SGImplSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#undef DEBUG_SGIMPL
 
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <iostream>
#include <print>
#include <functional>
#include <format>
#include <string>
#include <unordered_map>
 
#include <sstream>
#include <fstream>
#include <iomanip>
 
#include "AthContainers/AuxVectorBase.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthenaKernel/IProxyProviderSvc.h"
#include "AthenaKernel/IIOVSvc.h"
#include "AthenaKernel/CLIDRegistry.h"
#include "AthenaKernel/errorcheck.h"
#include "AthenaKernel/StoreID.h"
#include "AthenaKernel/proxyDictFromEventContext.h"
#include "GaudiKernel/IClassIDSvc.h"
#include "GaudiKernel/IHistorySvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/DataHistory.h"
#include "SGTools/CurrentEventStore.h"
#include "AthenaKernel/DataBucketBase.h"
#include "SGTools/DataProxy.h"
#include "SGTools/DataStore.h"
#include "SGTools/StringPool.h"
#include "SGTools/TransientAddress.h"
#include "PersistentDataModel/DataHeader.h"
#include "StoreGate/StoreClearedIncident.h"
#include "AthAllocators/ArenaHeader.h"
#include "CxxUtils/checker_macros.h"
 
// StoreGateSvc. must come before SGImplSvc.h
#include "StoreGate/StoreGateSvc.h"
#include "StoreGate/tools/SGImplSvc.h"
#include "SGTools/DataStore.h"
 
using std::setw;
using std::hex;
using std::dec;
using std::endl;
using std::ends;
using std::pair;
using std::string;
using std::vector;
 
using SG::DataProxy;
using SG::DataStore;
using SG::TransientAddress;
 
// Helpers for debug formatting
// std::print implementation to be replaced when C++ 23 is available
namespace dbg {
template <class... Args> void print(std::FILE* stream, std::format_string<Args...> fmt, Args&&... args) {
  std::fputs(std::format(fmt, std::forward<Args>(args)...), stream);
}
 
template <class T> void* ptr(T* p) { return static_cast<void*>(p); }
}

// Remapping implementation.
 
 
namespace SG {
 
 
  struct RemapImpl
  {
    typedef IStringPool::sgkey_t sgkey_t;
 
    struct remap_t {
      sgkey_t target = 0;
      off_t index_offset = 0;
    };
    typedef SGKeyMap<remap_t> remap_map_t;
    remap_map_t m_remaps;
  };
 
 
} // namespace SG
 

SGImplSvc::SGImplSvc(const string& name,ISvcLocator* svc)
  : base_class(name, svc),
    m_pCLIDSvc("ClassIDSvc", name),
    m_pDataLoader("EventPersistencySvc", name),
    m_pPPSHandle("ProxyProviderSvc", name),
    m_pPPS(nullptr),
    m_pHistorySvc("HistorySvc", name),
    m_pStore(new DataStore(*this)),
    m_pIncSvc("IncidentSvc", name),
    m_DumpStore(false), 
    m_ActivateHistory(false),
    m_DumpArena(false),
    m_pIOVSvc("IOVSvc", name),
    m_storeLoaded(false),
    m_remap_impl (new SG::RemapImpl),
    m_arena (name),
    m_slotNumber(-1),
    m_numSlots(1)
{
  //our properties
  declareProperty("ProxyProviderSvc", m_pPPSHandle);
  declareProperty("Dump", m_DumpStore);
  declareProperty("ActivateHistory", m_ActivateHistory);
  declareProperty("DumpArena", m_DumpArena);
  //StoreGateSvc properties
  declareProperty("IncidentSvc", m_pIncSvc);
  //add handler for Service base class property
  m_outputLevel.declareUpdateHandler(&SGImplSvc::msg_update_handler, this);
  
  SG::ArenaHeader* header = SG::ArenaHeader::defaultHeader();
  header->addArena (&m_arena);
}
 

SGImplSvc::~SGImplSvc()  {
  SG::ArenaHeader* header = SG::ArenaHeader::defaultHeader();
  header->delArena (&m_arena);
 
  delete m_pStore;
  delete m_remap_impl;
}

StatusCode SGImplSvc::initialize()    {
 
  SG_MSG_VERBOSE ("Initializing {}", name());
 
  CHECK( Service::initialize() );
 
  if (!m_pStore)
    m_pStore = new DataStore (*this);
  if (!m_remap_impl)
    m_remap_impl = new SG::RemapImpl;
 
  //properties accessible from now on
  
  store()->setStoreID(StoreID::findStoreID(name()));
  // If this is the default event store (StoreGateSvc), then declare
  // our arena as the default for memory allocations.
  if (this->storeID() == StoreID::EVENT_STORE) {
    m_arena.makeCurrent();
    SG::CurrentEventStore::setStore (this);
    Atlas::setProxyDictInEventContext (this);
  }
  // set up the incident service:
  if (!(m_pIncSvc.retrieve()).isSuccess()) {
    SG_MSG_ERROR ("Could not locate IncidentSvc ");
    return StatusCode::FAILURE;
  }
 
  // We explicitly do not retrieve m_pIOVSvc and rely on retrieval
  // on first use to avoid an initialization loop here.
 
  CHECK( m_pDataLoader.retrieve() );
  CHECK( m_pCLIDSvc.retrieve() );
 
  if (!m_pPPSHandle.empty()) {
    CHECK( m_pPPSHandle.retrieve() );
    m_pPPS = &*m_pPPSHandle;
  }
 
  if ( m_pPPS && (m_pPPS->preLoadProxies(*m_pStore)).isFailure() )
    {
      SG_MSG_DEBUG(" Failed to preLoad proxies");
      return StatusCode::FAILURE;
    }
 
  // Get hold of History Service
  if (m_ActivateHistory) {
    CHECK( m_pHistorySvc.retrieve() );
  }
 
  return StatusCode::SUCCESS;
}

StatusCode SGImplSvc::start()    {
 
  SG_MSG_VERBOSE ("Start {}", name());
  /*
  // This will need regFcn clients to be updated first.
  if ( 0 == m_pPPS || (m_pPPS->preLoadProxies(*m_pStore)).isFailure() ) {
     SG_MSG_DEBUG (" Failed to preLoad proxies");
     return StatusCode::FAILURE;
  }
  */
 
  return StatusCode::SUCCESS;
}

