StoreGateSvc.icc

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
/** @file StoreGateSvc.icc
 */
 
#ifndef STOREGATE_STOREGATESVC_ICC
#define STOREGATE_STOREGATESVC_ICC
#include "StoreGate/constraints/KeyConcept.h"
#include "AthContainersInterfaces/AuxStore_traits.h"
#include "AthenaKernel/ClassName.h"
#include "CxxUtils/checker_macros.h"
#include <vector>
 
/// macro to help writing the function calls.
/// first looks if there is a hive slot defined, otherwise forwards to the "serial" implementation
#define _SGXCALL(FUN,ARGS,ONERR)                                        \
  SGImplSvc* impl = this->currentStore();                               \
  if (impl) {                                                           \
    return impl->FUN ARGS;                                              \
  }                                                                     \
  return ONERR;
 
 
/// macro to help writing the function calls
#define _SGVOIDCALL(FUN,ARGS)                                           \
  SGImplSvc* impl = this->currentStore();                               \
  if (impl) {                                                           \
    impl->FUN ARGS;                                                     \
  }
 
 
inline
StoreID::type 
StoreGateSvc::storeID() const
{
  return m_storeID;
}
 
 
inline
SGImplSvc*
StoreGateSvc::currentStore() const {
  if (m_storeID == StoreID::EVENT_STORE) {
    SG::HiveEventSlot* slot = currentSlot();
    if (slot) return slot->pEvtStore;
  }
  return m_defaultStore;
}
 
 
inline
SG::DataProxy* 
StoreGateSvc::proxy(const CLID& id, const char* key) const {
  _SGXCALL( proxy, (id, key), 0 ); 
}
 
inline
SG::DataProxy* 
StoreGateSvc::proxy_exact (SG::sgkey_t sgkey) const { 
  _SGXCALL( proxy_exact, (sgkey), 0 ); 
}
 
///////////////////////////////////////////////////////////////////
// create an object and record it with key
//////////////////////////////////////////////////////////////////
template <typename T, typename TKEY, typename... ARGS>
SG::WPtr<T> 
StoreGateSvc::create(const TKEY& key, ARGS... constructorArgs) {
  T* pT = new T(constructorArgs...);
  if(!(this->record(pT, key).isSuccess())) {
    SG_MSG_ERROR ("create: problem recording created object @{} using key {}",
                  static_cast<void*>(pT), key);
    pT=0; //record will take care of deleting pT even if it fails
  }
  return pT;
}
///////////////////////////////////////////////////////////////////
// record an object with key
//////////////////////////////////////////////////////////////////
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::record(T* pObject, const TKEY& key)
{
  const bool ALLOWMODS(true);
  return record(pObject, key, ALLOWMODS); //allow mods by default
}
//-------------------------------------------------------------------
template <typename T, typename TKEY>
StatusCode StoreGateSvc::record(const T* pObject, const TKEY& key)
{
  const bool NOMODS(false);
  // Ok --- we hold objects as non-const pointers internally, but mark
  // them as const, so they can only be retrieved as const.
  T* pObject_nc ATLAS_THREAD_SAFE = const_cast<T*> (pObject);
  return record(pObject_nc, key, NOMODS);   // do not allow mods
}
 
//-------------------------------------------------------------------
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::record(T* pObject, const TKEY& key, 
                                bool allowMods, bool resetOnly, bool noHist)
{
  return record1 (SG::asStorable<T>(pObject), pObject, key,
                  allowMods, resetOnly, noHist);
}
 
 
//-------------------------------------------------------------------
 
 
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::record1(DataObject* obj,
                                 T* pObject, const TKEY& key, 
                                 bool allowMods, bool resetOnly, bool noHist)
requires KeyConcept<TKEY>
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRecord (ClassID_traits<T>::ID(), key);
  }
 
  // make sure the BaseInfo(Base) structure is initialized
  SG::BaseInfo<T>::baseinfo();
 
  // If s_isConst is set for this type, then we want to automatically
  // make it const when recorded.
  if (ClassID_traits<T>::s_isConst)
    allowMods = false;
 
  StatusCode sc = this->currentStore()->typeless_record( obj, key, pObject,
                                                         allowMods, resetOnly, noHist,
                                                         &typeid(T));
