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-2023 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 "AthenaKernel/getThinningCache.h"
#include "CxxUtils/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;    
};
 
 
#include "AthLinks/ElementLinkBase.icc"
 
 
#endif // not ATHLINKS_ELEMENTLINKBASE_H