ELProxy.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef ATHCONTAINERS_ELPROXY_H
#define ATHCONTAINERS_ELPROXY_H
 
 
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/PackedLinkVectorFactory.h"
#include "AthContainers/tools/PackedLinkConversions.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthLinks/DataLink.h"
#include "AthLinks/ElementLink.h"
#include "CxxUtils/range_with_at.h"
#include "CxxUtils/checker_macros.h"
#include <functional>
#include <ranges>
#include <concepts>
#include <vector>
 
 
namespace SG { namespace detail {
 
 
template <class CONT>
class ELProxyValBase
{
public:
  using Cont_t = CONT;
 
 
  ELProxyValBase (PackedLinkConverter<CONT>& cnv);
 
 
  ELProxyValBase (AuxVectorData& container,
                  SG::auxid_t auxid,
                  SG::auxid_t linked_auxid);
 
 
protected:
  PackedLinkConverter<CONT> m_cnv;
};
 
 
template <class CONT>
class ELProxyRefBase
{
public:
  using Cont_t = CONT;
 
  ELProxyRefBase (PackedLinkConverter<CONT>& cnv);
 
 
protected:
  PackedLinkConverter<CONT>& m_cnv;
};
 
 
template <class BASE>
class ELProxyT
  : public BASE
{
public:
  using Cont_t = typename BASE::Cont_t;
 
  using Link_t = ElementLink<Cont_t>;
 
  using PLink_t = SG::PackedLink<Cont_t>;
 
  ELProxyT (const ELProxyT&) = delete;
  ELProxyT& operator= (const ELProxyT&) = delete;
 
 
  ELProxyT (PLink_t& pl, PackedLinkConverter<Cont_t>& cnv);
 
 
  ELProxyT (PLink_t& pl, AuxVectorData& container,
            SG::auxid_t auxid,
            SG::auxid_t linked_auxid);
 
 
  operator const Link_t() const;
 
 
  const Link_t operator= (const Link_t& link);
 
 
  bool operator== (const Link_t& l) const;
 
 
  bool operator== (const ELProxyT& p) const;
 
 
  // nb. We don't proxy the implicit converison of ElementLink
  // to a pointer --- that can end up matching in places where we don't
  // want it to.
 
 
  // Proxy const methods of @c ElementLink.
#define ELPROXY(M) auto M() const { return this->m_cnv (m_pl).M(); }
  ELPROXY(getDataPtr)
  ELPROXY(getDataNonConstPtr)
  ELPROXY(getDataLink)
  ELPROXY(getStorableObjectPointer)
  ELPROXY(getStorableObjectRef)
  ELPROXY(cptr)
  ELPROXY(operator*)
  ELPROXY(operator->)
  ELPROXY(operator!)
  ELPROXY(isvalid)
  ELPROXY(cachedElement)
#ifndef XAOD_STANDALONE
  ELPROXY(isDefaultIndex)
#endif
  ELPROXY(hasCachedElement)
  ELPROXY(isDefault)
  ELPROXY(index)
  ELPROXY(persIndex)
  ELPROXY(dataID)
  ELPROXY(key)
  ELPROXY(persKey)
#ifndef XAOD_STANDALONE
  ELPROXY(source)
  ELPROXY(proxy)
#endif
#undef ELPROXY
 
 
private:
  PLink_t& m_pl;
};
 
 
//***************************************************************************
 
 
template <class PROXY>
class ELProxyConverter
  : public detail::PackedLinkConverter<typename PROXY::Cont_t>
{
public:
  using Base = detail::PackedLinkConverter<typename PROXY::Cont_t>;
  using Link_t = typename PROXY::Link_t;
  using PLink_t = typename PROXY::PLink_t;
  using value_type = typename PROXY::Link_t;
 
 
  ELProxyConverter (const Base& cnv);
 
 
  ELProxyConverter (AuxVectorData& container,
                    SG::auxid_t auxid,
                    SG::auxid_t linked_auxid);
 
  
  using Base::operator();
 
 
  PROXY operator() (PLink_t& pl);
};
 
 
template <class CONT>
using ELProxyInSpan = detail::ELProxyT<detail::ELProxyRefBase<CONT> >;
 
 
template <class CONT>
using ELProxyInSpanConverter =
  detail::ELProxyConverter<detail::ELProxyInSpan<CONT> >;
 
 
//***************************************************************************
 
 
template <class CONT, class PLINK_ALLOC>
using PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, PLINK_ALLOC>::span;
 
 
template <class CONT, class PLINK_ALLOC>
using ELSpanProxyBase =
  CxxUtils::transform_view_with_at<PackedLink_span<CONT, PLINK_ALLOC>,
                                   std::reference_wrapper<detail::ELProxyInSpanConverter<CONT> > >;
 
 
template <class CONT, class PLINK_ALLOC>
class ELSpanProxy
  : public ELSpanProxyBase<CONT, PLINK_ALLOC>
{
public:
  using Base = ELSpanProxyBase<CONT, PLINK_ALLOC>;
 
  using PLink_t = SG::PackedLink<CONT>;
 
  using Link_t = ElementLink<CONT>;
 
  using PackedLink_span = detail::PackedLink_span<CONT, PLINK_ALLOC>;
 
  using VElt_t = std::vector<SG::PackedLink<CONT>, PLINK_ALLOC>;
 
  using iterator = std::ranges::iterator_t<Base>;
 
 
  ELSpanProxy (VElt_t& velt, AuxVectorData& container,
               SG::auxid_t auxid,
               SG::auxid_t linked_auxid);
 
 
  template <ElementLinkRange<CONT> RANGE>
  void operator= (const RANGE& r);
 
 
  template <class VALLOC>
  operator std::vector<Link_t, VALLOC>() const;
 
 
  std::vector<Link_t> asVector() const;
 
 
  template <class VALLOC>
  bool operator== (const std::vector<Link_t, VALLOC>& v) const;
 
 
  void push_back (const Link_t& l);
 
 
  void clear();
 
 
  void resize (size_t n, const Link_t& l = Link_t());
 
 
  void erase (iterator pos);
 
 
  void erase (iterator first, iterator last);
 
 
  void insert (iterator pos, const Link_t& l);
 
 
  void insert (iterator pos, size_t n, const Link_t& l);
 
 
  template <CxxUtils::detail::InputValIterator<ElementLink<CONT> > ITERATOR>
  void insert (iterator pos, ITERATOR first, ITERATOR last);
 
 
  template <ElementLinkRange<CONT> RANGE>
  void insert_range (iterator pos, const RANGE& range);
 
 
  template <ElementLinkRange<CONT> RANGE>
  void append_range (const RANGE& range);
 
 
  void pop_back();
 
 
  void assign (size_t n, const Link_t& l);
 
 
  template <CxxUtils::detail::InputValIterator<ElementLink<CONT> > ITERATOR>
  void assign (ITERATOR first, ITERATOR last);
 
 
  template <ElementLinkRange<CONT> RANGE>
  void assign_range (const RANGE& range);
 
 
private:
  VElt_t& m_velt;
 
  ELProxyInSpanConverter<CONT> m_cnv;
};
 
 
//***************************************************************************
 
 
template <class CONT, class PLINK_ALLOC>
class ELSpanConverter
{
public:
  using value_type = ELSpanProxy<CONT, PLINK_ALLOC>;
  using VElt_t = typename value_type::VElt_t;
 
  /***
   * @brief Constructor.
   * @param container Container holding the variables.
   * @param auxid The ID of the PackedLink variable.
   * @param linked_auxid The ID of the linked DataLinks.
   */
  ELSpanConverter (AuxVectorData& container,
                   auxid_t auxid,
                   auxid_t linked_auxid);
 
 
  value_type operator() (VElt_t& velt) const;
 
 
private:
  AuxVectorData& m_container;
 
  auxid_t m_auxid;
 
  auxid_t m_linkedAuxid;
};
 
 
}} // namespace SG::detail
 
 
#include "AthContainers/tools/ELProxy.icc"
 
 
#endif // not ATHCONTAINERS_ELPROXY_H