AthLinks/DataLinkBase.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_DATALINKBASE_H
#define ATHLINKS_DATALINKBASE_H
 
 
#include "AthLinks/tools/DataProxyHolder.h"
#include "AthLinks/exceptions.h"
#include "AthContainersInterfaces/ToTransient.h"
 
 
class EventContext;
 
 
namespace SG {
class DataProxy;
template <class INDEXING_POLICY> class GenericElementLinkBase;
}
class IProxyDict;
 

class DataLinkBase
{
public:
  typedef SG::DataProxyHolder::sgkey_t sgkey_t;

  typedef SG::DataProxyHolder::ID_type ID_type;
 
  typedef SG::DataProxyHolder::pointer_t       pointer_t;
  typedef SG::DataProxyHolder::const_pointer_t const_pointer_t;

  typedef SG::DataProxyHolder::castfn_t        castfn_t;
 

  bool isDefault() const;
 

  const ID_type& dataID() const;
 

  sgkey_t key() const;
 

  void clear();
 

  SG::DataProxy* proxy (bool nothrow = false) const;
 

  IProxyDict* source() const;
 
 
  
  bool toTransient (IProxyDict* sg = 0);
 

  bool toTransient (const EventContext& ctx);
 

  bool toTransient (const ID_type& dataID, CLID link_clid, IProxyDict* sg = 0);
 

  bool toTransient (const ID_type& dataID, CLID link_clid,
                    const EventContext& ctx);
 

  bool toPersistent();
 

  bool toPersistentNoRemap();
 

  bool operator== (const DataLinkBase& other) const;
 

  bool operator!= (const DataLinkBase& other) const;
 
 
 
protected:
  // To get m_proxy from the ctors taking a DataLink+index.
  friend class ElementLinkBase;
  template <class INDEXING_POLICY> friend class SG::GenericElementLinkBase;

  friend class DataLinkBase_test;
 

  DataLinkBase();
 

  DataLinkBase (const_pointer_t obj, CLID link_clid, IProxyDict* sg);
 

  DataLinkBase (const ID_type& dataID, CLID link_clid, IProxyDict* sg);
 

  DataLinkBase (sgkey_t key, CLID link_clid, IProxyDict* sg);
 

  DataLinkBase (sgkey_t key, const SG::DataProxyHolder& holder);
 

  void toStorableObject (const_pointer_t obj,
                         CLID clid_in,
                         IProxyDict* sg);
 

  void toIdentifiedObject (const ID_type& dataID,
                           CLID clid,
                           IProxyDict* sg);
 

  void toIdentifiedObject (sgkey_t key,
                           CLID clid,
                           IProxyDict* sg);
 

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

  void throwInvalidLink() const;
 
 
 
private:
  sgkey_t m_persKey;

  SG::DataProxyHolder m_proxy;  
};
 
 
namespace SG {
 
 
inline
bool toTransient (DataLinkBase& dl, IProxyDict* sg)
{
  dl.toTransient (sg);
  return true;
}
 
 
inline
bool toTransient (DataLinkBase& dl, const EventContext& ctx)
{
  dl.toTransient (ctx);
  return true;
}
 
 
} // namespace SG
 
 
#include "AthLinks/DataLinkBase.icc"
 
 
#endif // not ATHLINKS_DATALINKBASE_H