#ifndef NDEBUG
  if (sc.isSuccess()) {
    SG_MSG_DEBUG( 
                 "Recorded object @{} with key {} of type {} (CLID {})\n"
                 " in DataObject @{}\n"
                 " object {}modifiable when retrieved",
                 static_cast<void*>(pObject),
                 static_cast<std::string>(key),
                 ClassID_traits<T>::typeName(),
                 ClassID_traits<T>::ID(),
                 static_cast<void*>(obj),
                 (allowMods ? "" : "not "));
  }
#endif
 
  return sc;
}
 
 
//-------------------------------------------------------------------
 
 
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::overwrite1(DataObject* obj, T* pObject,
                                    const TKEY& key, 
                                    bool allowMods, bool noHist)
requires KeyConcept<TKEY>
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRecord (ClassID_traits<T>::ID(), key);
  }
 
  // make sure the BaseInfo(Base) structure is initialized
  SG::BaseInfo<T>::baseinfo();
 
  // If s_isConst is set for this type, then we want to automatically
  // make it const when recorded.
  if (ClassID_traits<T>::s_isConst) allowMods = false;
 
  StatusCode sc = this->currentStore()->typeless_overwrite(ClassID_traits<T>::ID(),
                                                           obj, key, 
                                                           pObject, allowMods,  noHist,
                                                           &typeid(T));
#ifndef NDEBUG
  if (sc.isSuccess()) {
    SG_MSG_DEBUG("overwrite: Recorded object @{} with key {} of type {} (CLID {})\n"
                 " in DataObject @{}\n"
                 " object {}modifiable when retrieved",
                 static_cast<void*>(pObject),
                 static_cast<std::string>(key),
                 ClassID_traits<T>::typeName(),
                 ClassID_traits<T>::ID() ,
                 static_cast<void*>(obj),
                 (allowMods ? "" : "not "));
  }
#endif
  return sc;
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the default object (with no key) as a const pointer
//////////////////////////////////////////////////////////////////
template <typename T> 
StatusCode StoreGateSvc::retrieve(const T*& ptr) const
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), "");
  }
 
  SG::DataProxy* dp =proxy(ClassID_traits<T>::ID());
  if (!dp || !dp->isValid()) {
    SG_MSG_WARNING ("retrieve(default): No valid proxy for default object \n" 
                    " of type {} (CLID {})",
                    ClassID_traits<T>::typeName(),
                    ClassID_traits<T>::ID());
    return StatusCode::FAILURE;
  }
  ptr = SG::DataProxy_cast<T> (dp);
  if (!ptr) {
    return StatusCode::FAILURE;
  }
 
  //for types with an associated store, try to retrieve it and associate it
  this->associateAux (ptr, SG::DEFAULTKEY);
#ifndef NDEBUG
  SG_MSG_DEBUG("retrieve(default): Retrieved const pointer to default object \n"
               " of type {} (CLID {})",
               ClassID_traits<T>::typeName() ,
               ClassID_traits<T>::ID());
#endif
 
  return StatusCode::SUCCESS;
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the default object (with no key) as a pointer (non-const)
//////////////////////////////////////////////////////////////////
template <typename T> 
StatusCode StoreGateSvc::retrieve(T*& ptr) const
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), "");
  }
 
  SG::DataProxy* dp =proxy(ClassID_traits<T>::ID());
  if (!dp || !dp->isValid() || dp->isConst()) {
    SG_MSG_WARNING ("retrieve(default): No valid proxy for default object " 
                    " of type {} (CLID {})\n Try to use a const retrieve ",
                    ClassID_traits<T>::typeName(),
                    ClassID_traits<T>::ID());
    return StatusCode::FAILURE;
  }
  ptr = SG::DataProxy_cast<T> (dp);
  if (!ptr) {
    return StatusCode::FAILURE;
  }
 
  //for types with an associated store, try to retrieve it and associate it
  this->associateAux (ptr, SG::DEFAULTKEY);