StatusCode SGImplSvc::stop()    {
 
  SG_MSG_VERBOSE ("Stop {}", name());
  //HACK ALERT: ID event store objects refer to det store objects
  //by setting an ad-hoc priority for event store(s) we make sure they are finalized and hence cleared first
  // see e.g. https://savannah.cern.ch/bugs/index.php?99993
  if (store()->storeID() == StoreID::EVENT_STORE) {
    ISvcManager* pISM(dynamic_cast<ISvcManager*>(serviceLocator().get()));
    if (!pISM)
      return StatusCode::FAILURE;
    pISM->setPriority(name(), pISM->getPriority(name())+1).ignore();
    SG_MSG_VERBOSE ("stop: setting service priority to {} so that event stores get finalized and cleared before other stores",
                    pISM->getPriority(name()));
  }
  return StatusCode::SUCCESS;
}

void SGImplSvc::handle(const Incident &inc) {
 
  if (inc.type() == "EndEvent") { 
    if (m_DumpStore) {
      SG_MSG_DEBUG("Dumping StoreGate Contents");
      SG_MSG_INFO ("\n{}\n", dump());
    }
  }
}
 
StatusCode SGImplSvc::loadEventProxies() {
  lock_t lock (m_mutex);
  StatusCode sc(StatusCode::SUCCESS);
  //FIXME this should probably be dealt with by the providers
  if (0 != m_pPPS && !m_storeLoaded) {
    m_storeLoaded = true;
    sc=m_pPPS->loadProxies(*m_pStore);
#ifdef DEBUG_SGIMPL
    dbg::print(stderr, "SGImplSvc::loadEventProxies() LOADED PROXIES on {}\n", name());
  }
  else {
    dbg::print(stderr, "SGImplSvc::loadEventProxies() PROXIES ALREADY LOADED on {}\n", name());
#endif
  }
  return sc;
}

// Create a key for a type (used if the client has not specified a key)
string SGImplSvc::createKey(const CLID& id)
{
  return std::to_string(m_pStore->typeCount(id) + 1);
}

// clear store
StatusCode SGImplSvc::clearStore(bool forceRemove)
{
#ifdef DEBUG_SGIMPL
  dbg::print(stderr, "SGImplSvc::clearStore(forceRemove={}) on {}\n", forceRemove, name());
#endif
  {
    if (m_DumpArena) {
      std::ostringstream s;
      m_arena.report(s);
      SG_MSG_INFO ("Report for Arena: {}\n{}", m_arena.name(), s.str());
    }
  }
  {
    lock_t lock (m_mutex);
    emptyTrash();
    for (auto& p : m_newBoundHandles)
      p.second.clear();
    assert(m_pStore);
    SG_MSG_DEBUG ("Clearing store with forceRemove={}", forceRemove);
    bool hard_reset = (m_numSlots > 1);
    m_pStore->clearStore(forceRemove, hard_reset, &msgStream(MSG::DEBUG));
    m_storeLoaded=false;  //FIXME hack needed by loadEventProxies
  }
  {
    lock_t remap_lock (m_remapMutex);
    m_remap_impl->m_remaps.clear();
    m_arena.reset();
  }
 
  return StatusCode::SUCCESS;
}

StatusCode SGImplSvc::finalize()    {
  SG_MSG_VERBOSE ("Finalizing {}", name());
  
  // Incident service may not work in finalize.
  // Clear this, so that we won't try to send an incident from clearStore.
  (m_pIncSvc.release()).ignore();
  
  const bool FORCEREMOVE(true);
  clearStore(FORCEREMOVE).ignore();
  
  m_stringpool.clear();
  delete m_pStore;
  m_pStore = nullptr;
  delete m_remap_impl;
  m_remap_impl = 0;
  m_arena.erase();
 
  return Service::finalize();
}

StatusCode SGImplSvc::reinitialize()    {
  SG_MSG_VERBOSE ("Reinitializing {}", name());
  const bool FORCEREMOVE(true);
  clearStore(FORCEREMOVE).ignore();
  //not in v20r2p2! return Service::reinitialize();
  return StatusCode::SUCCESS;
}

// add proxy (with IOpaqueAddress that will later be retrieved from P)
StatusCode SGImplSvc::recordAddress(const std::string& skey,
                                    CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress,
                                    bool clearAddressFlag,
                                    const std::vector<CLID>& bases)
{
  lock_t lock (m_mutex);
  assert(0 != pAddress);
  CLID dataID = pAddress->clID();
 
  if (dataID == 0)
    {
      SG_MSG_WARNING ("recordAddress: Invalid Class ID found in IOpaqueAddress @{}. IOA will not be recorded",
                      static_cast<void*>(pAddress.get()));
      return StatusCode::FAILURE;
    }
 
  //do not overwrite a persistent object
  if (m_pPPS) {
    DataProxy* dp = m_pStore->proxy (dataID, skey);
    if (!dp) {
      dp = m_pPPS->retrieveProxy(dataID, skey, *m_pStore);
    }
    if (dp && dp->provider()) {
      std::string clidTypeName; 
      m_pCLIDSvc->getTypeNameOfID(dataID, clidTypeName).ignore();
      SG_MSG_WARNING ("recordAddress: failed for key={}, type  (CLID {})\n" 
                      " there is already a persistent version of this object. Will not record a duplicate! ",
                      skey, clidTypeName, dataID);
      return StatusCode::FAILURE;
    }
  }
 
  // Check if a key already exists
  DataProxy* dp = m_pStore->proxy_exact(dataID, skey);
  if (0 == dp && 0 != m_pPPS) {
    dp = m_pPPS->retrieveProxy(dataID, skey, *m_pStore);
  }
 
  // Now treat the various cases:
  if (0 == dp) 
    {
      // create the proxy object and register it
      dp = new DataProxy (TransientAddress (dataID, skey,
                                            std::move(pAddress),
                                            clearAddressFlag),
                          m_pDataLoader.get(), true, true);
      m_pStore->addToStore(dataID, dp).ignore();
 
      addAutoSymLinks (skey, dataID, dp, 0, false);
 
      // Add extra bases.
      for (CLID b : bases) {
        if (addSymLink (b, dp).isFailure()) {
          warning() << std::format ("Can't add extra base {} for object {}/{}",
                                    b, dataID, skey) << endmsg;
        }
      }
    }
  else if ((0 != dp) && (0 == dp->address()))
    // Note: intentionally not checking dp->isValidAddress()
    {
      // Update proxy with IOpaqueAddress
      dp->setAddress(std::move(pAddress));
    }
  else
    {
      string errType;
      m_pCLIDSvc->getTypeNameOfID(dataID, errType).ignore();
      SG_MSG_WARNING ("recordAddress: preexisting proxy @{} with non-NULL IOA found for key  type {} ({}). \n"
                      "Cannot record IOpaqueAddress @{}",
                      static_cast<void*>(dp), skey, errType, dataID,
                      static_cast<void*>(pAddress.get()));
      return StatusCode::FAILURE;
    }
 
  return StatusCode::SUCCESS;
 
}    

