AthLinks/ElementLink.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-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef ATHLINKS_ELEMENTLINK_H
#define ATHLINKS_ELEMENTLINK_H
 
 
#include "AthLinks/tools/ElementLinkTraits.h"
#include "AthLinks/DataLink.h"
#include "AthContainersInterfaces/ToTransient.h"
#include "AthenaKernel/proxyDictFromEventContext.h"
#include <format>
#include <utility>
#include <vector>
 
 
class IProxyDict;
class EventContext;
 

template <class STORABLE>
class ElementLink
  : public SG::ElementLinkTraits<STORABLE>::Base
{
private:
  typedef SG::ElementLinkTraits<STORABLE> Traits;

  typedef typename Traits::Base Base;

  typedef typename Base::castfn_t castfn_t;
 
 
public:
  typedef typename Traits::IndexingPolicy IndexingPolicy;

  typedef typename IndexingPolicy::index_type index_type; 

  typedef typename Base::sgkey_t sgkey_t;

  typedef typename Base::ID_type ID_type;

  typedef STORABLE                      value_type;
  typedef STORABLE*                     pointer;
  typedef const STORABLE*               const_pointer;
  typedef const STORABLE& BaseConstReference;
  typedef const STORABLE* BaseConstPointer;
 

  typedef typename IndexingPolicy::ElementType ElementType;
  typedef typename IndexingPolicy::ElementConstReference ElementConstReference;
  typedef typename IndexingPolicy::ElementConstPointer ElementConstPointer;
 

  static CLID classID();
 
 
  //========================================================================
 

  ElementLink();
 

  ElementLink(const ID_type& dataID, index_type elemID,
              IProxyDict* sg = 0);
 

  ElementLink(const ID_type& dataID, index_type elemID,
              const EventContext& ctx);
 

  ElementLink(sgkey_t key, index_type elemID, IProxyDict* sg = 0);
 

  ElementLink(sgkey_t key, index_type elemID, const EventContext& ctx);
 

  ElementLink(const ID_type& dataID,
              index_type elemID,
              ElementType pEl,
              IProxyDict* sg = 0);
 

  ElementLink(const ID_type& dataID,
              index_type elemID,
              ElementType pEl,
              const EventContext& ctx);
 

  ElementLink (sgkey_t key,
               index_type elemID,
               ElementType pEl,
               IProxyDict* sg = 0);
 

  ElementLink (sgkey_t key,
               index_type elemID,
               ElementType pEl,
               const EventContext& ctx);
 

  ElementLink (BaseConstReference data,
               index_type elemID, 
               IProxyDict* sg = 0);
 

  ElementLink (BaseConstReference data,
               index_type elemID, 
               const EventContext& ctx);
 

  ElementLink (const ElementType& element, 
               BaseConstReference data,
               IProxyDict* sg = 0);
 

  ElementLink (const ElementType& element, 
               BaseConstReference data,
               const EventContext& ctx);
 

  ElementLink (const ElementLink& other, index_type elemID);
 

  ElementLink (const DataLink<STORABLE>& dlink, index_type index);
 
 
  // Use default copy ctor.
 

  template <class U>
  ElementLink (const ElementLink<U>& other);
 
 
  // Default copy and assignment.
  ElementLink (const ElementLink&) = default;
  ElementLink& operator= (const ElementLink&) = default;
 
 
  //@)
  //========================================================================
 

  const_pointer getDataPtr() const;
 

  pointer getDataNonConstPtr();
 

  DataLink<STORABLE> getDataLink();
 

  const DataLink<STORABLE> getDataLink() const;
 

  BaseConstPointer getStorableObjectPointer() const;
 

  BaseConstReference getStorableObjectRef() const;
 

  ElementConstPointer cptr() const;
 

  ElementConstReference operator* () const;
 

  ElementConstPointer operator->() const;
 

  operator ElementConstPointer () const;
 

  bool isValid() const;
 

  bool operator!() const;
 

  ElementType cachedElement() const;
 
 
 
  //@)
  //========================================================================
 

  bool toIndexedElement(BaseConstReference data, index_type elemID,
                        IProxyDict* sg = 0);
 

  bool toIndexedElement(BaseConstReference data, index_type elemID,
                        const EventContext& ctx);
 

  bool toContainedElement(BaseConstReference data,
                          ElementType element,
                          IProxyDict* sg = 0);
 

  bool toContainedElement(BaseConstReference data,
                          ElementType element,
                          const EventContext& ctx);
 

  bool setElement(ElementType element);
 

  bool setStorableObject(BaseConstReference data,
                         bool replace=false,
                         IProxyDict* sg = 0);
 

  bool setStorableObject(BaseConstReference data,
                         bool replace,
                         const EventContext& ctx);
 

  bool setStorableObject(BaseConstReference data,
                         const EventContext& ctx);
 

  void resetWithKeyAndIndex(const ID_type& dataID, index_type elemID, 
                            IProxyDict* sg=0);
 

  void resetWithKeyAndIndex(const ID_type& dataID, index_type elemID, 
                            const EventContext& ctx);
 

  void resetWithKeyAndIndex(sgkey_t key, index_type elemID, 
                            IProxyDict* sg=0);
 

  void resetWithKeyAndIndex(sgkey_t key, index_type elemID, 
                            const EventContext& ctx);
 

 
 
  // Inherited from base class:
  //  bool isDefaultIndex() const
  //   Test the index validity.
  //  bool hasCachedElement() const
  //   Test to see if this link has a cached element pointer.
  //  bool isDefault() const
  //   Test to see if this link is in the default state.
  //  index_type index() const
  //   Return the index of the link.
  //  ID_type dataID() const
  //   Return the SG key that we reference, as a string.
  //  sgkey_t key() const
  //   Return the SG key that we reference, as a hash.
  //  IProxyDict* source() const
  //   Return the data source for the reference.
  //  void reset()
  //   Reset the link to a null state.
  //  bool toTransient (IProxyDict*)
  //   Finish initialization after link has been read.
  //  bool doPersistent()
  //   Prepare this link for writing.
  //  bool thin()
  //  bool thin(const SG::ThinningCache* thinningCache)
  //   Adjust for thinning.
 
 
private:
  const void* storable() const;
 

  void* storableNonConst();
};
 