#ifndef NDEBUG
  SG_MSG_DEBUG("retrieve(default): Retrieved non-const pointer to default object \n" 
               " of type {} (CLID {})",
               ClassID_traits<T>::typeName() ,
               ClassID_traits<T>::ID());
#endif
 
  return StatusCode::SUCCESS;
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the keyed object as a const pointer
// Overload for std::string key type
//////////////////////////////////////////////////////////////////
template <typename T>
StatusCode StoreGateSvc::retrieve(const T*& ptr, const std::string& key) const
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), key);
  }
 
  SG::DataProxy* dp =proxy (ClassID_traits<T>::ID(),
                            key,
                            false);
  if (!dp || !dp->isValid()) {
    SG_MSG_WARNING ("retrieve(const): "
                    "No valid proxy for object {} of type {} (CLID {})",
                    key,
                    ClassID_traits<T>::typeName(),
                    ClassID_traits<T>::ID());
    return StatusCode::FAILURE;
  }
  ptr = SG::DataProxy_cast<T> (dp);
  if (!ptr) {
    return StatusCode::FAILURE;
  }
 
  //for types with an associated store, try to retrieve it and associate it
  this->associateAux (ptr, key);
#ifndef NDEBUG
  SG_MSG_DEBUG ("Retrieved const pointer to object {} of type {} (CLID {})",
                key,
                ClassID_traits<T>::typeName(),
                ClassID_traits<T>::ID());
#endif
 
  return StatusCode::SUCCESS;
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the keyed object as a const pointer
//////////////////////////////////////////////////////////////////
template <typename T, typename TKEY>
StatusCode StoreGateSvc::retrieve(const T*& ptr, const TKEY& key) const
requires KeyConcept<TKEY>
{
  return this->retrieve(ptr, static_cast<std::string>(key));
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the keyed object as a non-const pointer
// Overload for std::string key type
//////////////////////////////////////////////////////////////////
template <typename T>
StatusCode StoreGateSvc::retrieve(T*& ptr, const std::string& key) const
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), key);
  }
 
  SG::DataProxy* dp =proxy (ClassID_traits<T>::ID(),
                            key,
                            false);
  if (!dp || !dp->isValid() || dp->isConst()) {
    SG_MSG_WARNING("retrieve(non-const): No valid proxy for object {} of type {} (CLID {})\n"
                   " Try to use a const retrieve",
                   key,
                   ClassID_traits<T>::typeName(),
                   ClassID_traits<T>::ID());
    return StatusCode::FAILURE;
  }
  ptr = SG::DataProxy_cast<T> (dp);
  if (!ptr) {
    return StatusCode::FAILURE;
  }
 
  //for types with an associated store, try to retrieve it and associate it
  this->associateAux (ptr, key);
#ifndef NDEBUG
  SG_MSG_DEBUG("Retrieved non-const pointer to object {} of type {} (CLID {})",
               static_cast<std::string>(key),
               ClassID_traits<T>::typeName(),
               ClassID_traits<T>::ID());
#endif
 
  return StatusCode::SUCCESS;
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the keyed object as a non-const pointer
//////////////////////////////////////////////////////////////////
template <typename T, typename TKEY>
StatusCode StoreGateSvc::retrieve(T*& ptr, const TKEY& key) const
requires KeyConcept<TKEY>
{
  return this->retrieve(ptr, static_cast<std::string>(key));
}
 
/// Retrieve all objects of type T: returns an SG::ConstIterator range
template <typename T> 
StatusCode 
StoreGateSvc::retrieve(SG::ConstIterator<T>& begin, 
                       SG::ConstIterator<T>& end) const {
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), "(iterator)");
  }
  _SGXCALL(retrieve, (ClassID_traits<T>::ID(), begin, end), StatusCode::FAILURE);
}
 
 
/**
 * @brief Retrieve an object of type @c T from StoreGate.
 *        Return 0 if not found.
 **/
 