// add proxy (with IOpaqueAddress that will later be retrieved from P)
StatusCode SGImplSvc::recordAddress(CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress,
                                    bool clearAddressFlag,
                                    const std::vector<CLID>& bases)
{
  lock_t lock (m_mutex);
  assert(0 != pAddress);
 
  CLID dataID = pAddress->clID();
 
  string gK = (pAddress->par())[1];   // transient name by convention
  if (gK.empty()) gK = (pAddress->par())[0];   // FIXME backward compatibility
  if (gK.empty()) gK = createKey(dataID);
 
  return this->recordAddress(gK, std::move(pAddress), clearAddressFlag, bases);
}    
 
DataProxy* SGImplSvc::setupProxy(const CLID& dataID, 
                                 const string& gK, 
                                 DataObject* pDObj,
                                 bool allowMods, 
                                 bool resetOnly) {
  // locate the proxy           
  DataProxy* dp = m_pStore->proxy_exact(dataID, gK);
  
  if (0 != dp) { //proxy found  
    if (0 != dp->object())
      {
        // Case 0: duplicated proxy               
        SG_MSG_WARNING (" setupProxy:: error setting up proxy for key {} and clid {}\n"
                        " Pre-existing valid DataProxy @{} found in Store for key {} with clid {}",
                        gK, dataID,
                        static_cast<void*>(dp),
                        dp->object()->name(),
                        dp->object()->clID());
        recycle(pDObj);      // commit this object to trash
        dp = 0;
      } else {
      // Case 1: Proxy found... if not valid, update it:
      dp->setObject(pDObj);
      if (!allowMods) dp->setConst();
    } 
  } else {
    // Case 2: No Proxy found:
    dp = new DataProxy(pDObj,
                       TransientAddress(dataID, gK),
                       !allowMods, resetOnly);
    if (!(m_pStore->addToStore(dataID, dp).isSuccess())) {
      SG_MSG_WARNING (" setupProxy:: could not addToStore proxy @{}",
                      static_cast<void*>(dp));
      recycle(pDObj);      // commit this object to trash
      delete dp;
      dp = 0;
    }
  }
  return dp;
}

void SGImplSvc::setStoreID(StoreID::type id)
{
  lock_t lock (m_mutex);
  store()->setStoreID(id);
}

StoreID::type SGImplSvc::storeID() const
{
  lock_t lock (m_mutex);
  return store()->storeID();
}
 
 
void
SGImplSvc::keys(const CLID& id, std::vector<std::string>& vkeys, 
                bool includeAlias, bool onlyValid) 
 
{ 
  lock_t lock (m_mutex);
  return store()->keys(id, vkeys, includeAlias, onlyValid);
} 
 
 
bool SGImplSvc::isSymLinked(const CLID& linkID, DataProxy* dp)   
{        
  return (0 != dp) ? dp->transientID(linkID) : false;        
}

// Dump Contents in store:
string SGImplSvc::dump() const
{ 
  lock_t lock (m_mutex);
  auto out_buffer = std::string{};
  auto out = std::back_inserter(out_buffer);
  const std::string me = name();
  std::format_to(out, "{}: <<<<<<<<<<<<<<<<< Data Store Dump >>>>>>>>>>>>>>> \n", me);
  std::format_to(out, "{}: SGImplSvc()::dump() which is {} \n", me, m_storeLoaded ? "LOADED" : "NOT LOADED");
 
  DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
 
  for (; s_iter != s_end; ++s_iter) 
  {
 
    CLID id = s_iter->first;
    int nProxy = store()->typeCount(id);
    std::string tname;
    m_pCLIDSvc->getTypeNameOfID(id, tname).ignore();
    std::format_to(out, "{}: Found {} {} for ClassID {} ({}): \n", me, nProxy, ((nProxy == 1) ? "proxy" : "proxies"), id, tname);
 
    // loop over each type:
    SG::ConstProxyIterator p_iter = (s_iter->second).begin();
    SG::ConstProxyIterator p_end =  (s_iter->second).end();
 
    while (p_iter != p_end) {
      const DataProxy& dp(*p_iter->second);
        std::format_to(out, "{}: flags: ({:7s}, {:8s}, {:6s}) --- data: {:10p} --- key: {}\n", me,
                           (dp.isValid() ? "valid" : "INVALID"),
                           (dp.isConst() ? "locked" : "UNLOCKED"),
                           (dp.isResetOnly() ? "reset" : "DELETE"),
                           dbg::ptr(dp.object()), p_iter->first);
      ++p_iter;
    }
  }
  std::format_to(out, "{}: <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>> \n", me);
  return out_buffer;
}
 
DataStore* 
SGImplSvc::store() 
{ 
  return m_pStore; 
}
 
