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-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHLINKS_DATAPROXYHOLDER_H
#define ATHLINKS_DATAPROXYHOLDER_H
 
 
#include "CxxUtils/sgkey_t.h"
#include "SGTools/CurrentEventStore.h"
#include "SGTools/DataProxy.h"
#include "AthenaKernel/IStringPool.h"
#include "AthenaKernel/RCUObject.h"
#include "CxxUtils/checker_macros.h"
#include <string>
#include <unordered_map>
 
 
namespace SG {
 
 
class ThinningCache;
 
 
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 = 0);
 
 
  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