template <typename T>
T* StoreGateSvc::retrieve () const
{
  T* p = 0;
  retrieve (p).ignore();
  return p;
}
 
/**`<
 * @brief Retrieve an object of type @c T from StoreGate.
 *        Return 0 if not found.
 * @param key The key to use for the lookup.
 **/
template <typename T, class TKEY>
T* StoreGateSvc::retrieve (const TKEY& key) const
{
  T* p = 0;
  retrieve (p, key).ignore();
  return p;
}
 
/**
 * @brief Retrieve an object of type @c T from StoreGate.
 *        Return 0 if not found.
 **/
template <typename T>
T* StoreGateSvc::tryRetrieve () const
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), "");
  }
 
  SG::DataProxy* dp = proxy (ClassID_traits<T>::ID());
  if (dp && dp->isValid() && !dp->isConst()) {
    T* ptr = SG::DataProxy_cast<T> (dp);
    if (ptr) {
      this->associateAux (ptr, SG::DEFAULTKEY);
      return ptr;
    }
  }
  return nullptr;
}
 
template <typename T>
const T* StoreGateSvc::tryConstRetrieve() const
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), "");
  }
 
  SG::DataProxy* dp = proxy (ClassID_traits<T>::ID());
  if (dp && dp->isValid()) {
    const T* ptr = SG::DataProxy_cast<T> (dp);
    if (ptr) {
      this->associateAux (ptr, SG::DEFAULTKEY);
      return ptr;
    }
  }
  return nullptr;
}
 
/**
 * @brief Retrieve an object of type @c T from StoreGate.
 *        Return 0 if not found. Don't print any WARNINGs
 * @param key The key to use for the lookup.
 **/
template <typename T, class TKEY>
T* StoreGateSvc::tryRetrieve (const TKEY& key) const
requires KeyConcept<TKEY>
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), key);
  }
  SG::DataProxy* dp = proxy (ClassID_traits<T>::ID(),
                             static_cast<std::string> (key),
                             false);
  if (dp && dp->isValid() && !dp->isConst()) {
    T* ptr = SG::DataProxy_cast<T> (dp);
    if (ptr) {
      this->associateAux (ptr, key);
      return ptr;
    }
  }
  return nullptr;
}
 
template <typename T, class TKEY>
const T* StoreGateSvc::tryConstRetrieve (const TKEY& key) const
requires KeyConcept<TKEY>
{
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (ClassID_traits<T>::ID(), key);
  }
 
  SG::DataProxy* dp = proxy (ClassID_traits<T>::ID(),
                             static_cast<std::string> (key),
                             false);
  if (dp && dp->isValid()) {
    const T* ptr = SG::DataProxy_cast<T> (dp);
    if (ptr) {
      this->associateAux (ptr, key);
      return ptr;
    }
  }
  return nullptr;
}
 
template <typename T>
int StoreGateSvc::typeCount() const
{
  return typeCount(ClassID_traits<T>::ID());
}
 
 
template <typename T, typename TKEY> 
bool 
StoreGateSvc::contains(const TKEY& key) const 
{
  return this->contains(ClassID_traits<T>::ID(), key);
}
 
template <typename TKEY> 
bool 
StoreGateSvc::contains(const CLID& clid, const TKEY& key) const 
{
  _SGXCALL( contains, (clid,key), false );
}
 
template <typename T, typename TKEY> 
bool 
StoreGateSvc::transientContains(const TKEY& key) const 
{
  return transientContains(ClassID_traits<T>::ID(), key);
}
 
 
 
template <typename TKEY>
bool 
StoreGateSvc::transientContains(const CLID& id, const TKEY& key) const
{
  _SGXCALL(transientContains, (id, key), false);
}
 