const DataStore* 
SGImplSvc::store() const 
{ 
  return m_pStore; 
}
 
 
// Make a soft link to the object with key
StatusCode SGImplSvc::symLink(const CLID id, const std::string& key, const CLID linkID)
{
  lock_t lock (m_mutex);
  SG::DataProxy* dp(proxy(id, key, false));
  // if symLink already exists, just return success      
  return isSymLinked(linkID,dp) ?
    StatusCode::SUCCESS :
    addSymLink(linkID,dp);
}
 
 
StatusCode
SGImplSvc::addSymLink(const CLID& linkid, DataProxy* dp)
{ 
  if (0 == dp) {
    SG_MSG_WARNING ("addSymLink: no target DataProxy found. Sorry, can't link to a non-existing data object");
    return StatusCode::FAILURE;
  } 
  StatusCode sc = m_pStore->addSymLink(linkid, dp); 
 
  // If the symlink is a derived->base conversion, then we may have
  // a different transient pointer for the symlink.
  if (sc.isSuccess() && dp->object()) {
    void* baseptr = SG::DataProxy_cast (dp, linkid);
    if (baseptr)
      this->t2pRegister (baseptr, dp).ignore();
  }
  return sc;
}
 
 
StatusCode SGImplSvc::setAlias(const void* pObject, const std::string& aliasKey)
{
  lock_t lock (m_mutex);
 
  SG::DataProxy* dp(0);
  dp = proxy(pObject);
  if (0 == dp) {
    SG_MSG_ERROR ("setAlias: problem setting alias {}\n"
                  "DataObject does not exist, record before setting alias.",
                  aliasKey);
    return StatusCode::FAILURE;
  }
 
  StatusCode sc = addAlias(aliasKey, dp);
  if (sc.isFailure()) {
    SG_MSG_ERROR ("setAlias: problem setting alias {}\n" 
                  "DataObject does not exist, record before setting alias.",
                  aliasKey);
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode
SGImplSvc::addAlias(const std::string& aliasKey, DataProxy* proxy)
{
  if (0 == proxy) {
    SG_MSG_WARNING ("addAlias: no target DataProxy given, Cannot alias to a non-existing object");
    return StatusCode::FAILURE;
  }
 
  // add key to proxy and to ProxyStore
  return m_pStore->addAlias(aliasKey, proxy);
}
 
bool 
SGImplSvc::contains(const CLID id, const std::string& key) const
{
  try {
    return (0 != proxy(id, key, true));
  } catch(...) { return false; }
}
 
 
bool 
SGImplSvc::transientContains(const CLID id, const std::string& key) const
{
  try {
    return (0 != transientProxy(id, key));
  } catch(...) { return false; }
}
 
 
DataProxy* 
SGImplSvc::proxy(const void* const pTransient) const
{
  // No lock needed here --- the T2pmap held by DataStore has its own locking
  // (and we were seeing contention here).
  //lock_t lock (m_mutex);
  return m_pStore->locatePersistent(pTransient); 
}
 
DataProxy* 
SGImplSvc::proxy(const CLID& id) const
{ 
  return proxy(id, false);
}
 
DataProxy* 
SGImplSvc::proxy(const CLID& id, bool checkValid) const
{ 
  DataProxy* dp = nullptr;
  {
    lock_t lock (m_mutex);
    dp = m_pStore->proxy(id);
    if (0 == dp && 0 != m_pPPS) {
      SG::DataStore* pStore ATLAS_THREAD_SAFE = m_pStore;
      dp = m_pPPS->retrieveProxy(id, string("DEFAULT"), *pStore);
    }
  }
  // Be sure to release the lock before this.
  // isValid() may call back to the store, so we could otherwise deadlock..
  if (checkValid && 0 != dp) {
    // FIXME: For keyless retrieve, this checks only the first instance
    // of the CLID in store. If that happens to be invalid, but the second
    // is valid - this does not work (when checkValid is requested).
    return dp->isValid() ? dp : 0;
  }
  return dp;
}
 
DataProxy* 
SGImplSvc::proxy(const CLID& id, const string& key) const
{
  return proxy(id, key, false);
}
 
DataProxy*
SGImplSvc::proxy(const CLID& id, const string& key, bool checkValid) const
{ 
  DataProxy* dp = nullptr;
  {
    lock_t lock (m_mutex);
    dp = m_pStore->proxy(id, key);
#ifdef DEBUG_SGIMPL
    if (!dp) dbg::print(stderr, "::SGImplSvc::proxy(name={}, key={}): data proxy is null, m_pPPS is {}\n", this->name(), key, m_pPPS == 0 ? "NULL" : "NOT NULL");
#endif
    if (0 == dp && 0 != m_pPPS) {
      SG::DataStore* pStore ATLAS_THREAD_SAFE = m_pStore;
      dp = m_pPPS->retrieveProxy(id, key, *pStore);
#ifdef DEBUG_SGIMPL
      if (!dp) dbg::print(stderr, "::SGImplSvc::proxy(name={}, key={}): data proxy is still null\n", this->name(), key);
#endif
    }
  }
  // Be sure to release the lock before this.
  // isValid() may call back to the store, so we could otherwise deadlock..
  if (checkValid && 0 != dp && !(dp->isValid())) {
    dp = 0;
  }
  return dp;
}
 

StatusCode SGImplSvc::addToStore (CLID id, SG::DataProxy* proxy)
{
  lock_t lock (m_mutex);
  return m_pStore->addToStore (id, proxy);
}
 

SG::DataProxy* SGImplSvc::recordObject (SG::DataObjectSharedPtr<DataObject> obj,
                                        const std::string& key,
                                        bool allowMods,
                                        bool returnExisting)
{
  lock_t lock (m_mutex);
  const void* raw_ptr = obj.get();
  const std::type_info* tinfo = nullptr;
  
  if (DataBucketBase* bucket = dynamic_cast<DataBucketBase*> (obj.get())) {
    raw_ptr = bucket->object();
    tinfo = &bucket->tinfo();
  }
 
  if (returnExisting) {
    SG::DataProxy* proxy = this->proxy (obj->clID(), key);
    if (proxy && proxy->isValid()) return proxy;
 
    // Look for the same object recorded under a different key/clid.
    proxy = this->proxy (raw_ptr);
    if (proxy && proxy->isValid()) {
      if (proxy->transientID (obj->clID())) {
        // CLID matches.  Make an alias.
        if (addAlias (key, proxy).isFailure()) {
          CLID clid = proxy->clID();
          std::string clidTypeName; 
          m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
          SG_MSG_WARNING ("SGImplSvc::recordObject: addAlias fails for object {} [{}] {} and new key {}",
                          clid, clidTypeName, proxy->name(), key);
          proxy = nullptr;
        }
      }
 
      else if (key == proxy->name() || proxy->hasAlias(key) > 0)
      {
        // key matches.  Make a symlink.
        if (addSymLink (obj->clID(), proxy).isFailure()) {
          CLID clid = proxy->clID();
          std::string clidTypeName; 
          m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
          CLID newclid = obj->clID();
          std::string newclidTypeName; 
          m_pCLIDSvc->getTypeNameOfID(newclid, newclidTypeName).ignore();
          SG_MSG_ERROR ("SGImplSvc::recordObject:"
                        " addSymLink fails for object {} [{}] {} and new clid {} [{}]",
                        clid, clidTypeName, proxy->name(),
                        newclid, newclidTypeName);
          proxy = nullptr;
        }
      }
 
      else {
        CLID clid = proxy->clID();
        std::string clidTypeName; 
        m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
        CLID newclid = obj->clID();
        std::string newclidTypeName; 
        m_pCLIDSvc->getTypeNameOfID(newclid, newclidTypeName).ignore();
        SG_MSG_ERROR ("SGImplSvc::recordObject:"
                      " existing object found with {} [{}] {} but neither"
                      " clid {} [{}] nor key {} match.",
                      clid, clidTypeName, proxy->name(),
                      newclid, newclidTypeName, key);
        proxy = nullptr;
      }
 
      return proxy;
    }
  }
 
  const bool resetOnly = true;
  const bool noHist = false;
  SG::DataProxy* proxy = nullptr;
  if (this->typeless_record (obj.get(), key, raw_ptr,
                             allowMods, resetOnly, noHist, tinfo,
                             &proxy, true).isFailure())
    {
      return nullptr;
    }
  return proxy;
}
 

SG::DataProxy* SGImplSvc::proxy_exact (SG::sgkey_t sgkey) const
{
  return m_pStore->proxy_exact_unlocked (sgkey, m_mutex);
}
 

void SGImplSvc::setSlotNumber (int slot, int numSlots)
{
  m_slotNumber = slot;
  m_numSlots = numSlots;
 
  SG::ArenaHeader* header = SG::ArenaHeader::defaultHeader();
  header->setArenaForSlot (slot, &m_arena);
}
 
 
std::vector<const SG::DataProxy*> 
SGImplSvc::proxies() const
{
  lock_t lock (m_mutex);
  const std::vector<SG::DataProxy*>& proxies = store()->proxies();
  std::vector<const SG::DataProxy*> ret (proxies.begin(), proxies.end());
  return ret;
}
 
 
std::vector<CLID>
SGImplSvc::clids() const
{
  lock_t lock (m_mutex);
 
  using std::distance;
  DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
 
  std::vector<CLID> clids;
  clids.reserve( distance( s_iter, s_end ) );
 
  for (; s_iter != s_end; ++s_iter ) {
    const CLID id = s_iter->first;
    clids.push_back (id);
  }
 
  return clids;
}
 
 
DataProxy*
SGImplSvc::transientProxy(const CLID& id, const string& key) const
{ 
  lock_t lock (m_mutex);
  DataProxy* dp(m_pStore->proxy(id, key));
  return ( (0 != dp && dp->isValidObject()) ? dp : 0 );
}
 
DataObject* 
SGImplSvc::accessData(const CLID& id) const
{ 
  lock_t lock (m_mutex);
  DataProxy* theProxy(proxy(id, true));
  return (0 == theProxy) ? 0 : theProxy->accessData();
}
 
DataObject* 
SGImplSvc::accessData(const CLID& id, const string& key) const
{ 
  lock_t lock (m_mutex);
  DataProxy* theProxy(proxy(id, key, true));
  return (0 == theProxy) ? 0 : theProxy->accessData();
}
 
StatusCode
SGImplSvc::typeless_record( DataObject* obj, const std::string& key,
                            const void* const raw_ptr,
                            bool allowMods, bool resetOnly, bool noHist)
{
  return typeless_record (obj, key, raw_ptr, allowMods, resetOnly, noHist, 0,
                          nullptr, true);
}
 
 
StatusCode
SGImplSvc::typeless_record( DataObject* obj, const std::string& key,
                            const void* const raw_ptr,
                            bool allowMods, bool resetOnly, bool noHist,
                            const std::type_info* tinfo)
{
  return typeless_record (obj, key, raw_ptr, allowMods, resetOnly, noHist,tinfo,
                          nullptr, true);
}
 
 
StatusCode
SGImplSvc::typeless_record( DataObject* obj, const std::string& key,
                            const void* const raw_ptr,
                            bool allowMods, bool resetOnly, bool noHist,
                            const std::type_info* tinfo,
                            SG::DataProxy** proxy_ret,
                            bool noOverwrite)
{
  lock_t lock (m_mutex);
  SG::DataProxy* proxy =
    record_impl( obj, key, raw_ptr, allowMods, resetOnly, !noOverwrite, tinfo);
  if ( proxy == nullptr )
    return StatusCode::FAILURE;
  if (proxy_ret)
    *proxy_ret = proxy;
 
  if ( !m_ActivateHistory || noHist ) {
    return StatusCode::SUCCESS;
  }
 
  if ( store()->storeID() != StoreID::EVENT_STORE ) {
    return StatusCode::SUCCESS;
  } else {
    return record_HistObj( obj->clID(), key, name(), allowMods, resetOnly );
  }
}
 
StatusCode
SGImplSvc::typeless_overwrite( const CLID& clid, 
                               DataObject* obj, 
                               const std::string& key,
                               const void* const raw_ptr,
                               bool allowMods,
                               bool noHist,
                               const std::type_info* tinfo)
{
  lock_t lock (m_mutex);
  StatusCode sc(StatusCode::SUCCESS);
  SG::DataProxy* toRemove(proxy(clid, key, false));
  if (0 != toRemove) {
    toRemove->addRef();
    const bool FORCEREMOVE(true);        
    sc =removeProxy(toRemove, (void*)0, FORCEREMOVE);
  }
  if (sc.isSuccess()) {
    const bool ALLOWOVERWRITE(true);
    const bool NORESET(false);
    if (record_impl( obj, key, raw_ptr, allowMods, NORESET, ALLOWOVERWRITE, tinfo) == nullptr)
      sc = StatusCode::FAILURE;
    else if ( m_ActivateHistory && noHist && store()->storeID() == StoreID::EVENT_STORE ) {
      sc = record_HistObj( obj->clID(), key, name(), allowMods, NORESET );
    }
  }
  //for detector store objects managed by IIOVSvc, replace the old proxy with the new one (#104311)
  if (toRemove && sc.isSuccess() && store()->storeID() == StoreID::DETECTOR_STORE) {
    sc = m_pIOVSvc->replaceProxy(toRemove, proxy(clid, key));
  }
  if (toRemove)
    toRemove->release();
  return sc;
}
 
SG::DataProxy*
SGImplSvc::record_impl( DataObject* pDObj, const std::string& key,
                        const void* const raw_ptr,
                        bool allowMods, bool resetOnly, bool allowOverwrite,
                        const std::type_info* tinfo)
{
  CLID clid = pDObj->clID();
  std::string rawKey(key);
  if (!allowOverwrite && m_pPPS) {
    //do not overwrite a persistent object
    DataProxy* dp = m_pStore->proxy (clid, rawKey);
    if (!dp) {
      dp = m_pPPS->retrieveProxy(clid, rawKey, *m_pStore);
    }
    if (dp && dp->provider()) {
      std::string clidTypeName; 
      m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
      SG_MSG_WARNING ("record_impl: you are recording an object with key {}, type {} (CLID {})\n"
                      " There is already a persistent version of this object."
                      " Recording a duplicate may lead to unreproducible results and it is deprecated.",
                      rawKey, clidTypeName, clid);
    }
  }
  //now check whether raw_ptr has already been recorded
  //We need to do this before we create the bucket, the proxy etc
  SG::DataProxy* dp(proxy(raw_ptr));
  if (0 != dp) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    SG_MSG_WARNING ("record_impl: failed for key={}, type {} (CLID {})\n"
                    " object @{} already in store with key={}. Will not record a duplicate!",
                    rawKey, clidTypeName, clid, raw_ptr, dp->name());
    if (pDObj != dp->object()) {
      DataBucketBase* pDBB(dynamic_cast<DataBucketBase*>(pDObj));
      if (!pDBB) std::abort();
      pDBB->relinquish(); //don't own the data obj already recorded!
    }
    this->recycle(pDObj);
    return nullptr;
  }
 
 
  // setup the proxy
  dp = setupProxy( clid, rawKey, pDObj, allowMods, resetOnly );
  if ( 0 == dp ) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    SG_MSG_WARNING ("record_impl: Problem setting up the proxy for object @{}\n"
                    " recorded with key {} of type {} (CLID {}) in DataObject @{}",
                    raw_ptr, rawKey, clidTypeName, clid,
                    static_cast<void*>(pDObj));
 
    return nullptr;
  }
 
  // record in t2p:
  if ( !(this->t2pRegister( raw_ptr, dp )).isSuccess() ) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    SG_MSG_WARNING ("record_impl: can not add to t2p map object @{}\n"
                    " with key {} of type {} (CLID {})",
                    raw_ptr, rawKey, clidTypeName, clid);
    return nullptr;
  }
 
  addAutoSymLinks (rawKey, clid, dp, tinfo);
 
  return dp;
}
 
