AthLinks/ElementLinkBase.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-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef ATHLINKS_ELEMENTLINKBASE_H
#define ATHLINKS_ELEMENTLINKBASE_H
 
 
#include "AthLinks/tools/DataProxyHolder.h"
#include "AthLinks/tools/ForwardIndexingPolicy.h"
#include "AthLinks/DataLinkBase.h"
#include "AthContainersInterfaces/ToTransient.h"
#include "AthenaKernel/getThinningCache.h"
#include "AthenaKernel/proxyDictFromEventContext.h"
#include "SGCore/sgkey_t.h"
#include "CxxUtils/CachedPointer.h"
#include <cstdlib>
#include <stdint.h>
 
 
namespace SG {
  class ThinningCache;
}
 

class ElementLinkBase
{
private:
  static const uint32_t INVALID = static_cast<uint32_t> (-1);

  typedef const void* ElementType;

  typedef SG::DataProxyHolder::const_pointer_t const_pointer_t;
 
 
public:
  typedef size_t index_type;

  typedef uint32_t stored_index_type;

  typedef SG::DataProxyHolder::sgkey_t sgkey_t;

  typedef SG::DataProxyHolder::ID_type ID_type;

  typedef void* castfn_t (SG::DataProxy*);
 
 
  ElementLinkBase (const ElementLinkBase&) = default;
  ElementLinkBase& operator= (const ElementLinkBase&) = default;
 

  bool isDefaultIndex() const;
 

  bool hasCachedElement() const;
 

  bool isDefault() const;
 

  index_type index() const;
 

  stored_index_type persIndex() const;
 

  const ID_type& dataID() const;
 

  sgkey_t key() const;
 

  sgkey_t persKey() const;
 

  IProxyDict* source() const;
 

  const SG::DataProxy* proxy() const;
 

  void reset ();
 

  bool toTransient (IProxyDict* sg = 0);
 

  bool toPersistent();
 

  bool thin();
 

  bool thin (const SG::ThinningCache* thinningCache);
 

  ElementLinkBase();
 
 
protected:
  ElementLinkBase (const ID_type& dataID,
                   CLID link_clid,
                   index_type elemID,
                   IProxyDict* sg);
 

  ElementLinkBase (sgkey_t key,
                   CLID link_clid,
                   index_type elemID,
                   IProxyDict* sg);
 
 

  ElementLinkBase (const ID_type& dataID,
                   CLID link_clid,
                   index_type elemID,
                   const void* elt,
                   IProxyDict* sg);
 

  ElementLinkBase (sgkey_t key,
                   CLID link_clid,
                   index_type elemID,
                   const void* elt,
                   IProxyDict* sg);
 

  ElementLinkBase (const_pointer_t obj,
                   CLID link_clid,
                   index_type elemID,
                   IProxyDict* sg);
 

  ElementLinkBase (const ElementLinkBase& other, index_type elemID);
 

  ElementLinkBase (const DataLinkBase& dlink, index_type index);
 

  template <class FROM_TRAITS, class TO_TRAITS>
  ElementLinkBase (const ElementLinkBase& other,
                   FROM_TRAITS*, TO_TRAITS*);
 

  void* storableBase (castfn_t* castfn, CLID clid, bool isConst) const;
 

  bool setStorableObject (const_pointer_t data,
                          CLID link_clid,
                          bool replace,
                          IProxyDict* sg);
 

  bool toIndexedElement (const_pointer_t obj,
                         CLID link_clid,
                         index_type elemID,
                         IProxyDict* sg);
 

  void resetWithKeyAndIndex (const ID_type& dataID,
                             CLID link_clid,
                             index_type elemID,
                             IProxyDict* sg);
 

  void resetWithKeyAndIndex (sgkey_t key,
                             CLID link_clid,
                             index_type elemID,
                             IProxyDict* sg);
 

  void setIndex (index_type index);
 

  const stored_index_type& storedIndex() const;
 

  void setCachedElement (ElementType elt) const;
 

  void storeCachedElement (ElementType elt);
 

  template <class T>
  bool getCachedElement (const T* & elt) const;
 

  const SG::DataProxyHolder& proxyHolder() const;
 
 
private:
  friend class ElementLinkBase_test;

  void clearCachedElement();

  SG::sgkey_t m_persKey;

  stored_index_type m_persIndex;

  SG::DataProxyHolder m_proxy;  
 
  CxxUtils::CachedPointer<void>  m_element;    
};
 
 
namespace SG {
 
 
inline
bool toTransient (ElementLinkBase& el, IProxyDict* sg)
{
  el.toTransient (sg);
  return true;
}
 
 
inline
bool toTransient (ElementLinkBase& el, const EventContext& ctx)
{
  el.toTransient (Atlas::proxyDictFromEventContext (ctx));
  return true;
}
 
 
} // namespace SG
 
 
#include "AthLinks/ElementLinkBase.icc"
 
 
#endif // not ATHLINKS_ELEMENTLINKBASE_H