template <typename STORABLE>
bool operator < (const ElementLink<STORABLE>& lhs,
                 const ElementLink<STORABLE>& rhs);
 

template <typename STORABLE>
bool operator > (const ElementLink<STORABLE>& lhs,
         const ElementLink<STORABLE>& rhs);
 

template <typename STORABLE>
bool operator == (const ElementLink<STORABLE>& lhs,
          const ElementLink<STORABLE>& rhs);
 

template <typename STORABLE>
bool operator != (const ElementLink<STORABLE>& lhs,
          const ElementLink<STORABLE>& rhs);
 
 
namespace SG_detail {
 

bool checkForRemap (IProxyDict* sg,
                    SG::sgkey_t sgkey_in,
                    size_t index_in,
                    SG::sgkey_t& sgkey_out,
                    size_t& index_out);
 

template <class T>
inline
bool checkForRemap (IProxyDict* sg,
                    SG::sgkey_t sgkey_in,
                    const T& /*dum_in*/,
                    SG::sgkey_t& sgkey_out,
                    T& /*dum_out*/);
 
 
} // namespace SG_detail
 
 
namespace SG {
 

template <class STORABLE>
class ToTransient<ElementLink<STORABLE> >
{
public:
  static void toTransient (ElementLink<STORABLE>& el,
                           IProxyDict* sg = nullptr);
  static void toTransient (ElementLink<STORABLE>& el,
                           const EventContext& ctx);
};
 

template <class STORABLE, class ALLOC>
class ToTransient<std::vector<ElementLink<STORABLE>, ALLOC> >
{
public:
  static void toTransient (std::vector<ElementLink<STORABLE>, ALLOC>& elv,
                           IProxyDict* sg = nullptr);
  static void toTransient (std::vector<ElementLink<STORABLE>, ALLOC>& elv,
                           const EventContext& ctx);
};
 
 

template <class STORABLE, class ALLOC1, class ALLOC2>
class ToTransient<std::vector<std::vector<ElementLink<STORABLE>, ALLOC1>, ALLOC2> >
{
public:
  static void toTransient (std::vector<std::vector<ElementLink<STORABLE>, ALLOC1>, ALLOC2>& elvv,
                           IProxyDict* sg = nullptr);
  static void toTransient (std::vector<std::vector<ElementLink<STORABLE>, ALLOC1>, ALLOC2>& elvv,
                           const EventContext& ctx);
};
 
 
 
} // namespace SG
 
 
namespace std {
 
 
// C++20 compatible formatter.
template <class T>
struct formatter<ElementLink<T> >
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const ElementLink<T>& k, FmtContext& ctx) const
  {
    if (k.isDefault()) {
      return formatter<string_view>::format ("(nullLink)", ctx);
    }
    return format_to (ctx.out(), "@{}[{}]", k.dataID(), k.index());
  }
};
 
 
} // namespace std
 
 
#include "AthLinks/ElementLink.icc"
 
 
#endif // not ATHLINKS_ELEMENTLINK_H