DataProxy*
SGImplSvc::locatePersistent(const TransientAddress* tAddr, 
                            bool checkValid) const
{ 
  DataProxy* dp = m_pStore->proxy(tAddr);
  
  if (checkValid && 0 != dp) {
    return dp->isValid() ? dp : 0;
  } else {
    return dp;
  }
}
 
StatusCode
SGImplSvc::removeProxy(DataProxy* proxy, const void* pTrans, 
                       bool forceRemove)
{
  lock_t lock (m_mutex);
  // check if valid proxy
  if (0 == proxy) return StatusCode::FAILURE;
 
  if (0 == pTrans) {
    DataBucketBase* bucket = dynamic_cast<DataBucketBase*>(proxy->object());
    if (bucket) pTrans = bucket->object();
  }
 
  // remove all entries from t2p map
  //  --- only if the proxy actually has an object!
  //      otherwise, we can trigger I/O.
  //      besides being useless here, we can get deadlocks if we
  //      call into the I/O code while holding the SG lock.
  if (proxy->isValidObject()) {
    this->t2pRemove(pTrans);
    SG::DataProxy::CLIDCont_t clids = proxy->transientID();
    for (SG::DataProxy::CLIDCont_t::const_iterator i = clids.begin();
         i != clids.end();
         ++i)
    {
      void* ptr = SG::DataProxy_cast (proxy, *i);
      this->t2pRemove(ptr);
    }
  }
 
  // remove from store
  return m_pStore->removeProxy(proxy, forceRemove, true);
}
 
