DataProxyHolder.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_DATAPROXYHOLDER_H
#define ATHLINKS_DATAPROXYHOLDER_H
 
 
#include "SGCore/sgkey_t.h"
#include "GaudiKernel/ClassID.h"
#include <string>
#include <unordered_map>
#include <cassert>
 
 
class IProxyDict;
 
 
namespace SG {
 
 
class ThinningCache;
class DataProxy;
 

class DataProxyHolder
{
public:
  using sgkey_t = SG::sgkey_t;

  using ID_type = std::string;

  using pointer_t       = void*;
  using const_pointer_t = const void*;

  typedef void* castfn_t (SG::DataProxy*);
 

  DataProxyHolder();
 

  template <class FROM_STORABLE, class TO_STORABLE>
  DataProxyHolder (const DataProxyHolder& other, FROM_STORABLE*, TO_STORABLE*);
 
 
  DataProxyHolder (const DataProxyHolder&) = default;
  DataProxyHolder& operator= (const DataProxyHolder&) = default;
 

  void clear();
 

  sgkey_t toStorableObject (const_pointer_t obj,
                            CLID link_clid,
                            IProxyDict* sg);
 

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

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

  bool isDefault() const;
 

  const ID_type& dataID() const;
 

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

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

  IProxyDict* source() const;
 

  void toTransient (sgkey_t sgkey,
                    IProxyDict* sg = nullptr,
                    bool noDummy = false);
 

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

  void toPersistentNoRemap (sgkey_t& sgkey);
 

  bool toPersistent (sgkey_t& sgkey, uint64_t& index);
 

  bool toPersistent (sgkey_t& sgkey, uint32_t& index);
 

  template <class T>
  bool toPersistent (sgkey_t& sgkey, const T& /*index*/);
 

  static
  bool thin (sgkey_t& sgkey, size_t& index,
             const SG::ThinningCache* thinningCache);
 

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

  void throwInvalidLink (sgkey_t sgkey) const;
 
 
private:
  bool isObjpointer() const;
 

  pointer_t objpointer() const;
 

  void storeObjpointer (const_pointer_t p);
 

  SG::DataProxy* proxy1 (bool nothrow) const;
 

  IProxyDict* source1();
 

  bool tryRemap (sgkey_t& sgkey, size_t& index);
 

  SG::DataProxy* m_proxy; 
};
 
 
} // namespace SG
 
 
#include "AthLinks/tools/DataProxyHolder.icc"
 
 
#endif // not ATHLINKS_DATAPROXYHOLDER_H