//-------------------------end of contains methods--------------------
template <typename T>
void
StoreGateSvc::keys(std::vector<std::string>& vkeys, 
                   bool includeAlias, bool onlyValid) const {
  return this->keys(ClassID_traits<T>::ID(), vkeys, includeAlias, onlyValid);
} 
 
 
//-------------------------------------------------------------------
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::record(std::unique_ptr<T> pUnique, const TKEY& key)
{
  const bool ALLOWMODS(true);
  return record(std::move(pUnique), key, ALLOWMODS); //allow mods by default
}
//-------------------------------------------------------------------
template <typename T, typename TKEY>
StatusCode StoreGateSvc::record(std::unique_ptr<const T> pUnique,
                                const TKEY& key)
{
  const bool NOMODS(false);
  // Ok --- we hold objects as non-const pointers internally, but mark
  // them as const, so they can only be retrieved as const.
  T* ptr ATLAS_THREAD_SAFE = const_cast<T*> (pUnique.release());
  return record1(SG::asStorable (ptr), ptr,
                 key, NOMODS);   // do not allow mods
}
 
//-------------------------------------------------------------------
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::record(std::unique_ptr<T> pUnique, const TKEY& key, 
                                bool allowMods, bool resetOnly, bool noHist)
{
  T* ptr = pUnique.get();
  return record1 (SG::asStorable<T>(std::move(pUnique)), ptr, key,
                  allowMods, resetOnly, noHist);
}
 
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::overwrite(T* p2BRegistered, const TKEY& key)
{
  const bool ALLOWMODS(true);
  return overwrite(p2BRegistered, key, ALLOWMODS); //SG takes ownership
}
 
template <typename T, typename TKEY> 
StatusCode 
StoreGateSvc::overwrite(T* pObject, const TKEY& key, 
                        bool allowMods, bool noHist) 
{
  return overwrite1 (SG::asStorable<T>(pObject), pObject, key,
                     allowMods, noHist);
}
 
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::overwrite(std::unique_ptr<T> pUnique, const TKEY& key)
{
  const bool ALLOWMODS(true);
  return overwrite(std::move(pUnique), key, ALLOWMODS); //allow mods by default
}
 
template <typename T, typename TKEY> 
StatusCode StoreGateSvc::overwrite(std::unique_ptr<T> pUnique, const TKEY& key, 
                                   bool allowMods, bool noHist)
{
  T* ptr = pUnique.get();
  return overwrite1 (SG::asStorable<T>(std::move(pUnique)), ptr, key,
                     allowMods, noHist);
}
 
template <typename T, typename AKEY>
StatusCode StoreGateSvc::setAlias(const T* pObject, const AKEY& aKey)
requires KeyConcept<AKEY>
{
  _SGXCALL(setAlias, (pObject, aKey), StatusCode::FAILURE);
}
//-------------------------------------------------------------------
template <typename T, typename TKEY, typename AKEY>
StatusCode 
StoreGateSvc::setAlias(const T* /*dummy*/,
                       const TKEY& key, const AKEY& aKey)
requires KeyConcept<TKEY> && KeyConcept<AKEY>
{
  _SGXCALL(setAlias, (ClassID_traits<T>::ID(), key, aKey), StatusCode::FAILURE);
}
 
inline
StatusCode
StoreGateSvc::setAlias(SG::DataProxy* proxy, const std::string& aliasKey)
{
  _SGXCALL(setAlias, (proxy, aliasKey), StatusCode::FAILURE);
}
 
//////////////////////////////////////////////////////////////////
// Make a soft link to the object with key: return non_const link
//////////////////////////////////////////////////////////////////
template <typename T, typename TLINK> 
StatusCode 
StoreGateSvc::symLink(const T* pObject, TLINK* /*dummy*/)
{
  _SGXCALL(symLink, (pObject, ClassID_traits<TLINK>::ID()), StatusCode::FAILURE);
}
 