StatusCode
SGImplSvc::t2pRegister(const void* const pTrans, DataProxy* const pPers)
{ 
  return m_pStore->t2pRegister(pTrans, pPers);
}
 
 
void
SGImplSvc::t2pRemove(const void* const pTrans)
{
  m_pStore->t2pRemove(pTrans); 
}
 
void
SGImplSvc::msg_update_handler(Gaudi::Details::PropertyBase& /*outputLevel*/)
{
  setUpMessaging();
  updateMsgStreamOutputLevel( outputLevel() );
  msgSvc()->setOutputLevel(name(), outputLevel());
}
 
StatusCode SGImplSvc::setConst(const void* pObject)
{
  lock_t lock (m_mutex);
  // Check if DataProxy does not exist
  DataProxy * dp = proxy(pObject); 
 
  if (0 == dp)
    {
      SG_MSG_WARNING ("setConst: NO Proxy for the dobj you want to set const");
      return StatusCode::FAILURE;
    }
 
  dp->setConst();
  return StatusCode::SUCCESS;
}
 
 
// remove an object from Store, will remove its proxy if not reset only
StatusCode 
SGImplSvc::remove(const void* pObject)
{
  lock_t lock (m_mutex);
  return removeProxy(proxy(pObject), pObject);
}
 
 
// remove an object and its proxy from Store     
StatusCode       
SGImplSvc::removeDataAndProxy(const void* pObject)          
{        
  lock_t lock (m_mutex);
  const bool FORCEREMOVE(true);          
  return removeProxy(proxy(pObject), pObject, FORCEREMOVE);      
}
 
//put a bad (unrecordable) dobj away
void SGImplSvc::recycle(DataObject* pBadDObj) {
  assert(pBadDObj);
  pBadDObj->addRef(); 
  m_trash.push_back(pBadDObj);
}
 
//throw away bad objects
void SGImplSvc::emptyTrash() {
  lock_t lock (m_mutex);
  while (!m_trash.empty()) {
    m_trash.front()->release();  //delete the bad data object
    m_trash.pop_front();     //remove pointer from list
  }
}
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode 
SGImplSvc::record_HistObj(const CLID& id, const std::string& key,
                          const std::string& store, 
                          bool allowMods, bool resetOnly) {
 
  DataHistory *dho;
  dho = m_pHistorySvc->createDataHistoryObj( id, key, store );
 
  std::string idname;
  StatusCode sc = m_pCLIDSvc->getTypeNameOfID(id, idname);
  if (sc.isFailure() || idname.empty() ) { 
    idname = std::to_string(id);
  }
  idname += '/';
  idname += key;
 
  DataObject* obj = SG::asStorable(dho);
  
  const bool ALLOWOVERWRITE(false);
  if (record_impl(obj, idname, dho, allowMods, resetOnly, ALLOWOVERWRITE,
                  &typeid(DataHistory)) == nullptr)
    return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}
 

SGImplSvc::sgkey_t
SGImplSvc::stringToKey (const std::string& str, CLID clid)
{
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.stringToKey (str, clid);
}
 

const std::string* SGImplSvc::keyToString (sgkey_t key) const
{
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.keyToString (key);
}
 

const std::string*
SGImplSvc::keyToString (sgkey_t key, CLID& clid) const
{
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.keyToString (key, clid);
}
 

void SGImplSvc::registerKey (sgkey_t key,
                             const std::string& str,
                             CLID clid)
{
  lock_t lock (m_stringPoolMutex);
  if (!m_stringpool.registerKey (key, str, clid)) {
    CLID clid2;
    const std::string* str2 = m_stringpool.keyToString (key, clid2);
    SG_MSG_WARNING ("The numeric key {} maps to multiple string key/CLID pairs: {}/{} and {}/{}",
                    key, *str2, clid2, str, clid);
  }
}
 

bool SGImplSvc::mergeStringPool (const SGImplSvc& other)
{
  // We should hold m_stringPoolMutex before touching the pool.
  // But if we acquire the locks for both this and the other store,
  // we risk a deadlock.  So first copy the other pool, so that we
  // don't need to hold both locks at the same time.
  SG::StringPool tmp;
  {
    lock_t lock (other.m_stringPoolMutex);
    tmp = other.m_stringpool;
  }
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.merge (tmp);
}
 
 
void
SGImplSvc::releaseObject(const CLID& id, const std::string& key) {
  lock_t lock (m_mutex);
  DataProxy *pP(0);
  if (0 != (pP = proxy(id, key))) {
    // remove all entries from t2p map
    SG::DataProxy::CLIDCont_t clids = pP->transientID();
    SG::DataProxy::CLIDCont_t::const_iterator i(clids.begin()), e(clids.end());
    while (i != e) t2pRemove(SG::DataProxy_cast (pP, *i++));
    DataBucketBase *pDBB(dynamic_cast<DataBucketBase*>(pP->object()));
    //tell the bucket to let go of the data object
    if (0 != pDBB) pDBB->relinquish(); //somebody else better took ownership
    bool hard_reset = (m_numSlots > 1);
    pP->reset (hard_reset);
  }
}
 
void
SGImplSvc::clearProxyPayload(SG::DataProxy* dp) {
  lock_t lock (m_mutex);
 
  // Remove transient pointer entries for this proxy.
  // But do that only if the proxy has a valid object.
  // Otherwise, we could trigger I/O --- which we don't want since it's useless
  // (we'd just destroy the object immediately).  In some cases it can also
  // lead to a deadlock (see ATR-24482).
  if (dp->isValidObject()) {
    SG::DataProxy::CLIDCont_t clids = dp->transientID();
    SG::DataProxy::CLIDCont_t::const_iterator i(clids.begin()), e(clids.end());
    while (i != e) {
      t2pRemove(SG::DataProxy_cast (dp, *i++));
    }
  }
 
  bool hard_reset = (m_numSlots > 1);
  dp->reset (hard_reset);
}
 

void SGImplSvc::remap_impl (sgkey_t source,
                            sgkey_t target,
                            off_t index_offset)
{
  lock_t lock (m_remapMutex);
  SG::RemapImpl::remap_t payload;
  payload.target = target;
  payload.index_offset = index_offset;
  m_remap_impl->m_remaps[source] = payload;
}
 

bool SGImplSvc::tryELRemap (sgkey_t sgkey_in, size_t index_in,
                            sgkey_t& sgkey_out, size_t& index_out)
{
  lock_t lock (m_remapMutex);
  SG::RemapImpl::remap_map_t::iterator i =
    m_remap_impl->m_remaps.find (sgkey_in);
  if (i == m_remap_impl->m_remaps.end())
    return false;
  const SG::RemapImpl::remap_t& payload = i->second;
  sgkey_out = payload.target;
  index_out = index_in + payload.index_offset;
  return true;
}
 
 
CLID SGImplSvc::clid( const std::string& key ) const
{
  lock_t lock (m_mutex);
  SG::DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
  
  for ( ; s_iter != s_end; ++s_iter ) {
    if ( s_iter->second.find( key ) != s_iter->second.end() ) {
      return s_iter->first;
    }
  }
 
  return CLID_NULL;
}
 

void SGImplSvc::addAutoSymLinks (const std::string& key,
                                 CLID clid,
                                 DataProxy* dp,
                                 const std::type_info* tinfo,
                                 bool warn_nobib /*= true*/)
{
  // Automatically make all legal base class symlinks
  if (!tinfo) {
    tinfo = CLIDRegistry::CLIDToTypeinfo (clid);
  }
  const SG::BaseInfoBase* bib = nullptr;
  if (tinfo) {
    bib = SG::BaseInfoBase::find (*tinfo);
  }
  if (!bib) {
    // Could succeed where the previous fails if clid for DataVector<T>
    // but tinfo is for ConstDataVector<DataVector<T> >.
    bib = SG::BaseInfoBase::find (clid);
  }
  if ( bib ) {
    const std::vector<CLID>& bases = bib->get_bases();
    for ( std::size_t i = 0, iMax = bases.size(); i < iMax; ++i ) {
      if ( bases[i] != clid ) {
        if ( addSymLink( bases[i], dp ).isSuccess() ) {
          // register with t2p
          if (dp->object())
            this->t2pRegister( SG::DataProxy_cast( dp, bases[i] ), dp ).ignore();
        }
        else {
          SG_MSG_WARNING ("record_impl: Doing auto-symlinks for object"
                          " with CLID {} and SG key {}:"
                          " Proxy already set for base CLID {}; not making auto-symlink.",
                          clid, key, bases[i]);
        }
      }
    }
 
    // Handle copy conversions.
    {
      for (CLID copy_clid : bib->get_copy_conversions()) {
        if (m_pStore->addSymLink (copy_clid, dp).isFailure()) {
          SG_MSG_WARNING ("record_impl: Doing auto-symlinks for object"
                          " with CLID {} and SG key {}:"
                          " Proxy already set for copy-conversion CLID {}; not making auto-symlink.",
                          clid, key, copy_clid);
        }
      }
    }
  }
  else {
    if (warn_nobib) {
      SG_MSG_WARNING ("record_impl: Could not find suitable SG::BaseInfoBase for CLID [{}] ({}) !\t"
                      "No auto-symlink established !",
                      clid, key);
    }
  }
}
 