//////////////////////////////////////////////////////////////////
// Make a soft link to the object with key: set const link
//////////////////////////////////////////////////////////////////
template <typename T, typename TLINK> 
StatusCode 
StoreGateSvc::symLink(const T* pObject, const TLINK* /*dummy*/)
{
  _SGXCALL(symLink, (pObject, ClassID_traits<TLINK>::ID()), StatusCode::FAILURE);
}
 
template <KeyConcept TKEY> 
StatusCode 
StoreGateSvc::symLink(const CLID id, const TKEY& key, const CLID linkid)
{
  _SGXCALL(symLink, (id, key, linkid), StatusCode::FAILURE);
}
 
 
/// Remove pObject,  will remove its proxy if not reset only.
template <typename T>
StatusCode 
StoreGateSvc::remove(const T* pObject) {
  _SGXCALL(remove, (pObject), StatusCode::FAILURE);
}
 
/// Remove pObject and its proxy no matter what.         
template <typename T>    
StatusCode 
StoreGateSvc::removeDataAndProxy(const T* pObject)  {
  _SGXCALL(removeDataAndProxy, (pObject), StatusCode::FAILURE);
}
 
template <typename T, class TKEY>
StatusCode 
StoreGateSvc::retrieveHighestVersion(SG::ObjectWithVersion<T>& dobjWithVersion, 
                                     const TKEY& requestedKey) const
{
  std::list< SG::ObjectWithVersion<T> > allVersions;
  StatusCode sc(this->retrieveAllVersions(allVersions,requestedKey));
  if (sc.isSuccess()) {
    allVersions.sort(); // on highest version number
    dobjWithVersion.versionedKey.copyVK(allVersions.back().versionedKey.rawVersionKey());
  }
  return sc;
}
 
template <typename T, class TKEY>
StatusCode
StoreGateSvc::retrieveAllVersions(std::list< SG::ObjectWithVersion<T> >& allVersions,
                                  const TKEY& requestedKey) const
{
  StatusCode sc(StatusCode::FAILURE);
  SG::ConstIterator<T> i,e;
  if ((this->retrieve<T>(i,e)).isSuccess()){
    SG::VersionedKey reqVK(requestedKey);
    while (i != e) {
      SG::VersionedKey vk(i.key());
      if (reqVK.sameKey(vk)) {
        sc = StatusCode::SUCCESS;
        SG::ObjectWithVersion<T> okOWV(vk, i.proxy());
        allVersions.push_back(okOWV);
      }
      ++i;
    }
  }
  return sc;
}
 
 
template <typename T>
std::unique_ptr<T> 
StoreGateSvc::retrieveUniquePrivateCopy (const std::string& key)
{
  CLID clid = ClassID_traits<T>::ID();
  DataObject* obj = this->currentStore()->typeless_retrievePrivateCopy(clid, key);
  std::unique_ptr<T> ret (SG::Storable_cast<T>(obj));
  if (DataBucketBase* dbb = dynamic_cast<DataBucketBase*> (obj)) 
  {
    dbb->relinquish();
  }
  obj->release();
  return ret;
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the @c CLID of a given "key" 
// WARNING: slow!
//////////////////////////////////////////////////////////////////
template<typename TKEY>
CLID 
StoreGateSvc::clid( const TKEY& key ) const
{
  _SGXCALL(clid, (key), CLID_NULL);
}
 
//////////////////////////////////////////////////////////////////
// Retrieve the @c CLID s of a given "key" 
// WARNING: slow!
//////////////////////////////////////////////////////////////////
template<typename TKEY>
std::vector<CLID> 
StoreGateSvc::clids( const TKEY& key ) const
{
  std::vector<CLID> nullV;
  _SGXCALL(clids, (key), nullV);
}
 
///////////////////////////////////////////////////////////////////////////
 
inline
void 
StoreGateSvc::setProxyProviderSvc(IProxyProviderSvc* pPPSvc) {
  _SGVOIDCALL(setProxyProviderSvc, (pPPSvc));
}
 
 
inline
IProxyProviderSvc*
StoreGateSvc::proxyProviderSvc() {
  _SGXCALL(proxyProviderSvc, (), nullptr);
}
 
 
/**
 * @brief Return the metadata source ID for the current event slot.
 * @param key SG key of the DataHeader to query.
 *        Returns an empty string if no source has been set.
 *
 *        The default version always returns an empty string.
 */
inline
SG::SourceID
StoreGateSvc::sourceID (const std::string& key /*= "EventSelector"*/) const {
  _SGXCALL(sourceID, (key), "");
}
 
 
template <class TKEY>
void 
StoreGateSvc::remap (CLID clid,
                     const TKEY& source,
                     const TKEY& target,
                     off_t index_offset) {
  _SGVOIDCALL(remap_impl, (this->stringToKey (source, clid),
                           this->stringToKey (target, clid),
                           index_offset));
}
 
 
/**
 * @brief Remember that retrieve() was called for a MT store.
 * @param clid CLID of the operation.
 * @param key Key of the operation.
 */
inline
void StoreGateSvc::rememberBadRetrieve (CLID clid, const std::string& key) const
{
  rememberBad (m_badRetrieves, clid, key);
}
 
 
/**
 * @brief Remember that retrieve() was called for a MT store.
 * @param clid CLID of the operation.
 * @param key Key of the operation.
 */
inline
void StoreGateSvc::rememberBadRecord (CLID clid, const std::string& key) const
{
  rememberBad (m_badRecords, clid, key);
}
 
 
template <class DOBJ, class AUXSTORE>
bool StoreGateSvc::associateAux_impl (DOBJ* ptr,
                                      const std::string& key,
                                      const AUXSTORE*) const
{
  CLID auxclid = ClassID_traits<AUXSTORE>::ID();
  _SGXCALL( associateAux_impl, (ptr, key, auxclid), false);
}
 
 
template <class DOBJ>
bool StoreGateSvc::associateAux_impl (DOBJ* /*ptr*/,
                                      const std::string& /*key*/,
                                      const SG::NoAuxStore*) const
{
  return true;
}
 
 
/**
 * @brief associate a data object to its auxiliary store
 *        Return false if the aux store is not found.
 * @param key The key to use for the lookup.
 **/
template <class DOBJ>
bool StoreGateSvc::associateAux (DOBJ* ptr,
                                 const std::string& key,
                                 bool ignoreMissing) const
{
  typename SG::AuxStore_traits<DOBJ>::type* pDummy(0); //used to pass down auxstore type
  bool hasAux=associateAux_impl(ptr, key, pDummy) || ignoreMissing;
  if (!hasAux) {
    SG_MSG_WARNING("associateAux const: Could not associate AuxStore of type {}\n"
                   " to object of type {} (CLID {}) with key {}",
                   SG::AuxStore_traits<DOBJ>::const_typeName(),
                   ClassID_traits<DOBJ>::typeName(),
                   ClassID_traits<DOBJ>::ID(),
                   key);
  }
  return hasAux;
}
 
 
template <class DOBJ>
bool StoreGateSvc::associateAux (const DOBJ* ptr,
                                 const std::string& key,
                                 bool ignoreMissing) const
{
  typename SG::AuxStore_traits<DOBJ>::const_type* pDummy(0); //used to pass down auxstore type
  // Should generally be ok, since any actual modification is done
  // inside the store lock.  Still kind of a wart that we still do this, though.
  DOBJ* ptr_nc ATLAS_THREAD_SAFE = const_cast<DOBJ*> (ptr);
  bool hasAux=associateAux_impl(ptr_nc, key, pDummy) || ignoreMissing;
  if (!hasAux) {
    SG_MSG_WARNING("associateAux const: Could not associate AuxStore of type {}\n"
                   " to object of type {} (CLID {}) with key {}",
                   SG::AuxStore_traits<DOBJ>::const_typeName(),
                   ClassID_traits<DOBJ>::typeName(),
                   ClassID_traits<DOBJ>::ID(),
                   key);
  }
  return hasAux;
}
 
 
#endif //STOREGATE_STOREGATESVC_ICC