void
SGImplSvc::commitNewDataObjects() {
  lock_t lock (m_mutex);
 
  // Reset handles added since the last call to commit.
  bool hard_reset = (m_numSlots > 1);
  std::vector<IResetable*> handles;
  m_newBoundHandles[std::this_thread::get_id()].swap (handles);
  for (IResetable* h : handles)
    h->reset (hard_reset);
}
 

void
SGImplSvc::boundHandle (IResetable* handle)
{
  m_newBoundHandles[std::this_thread::get_id()].push_back (handle);
}
 

void
SGImplSvc::unboundHandle (IResetable* handle)
{
  std::vector<IResetable*>& v = m_newBoundHandles[std::this_thread::get_id()];
  std::vector<IResetable*>::iterator it =
    std::find (v.begin(), v.end(), handle);
  if (it != v.end())
    v.erase (it);
}
 

void SGImplSvc::makeCurrent()
{
  lock_t lock (m_mutex);
  m_arena.makeCurrent();
  SG::CurrentEventStore::setStore (this);
}
 

StatusCode
SGImplSvc::createObj (IConverter* cvt,
                      IOpaqueAddress* addr,
                      DataObject*& refpObject)
{
  // This lock was here originally, but is probably not really needed ---
  // both DataProxy and the I/O components have their own locks.
  // Further, this was observed to cause deadlocks for the detector store,
  // and would in general be expected to be a contention issue.
  //lock_t lock (m_mutex);
  return cvt->createObj (addr, refpObject);
}
 
 
// This is intended to be called from the debugger.
void SG_dump (SGImplSvc* sg)
{
  std::println ("{}", sg->dump());
}
void SG_dump (SGImplSvc* sg, const char* fname)
{
  std::ofstream f (fname);
  std::println (f, "{}", sg->dump());
  f.close();
}
 

SG::SourceID SGImplSvc::sourceID (const std::string& key /*= "EventSelector"*/) const
{
  lock_t lock (m_mutex);
  SG::DataProxy* dp =proxy (ClassID_traits<DataHeader>::ID(), key, true);
  if (dp) {
    const DataHeader* dh = SG::DataProxy_cast<DataHeader> (dp);
    if (dh) {
      return dh->begin()->getToken()->dbID().toString();
    }
  }
  return "";
}
 

// Retrieve a list of collections from Transient Store with no Key.
// const version
StatusCode SGImplSvc::retrieve (CLID clid,
                                SG::detail::IteratorBase& cibegin,
                                SG::detail::IteratorBase& ciend) const
{
  lock_t lock (m_mutex);
  SG::ConstProxyIterator first;
  SG::ConstProxyIterator end;
 
  if (!(m_pStore->pRange(clid,first,end)).isSuccess()) {
    std::string typnam;
    m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
    SG_MSG_DEBUG("retrieve(range): no object found of type {} (CLID {})",
                 typnam, clid);
  }
 
  (ciend.setState(end, end, true)).ignore();
  
  if (!(cibegin.setState(first, end, true)).isSuccess()) {
    std::string typnam;
    m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
    SG_MSG_DEBUG("retrieve(range): Can't initialize iterator for object range " 
                 " of type {} (CLID {})",
                 typnam, clid);
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 
 
bool SGImplSvc::associateAux_impl (SG::AuxVectorBase* ptr,
                                   const std::string& key,
                                   CLID auxclid) const
{
  // If we already have the aux store (as should usually be the case), return
  // without taking out the SG lock.  Otherwise, we can deadlock
  // if another thread is also trying to dereference a link to the aux store.
  // (Should _not_ be holding the SG lock when dereferencing the link!)
  if (ptr->hasStore()) return true;
 
  lock_t lock (m_mutex);
  SG_MSG_VERBOSE("called associateAux_impl for key " + key);
  // no Aux store set yet
  if (!ptr->hasStore()) {
    SG::DataProxy* dp = proxy (auxclid, key + "Aux.", true);
    if (dp) {
      if (!dp->isConst()) {
        SG::IAuxStore* pAux = SG::DataProxy_cast<SG::IAuxStore> (dp);
        if (pAux) {
          ptr->setStore (pAux);
          return true;
        }
      }
 
      const SG::IConstAuxStore* pAux = SG::DataProxy_cast<SG::IConstAuxStore> (dp);
      if (pAux) {
        ptr->setStore (pAux);
        return true;
      }
    }
  }
  return false;
}
 
 
bool SGImplSvc::associateAux_impl (SG::AuxElement* ptr,
                                   const std::string& key,
                                   CLID auxclid) const
{
  lock_t lock (m_mutex);
  SG_MSG_VERBOSE("called associateAux_impl for key " + key);
  // no Aux store set yet
  if (!ptr->hasStore()) {
    SG::DataProxy* dp = proxy (auxclid, key + "Aux.", true);
    if (dp) {
      if (!dp->isConst()) {
        SG::IAuxStore* pAux = SG::DataProxy_cast<SG::IAuxStore> (dp);
        if (pAux) {
          ptr->setStore (pAux);
          return true;
        }
      }
 
      const SG::IConstAuxStore* pAux = SG::DataProxy_cast<SG::IConstAuxStore> (dp);
      if (pAux) {
        ptr->setStore (pAux);
        return true;
      }
    }
  }
  return false;
}