StoreGate/src/VarHandleBase.cxx

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// VarHandleBase.cxx 
// Implementation file for class VarHandleBase
// Author: Paolo Calafiura
// Author: S.Binet<binet@cern.ch>
 
#undef DEBUG_VHB  /* define to get verbose debug printouts */
 
#include "StoreGate/VarHandleBase.h"
 
#include "StoreGate/StoreGateSvc.h"
#include "StoreGate/tools/SGImplSvc.h"
#include "StoreGate/exceptions.h"
 
#include "AthenaKernel/DataBucketBase.h"
#include "AthenaKernel/StorableConversions.h"
 
// fwk includes
#include "GaudiKernel/MsgStream.h"
#include "AthenaKernel/IHiveStore.h"
#include "AthenaKernel/getMessageSvc.h"
#include "AthenaKernel/errorcheck.h"
#include "AthenaKernel/ExtendedEventContext.h"
#include "CxxUtils/as_const_ptr.h"
#include "GaudiKernel/ThreadLocalContext.h"
 
#include <algorithm>
#include <cstdio>
#include <format>
 
#ifdef DEBUG_VHB
#include <boost/core/demangle.hpp>
 
// 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); }
 
std::string proxy(SG::DataProxy* proxy)
{
  return !proxy ? std::string("PROXY(null)") : std::format("PROXY({}, isValid={}, isConst={})", dbg::ptr(proxy), proxy->isValid(), proxy->isConst());
}
 
std::string store(IProxyDict* store)
{
  return !store ? std::string("null_store") : store->name();
}
}
#endif
 
namespace errorcheck {
 

  std::string context_name (const SG::VarHandleBase* context)
  {
  return std::format("VarHandle({}+{}[{}])", context->storeHandle().name(), context->key(), context->clid());
  }
 
} // namespace errorcheck
 
 
namespace SG {
 

  class SymlinkDataObject
    : public DataBucketBase
  {
  public:
    SymlinkDataObject (CLID clid, void* obj) : m_clid (clid), m_obj (obj) {}
    virtual const CLID& clID() const override { return m_clid; }
    virtual void* object() override { return m_obj; }
    virtual const std::type_info& tinfo() const override { return typeid(void); }
    using DataBucketBase::cast;
    virtual void* cast (CLID, SG::IRegisterTransient*, bool) override { std::abort(); }
    virtual void* cast (const std::type_info&, SG::IRegisterTransient*, bool) override { std::abort(); }
    virtual void relinquish() override { std::abort(); }
    virtual void lock() override { }
 
  
  private:
    CLID m_clid;
    void* m_obj;
  };
 

  VarHandleBase::VarHandleBase(CLID clid, Gaudi::DataHandle::Mode mode) :
    IResetable(),
    m_ptr(0),
    m_proxy(0),
    m_store(nullptr),
    m_storeWasSet(false),
    m_ownedKey (std::make_unique<VarHandleKey> (clid, "", mode)),
    m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
#ifdef DEBUG_VHB
    dbg::print(stderr, "VarHandleBase() {}\n", dbg::ptr(this));
#endif
  }
 

  VarHandleBase::VarHandleBase(CLID clid,
                               const std::string& sgkey,
                               Gaudi::DataHandle::Mode mode,
                               const std::string& storename,
                               const EventContext* ctx) :  
    IResetable(),
    m_ptr(NULL),
    m_proxy(NULL),
    m_store(nullptr),
    m_storeWasSet(false),
    m_ownedKey (std::make_unique<VarHandleKey> (clid, sgkey, mode, storename)),
    m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
 
    if (ctx && !setStoreFromHandle(ctx)) {
      throw SG::ExcHandleInitError (clid, sgkey, storename);
    }
  }
 

  VarHandleBase::VarHandleBase(CLID clid,
                               const std::string& sgkey,
                               Gaudi::DataHandle::Mode mode,
                               IProxyDict* sg) :
    IResetable(),
    m_ptr(nullptr),
    m_proxy(nullptr),
    m_store(sg),
    m_storeWasSet(true),
    m_ownedKey (std::make_unique<VarHandleKey> (clid, sgkey, mode, sg->name())),
    m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
  }
 

  VarHandleBase::VarHandleBase (const VarHandleKey& key,
                                const EventContext* ctx)
    : IResetable(),
      m_ptr(nullptr),
      m_proxy(nullptr),
      m_store(nullptr),
      m_storeWasSet(false),
      m_key (&key)
  {
    if (key.storeHandle().get() == nullptr) {
      throw SG::ExcUninitKey (key.clid(), key.key(),
                              key.storeHandle().name());
    }
    
    if (!setStoreFromHandle(ctx)) {
      throw SG::ExcHandleInitError (key.clid(), key.key(),
                                    key.storeHandle().name());
    }
  }
 

  VarHandleBase::VarHandleBase (SG::DataProxy* proxy,
                                Gaudi::DataHandle::Mode mode)
    : IResetable(),
      m_ptr (nullptr),
      m_proxy (nullptr),
      m_store (proxy->store()),
      m_storeWasSet (true),
      m_ownedKey (std::make_unique<VarHandleKey> (proxy->clID(),
                                                  proxy->name(),
                                                  mode,
                                                  m_store ? m_store->name() : "")),
      m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
    setProxy (proxy);
  }
 

  VarHandleBase::VarHandleBase( const VarHandleBase& rhs ) :
    IResetable(),
    m_ptr(rhs.m_ptr),
    m_proxy(nullptr),
    m_store(rhs.m_store),
    m_storeWasSet(rhs.m_storeWasSet)
  {
    if (rhs.m_ownedKey) {
      m_ownedKey = std::make_unique<VarHandleKey> (*rhs.m_ownedKey);
      m_ownedKey->setOwningHandle (this);
      m_key = m_ownedKey.get();
    }
    else {
      m_key = rhs.m_key;
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::copy constr from {} to {} with proxy={} => {}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), dbg::proxy(rhs.m_proxy), this->key(), dbg::store(this->m_store));
#endif
 
    setProxy (rhs.m_proxy);
  }
 

  VarHandleBase::VarHandleBase( VarHandleBase&& rhs ) noexcept :
    IResetable(),
    m_ptr(rhs.m_ptr),
    m_proxy(nullptr),
    m_store(rhs.m_store),
    m_storeWasSet(rhs.m_storeWasSet),
    m_ownedKey (std::move (rhs.m_ownedKey)),
    m_key (rhs.m_key)
  {
    if (m_ownedKey) {
      m_ownedKey->setOwningHandle (this);
    }
    rhs.m_ptr=0;
 
    if (rhs.m_proxy) {
      if (m_ownedKey) {
        rhs.m_proxy->unbindHandle (&rhs);
        rhs.m_proxy->bindHandle(this);
      }
      m_proxy = rhs.m_proxy;
      rhs.m_proxy=0; //no release: this has the ref now
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::move constr from {} to {} with proxy={}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
  }
 

  VarHandleBase& 
  VarHandleBase::operator=( const VarHandleBase& rhs )
  {
    if (this != &rhs) {
      if (rhs.m_ownedKey) {
        m_ownedKey = std::make_unique<VarHandleKey> (*rhs.m_ownedKey);
        m_ownedKey->setOwningHandle (this);
        m_key = m_ownedKey.get();
      }
      else {
        m_key = rhs.m_key;
        m_ownedKey.reset();
      }
 
      m_ptr =    rhs.m_ptr;
      m_store =  rhs.m_store;
      m_storeWasSet = rhs.m_storeWasSet;
      setProxy (rhs.m_proxy);
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::assignment from {} to {} with proxy={}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
    return *this;
  }
 

  VarHandleBase& 
  VarHandleBase::operator=( VarHandleBase&& rhs ) noexcept
  {
    if (this != &rhs) {
      m_ownedKey = std::move (rhs.m_ownedKey);
      if (m_ownedKey) {
        m_ownedKey->setOwningHandle (this);
      }
      m_key = rhs.m_key;
 
      m_ptr =    rhs.m_ptr;
      m_store =  rhs.m_store;
      m_storeWasSet = rhs.m_storeWasSet;
 
      rhs.m_ptr=0;
 
      resetProxy();
      if (rhs.m_proxy) {
        if (m_ownedKey) {
          rhs.m_proxy->unbindHandle (&rhs);
          rhs.m_proxy->bindHandle (this);
        }
        m_proxy =  rhs.m_proxy;
        rhs.m_proxy=0; //no release: this has the ref now
      }
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB:: move assign from {} to {} with proxy={}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
    return *this;
  }
 

   */
  VarHandleBase::~VarHandleBase()
  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB:: DESTROY {} with ptr={}, proxy={}, key={}, store={}\n", dbg::ptr(this), dbg::ptr(this->m_ptr), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
 
    if (m_ownedKey) {
      resetProxy();
    }
    m_ptr = 0;
  }
 
 
 
  //*************************************************************************
  // Accessors
  //
 

  const std::string& VarHandleBase::key() const
  {
    return m_key->key();
  }
 

   * @brief Return the StoreGate ID for the referenced object.
   *
   * A synonym for key().
   */
  const std::string& VarHandleBase::name() const 
  {
    return this->key();
  }
 

  /**
   * @brief Return the name of the store holding the object we are proxying.
   */
  std::string VarHandleBase::store() const
  {
    if (m_store)
      return m_store->name();
    return this->storeHandle().name();
  }
 
 
  //*************************************************************************
  // Validity checking.
  //
 

  bool VarHandleBase::isPresent() const
  {
    return isPresent_impl (key());
  }
 

  bool 
  VarHandleBase::isInitialized() const
  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::isInitialized({}, proxy={}) const\n", dbg::ptr(this), dbg::proxy(m_proxy));
#endif
    return (0 != m_proxy);
  }
 

  bool VarHandleBase::isSet() const
  {
    return isInitialized();
  }
 

  bool 
  VarHandleBase::isConst() const
  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::isConst({}, proxy={}) const\n", dbg::ptr(this), dbg::proxy(m_proxy));
#endif
    return 0 != m_proxy 
      ? m_proxy->isConst() 
      : false;
  }
 

   * This will return failure if the key is blank or if the event store
   * cannot be found.
   */
  StatusCode 
  VarHandleBase::initialize (bool used /*= true*/)
  {
    if (!used) {
      if (m_ownedKey) {
        CHECK( m_ownedKey->initialize (used) );
      }
      return StatusCode::SUCCESS;
    }
 
    if (!m_store) {
      if (m_ownedKey) {
        CHECK( m_ownedKey->initialize() );
      }
      m_store = &*(this->storeHandle());
      m_storeWasSet = false;
    }
 
    if (!m_store) {
      return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
  }
 

   * Note for the case of a WriteHandle that has not yet been written to,
   * the proxy may not exist.  We return Success in that case; however,
   * @c isInitialized will still return false.
   */
  StatusCode 
  VarHandleBase::setState()
  {
    CHECK( initialize() );
    if (!m_storeWasSet) {
      IProxyDict* store = storeFromHandle (nullptr);
      if (store) m_store = store;
    }
 
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB:: setState() on {} with key={} ({}) and store={} (CLID: {})\n", dbg::ptr(this), this->key(), m_key->hashedKey(), dbg::store(m_store), this->clid());
#endif
 
    SG::DataProxy* proxy = m_store->proxy_exact (m_key->hashedKey());
    if (!proxy) {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB:: setState() on {} ==> null proxy!\n", dbg::ptr(this));
#endif
      proxy = m_store->proxy(this->clid(), this->key());
    }
 
    if (!proxy) {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB:: setState() on {} ==> STILL null proxy!\n", dbg::ptr(this));
#endif
    }
    else if (!proxy->isValid()) {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB:: setState() on {} ==> proxy not valid! Dumping Store\n", dbg::ptr(this));
      if (!m_store) {
        dbg::print(stderr, "::VHB:: setState() on {} ==> m_store is a nullptr\n", dbg::ptr(this));
      }
      else {
        SGImplSvc* stor = dynamic_cast<SGImplSvc*>(m_store);
        if (!stor) {
          dbg::print(stderr, "::VHB:: setState() on {} ==> m_store points not to an SGImplSvc but to a {}\n", dbg::ptr(this), boost::core::demangle(typeid(*m_store).name()));
        }
        else {
          dbg::print(stderr, "\n{}\n", stor->dump());
        }
      }
#endif
    }
    StatusCode sc = this->setState(proxy);
 
    // Failure to find the proxy is ok in the case of a @c WriteHandle
    // that has not yet been written to.
    if (sc.isFailure() && mode() == Gaudi::DataHandle::Writer && m_ptr == nullptr)
      return StatusCode::SUCCESS;
 
    return sc;
  }
 
 
  //*************************************************************************
  // State setting.
  //
 

  StatusCode VarHandleBase::setProxyDict (IProxyDict* store)
  {
    reset(true);
    m_store = store;
    m_storeWasSet = true;
    return StatusCode::SUCCESS;
  }
 

  void 
  VarHandleBase::reset (bool hard) {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::reset {} with proxy={}, key={}, store={} (hard={})\n", dbg::ptr(this), dbg::proxy(m_proxy), this->key(), dbg::store(this->m_store), hard);
#endif
    m_ptr = 0; 
 
    if (hard) {
      m_store = 0;
      m_storeWasSet = false;
    }
 
    //if the proxy is not resetOnly then release it as it will become invalid
    // Also release on a hard reset.
    if (0 != m_proxy && (!m_proxy->isResetOnly() || hard)) {
      resetProxy();
    }
  }
 

  void VarHandleBase::finalReset() {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::finalReset {} with proxy={}, key={}, store={}\n", dbg::ptr(this), dbg::proxy(m_proxy), this->key(), dbg::store(this->m_store));
#endif
    reset (true);
  }
 

  StatusCode VarHandleBase::setConst()
  {
    if (typeless_dataPointer()) {
      m_proxy->setConst();
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }
 

  SG::VarHandleKey& VarHandleBase::vhKey()
  {
    if (!m_ownedKey) {
      throwExcNonConstHandleKey (m_key->clid(), m_key->key(),
                                 m_key->storeHandle().name());
    }
    return *m_ownedKey;
  }
 

  StatusCode VarHandleBase::assign (const std::string& sgkey)
  {
    return vhKey().assign (sgkey);
  }
 

  std::string VarHandleBase::toString() const
  {
    std::string s =
      std::format ("VarHandleBase @{} store={}, clid={}, key{}----------- ptr@{}, proxy@{}",
                   static_cast<const void*>(this),
                   store(), clid(), key(),
                   CxxUtils::as_const_ptr (m_ptr),
                   static_cast<const void*>(m_proxy));
    if (m_proxy)
      s += std::format (", DataObject@{}",
                        static_cast<const void*>(m_proxy->object()));
    return s;
  }
 
 
  //*************************************************************************
  // Protected methods.
  //
 

  StatusCode 
  VarHandleBase::setState(SG::DataProxy* proxy)
  {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB::setState({}, proxy={}) const\n", dbg::ptr(this), dbg::proxy(proxy));
#endif
    if (0 == proxy || !proxy->isValid()) {
      return StatusCode::FAILURE;
    }
 
    if (m_proxy != proxy) {
      // We're changing proxies.  Release the old and bind to the new.
      setProxy (proxy);
      // Clear cached pointer.
      m_ptr=0;
    }
 
    return StatusCode::SUCCESS;
  }
 

  StatusCode 
  VarHandleBase::setState(IProxyDict* store, const std::string& key)
  {
    if (0 == store) {
      return StatusCode::FAILURE;
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::setState({}, store={}, key={}) const\n", dbg::ptr(this), dbg::store(store), key);
#endif
    CLID cid = this->clid();
    SG::DataProxy* proxy = store->proxy(cid, key);
    return this->setState(proxy);
  }
 

  StatusCode
  VarHandleBase::record_impl (std::unique_ptr<DataObject> dobj,
                              void* dataPtr,
                              bool allowMods,
                              bool returnExisting)
  {
    if (!m_store) {
      if (m_ownedKey) {
        CHECK (m_ownedKey->initialize());
      }
      m_store = &*(this->storeHandle());
      m_storeWasSet = false;
    }
 
    if (this->name().empty()) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record an object with a null key";
      return StatusCode::FAILURE;
    }
    if (!dobj) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record null pointer";
      return StatusCode::FAILURE;
    }
 
    SG::DataObjectSharedPtr<DataObject> sptr (dobj.release());
    unsigned int initRefCount = sptr->refCount();
    SG::DataProxy* new_proxy = 
      m_store->recordObject (sptr, this->name(), allowMods, returnExisting);
    if (!new_proxy) {
      REPORT_ERROR (StatusCode::FAILURE) << "recordObject failed";
      resetProxy();
      return StatusCode::FAILURE;
    }
    if (m_proxy != new_proxy) {
      CHECK (this->setState (new_proxy));
    }
  
    if (new_proxy && initRefCount == sptr->refCount() && new_proxy->isValid()) {
      // If the reference count hasn't changed, then we've returned an existing
      // object rather than recording a new one.  Retrieve the pointer, making
      // sure that it isn't const.
      if (m_proxy->isConst()) {
        REPORT_ERROR (StatusCode::FAILURE)
          << "Found an existing const object from recordOrRetrieve.";
        return StatusCode::FAILURE;
      }
      m_ptr = typeless_dataPointer_impl(true);
      if (!allowMods)
        CHECK( setConst() );
    }
    else
      m_ptr=(void*)dataPtr;
 
    return StatusCode::SUCCESS;
  }
 

  const void*
  VarHandleBase::put_impl (const EventContext* ctx,
                           std::unique_ptr<DataObject> dobj,
                           const void* dataPtr,
                           bool allowMods,
                           bool returnExisting,
                           IProxyDict* & store) const
  {
    if (this->name().empty()) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record an object with a null key";
      return nullptr;
    }
 
    store = storeFromHandle (ctx);
    if (!store) {
      REPORT_ERROR (StatusCode::FAILURE) << "No store.";
      return nullptr;
    }
    if (!dobj) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record null pointer.";
      return nullptr;
    }
 
    SG::DataObjectSharedPtr<DataObject> sptr (std::move (dobj));
    unsigned int initRefCount = sptr->refCount();
    SG::DataProxy* new_proxy = 
      store->recordObject (sptr, this->name(), allowMods, returnExisting);
    if (!new_proxy) {
      REPORT_ERROR (StatusCode::FAILURE) << "recordObject failed";
      return nullptr;
    }
  
    if (new_proxy && initRefCount == sptr->refCount() && new_proxy->isValid()) {
      // If the reference count hasn't changed, then we've returned an existing
      // object rather than recording a new one.  Retrieve the pointer.
      dataPtr = typeless_dataPointer_fromProxy (new_proxy, true);
    }
 
    return dataPtr;
  }
 

  void* 
  VarHandleBase::typeless_dataPointer_impl (bool quiet)
  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::typeless_dataPointer_impl({}, ptr={}, proxy={}, key={}, store={})\n", dbg::ptr(this), dbg::ptr(this->m_ptr), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
 
    // First check for cached pointer.
    if (0 != m_ptr)
      return m_ptr;
 
    if (0 == m_proxy) {
      // No proxy, need to look it up.
      if (this->setState().isFailure() || !m_proxy) {
        if (!quiet) {
          REPORT_MESSAGE(MSG::WARNING)
            << "could not get proxy for key " << key();
          if (this->mode() != Gaudi::DataHandle::Reader) {
            REPORT_MESSAGE(MSG::WARNING)<< " try using a ReadHandle";
          }
        } //quiet
        return 0;
      } //setstate
    } //m_proxy
 
    m_ptr = typeless_dataPointer_fromProxy (m_proxy, quiet);
    return m_ptr;
  }
 

  void* VarHandleBase::typeless_ptr(bool quiet/*=defaultQuiet*/)
  {
    void* p = typeless_dataPointer(quiet);
    if (p != nullptr && isConst())
      throw SG::ExcConstObject (clid(), key(), store());
    return p;
  }
 
 
  /*
   * @brief Retrieve an object from SG as a const pointer without caching.
   * @param ctx The event context, or nullptr to use the current context.
   * @param quiet If true, suppress failure messages.
   *
   * Like typeless_dataPointer_impl, except that we don't change
   * any members of the handle.
   */
  const void* VarHandleBase::get_impl (const EventContext* ctx,
                                       bool quiet/*= defaultQuiet*/) const
  {
    if (this->mode() != Gaudi::DataHandle::Reader) {
      if (!quiet)
        REPORT_ERROR (StatusCode::FAILURE)
          << "get_impl called for a non-read handle.";
      return nullptr;
    }
 
    if (this->key().empty()) {
      if (!quiet)
        REPORT_ERROR (StatusCode::FAILURE)
          << "Cannot initialize a Read/Write/Update handle with a null key.";
      return nullptr;
    }
 
    IProxyDict* store = storeFromHandle (ctx);
    if (!store) {
      if (!quiet)
        REPORT_ERROR (StatusCode::FAILURE) << "No store.";
      return nullptr;
    }
 
    SG::DataProxy* proxy = store->proxy_exact(m_key->hashedKey());
    if (!proxy) {
      proxy = store->proxy(this->clid(), this->key());
      if (!proxy) {
        if (!quiet)
          REPORT_ERROR (StatusCode::FAILURE)
            << "Cannot find proxy for "
            << this->clid() << "/" << this->key();
        return nullptr;
      }
    }
 
    return typeless_dataPointer_fromProxy (proxy, quiet);
  }
 

  StatusCode VarHandleBase::symLink_impl (CLID newClid,
                                          const std::string& newKey)
  {
    if (!m_ptr || !m_store) {
      REPORT_ERROR (StatusCode::FAILURE) << "symlink: Handle not valid.";
      return StatusCode::FAILURE;
    }
    
    SG::DataObjectSharedPtr<DataObject> obj (new SymlinkDataObject (newClid, m_ptr));
    SG::DataProxy* prox = m_store->recordObject (obj, newKey, false, true);
    if (!prox)
      return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
  }
 

  IProxyDict* VarHandleBase::storeFromHandle (const EventContext* ctx) const
  {
    if (m_key->isEventStore()) {
      if (ctx)
        return Atlas::getExtendedEventContext(*ctx).proxy();
      if (m_storeWasSet && m_store) return m_store;
 
      const Atlas::ExtendedEventContext* ectx =
        Atlas::tryGetExtendedEventContext (Gaudi::Hive::currentContext());
 
      return (ectx ? ectx->proxy() : nullptr);
    }
 
    if (m_storeWasSet && m_store) return m_store;
    IProxyDict* store = m_store;
    if (!store)
      store = &*this->storeHandle();
 
    return store->hiveProxyDict();
  }
 

  bool VarHandleBase::setStoreFromHandle (const EventContext* ctx)
  {
    if (m_ownedKey) {
      if (m_ownedKey->initialize().isFailure()) {
        return false;
      }
    }
    m_store = storeFromHandle (ctx);
    m_storeWasSet = (ctx && m_store ==
                     Atlas::getExtendedEventContext(*ctx).proxy());
    return true;
  }
 

  void VarHandleBase::resetProxy()
  {
    if (m_proxy) {
      if (m_ownedKey) {
        m_proxy->unbindHandle(this);
        m_proxy->release();
      }
      m_proxy = nullptr;
    }
  }
 

  void VarHandleBase::setProxy (SG::DataProxy* proxy)
  {
    resetProxy();
    if (proxy) {
      if (m_ownedKey) {
        proxy->addRef();
        proxy->bindHandle (this);
      }
      m_proxy = proxy;
    }
  }
 

  void* 
  VarHandleBase::typeless_dataPointer_fromProxy (SG::DataProxy* proxy,
                                                 bool quiet) const
  {
    if (!proxy || !proxy->isValid()) {
      // invalid proxy
      if (!quiet) {
        REPORT_MESSAGE(MSG::WARNING)
          << "Proxy "
          << " [" << (proxy != 0 ? proxy->clID() : 0)
          << "/" << (proxy != 0 
                     ? proxy->name() 
                     : std::string("<N/A>"))
          << "] is in an invalid state";
      } //quiet
      return nullptr;
    }
 
    DataObject* dobj = proxy->accessData();
    if (!dobj) {
      // invalid dobj
      if (!quiet) {
        REPORT_MESSAGE(MSG::WARNING)
          << "this proxy " << MSG::hex << proxy
          << MSG::dec << " has a NULL data object ptr";
      }
      return nullptr;
    }
 
    const CLID clid = this->clid();
    void* ptr = SG::Storable_cast(dobj, clid, nullptr, true, proxy);
    if (ptr)
      return ptr;
 
    // If ptr is null, probably the clid we gave wasn't the clid
    // the object was stored with, nor it inherits from it.
    // before giving up, let's check its transient CLIDs
    DataBucketBase *dbb = 0;
    if (proxy->transientID(clid) &&
        0 != (dbb = dynamic_cast<DataBucketBase*>(dobj))) {
      // it is a symlink after all.
      // Let's hard cast (and keep our fingers Xed)
      ptr = static_cast<void*>(dbb->object());
    } else {
      if (!quiet) {
        REPORT_MESSAGE(MSG::WARNING)
          << "Request for an invalid object; requested CLID = " 
          << clid 
          << ", proxy primary ID is " << proxy->clID();
      }
    } // try symlink -- endif
    return ptr;
  }
 

  bool VarHandleBase::isPresent_impl (const std::string& key) const
  {
    const DataProxy* proxy = m_proxy;
    if (!proxy) {
      const IProxyDict* store = m_store;
      if (!store)
        store = this->storeHandle().get();
      if (store)
        proxy = store->proxy(this->clid(), key);
    }
    if (proxy) {
      return proxy->isValid();
    }
    return false;
  }
 
 
//*************************************************************************
  // Free functions.
  //
 

  std::ostream& operator<<( std::ostream& out, const VarHandleBase& o )
  {
    std::print (out, "{}", o.toString());
    return out;
  }
 

  bool operator==(const VarHandleBase& l, const VarHandleBase& r)
  {
    return (l.clid() == r.clid() &&
            l.mode() == r.mode() &&
            l.name() == r.name() &&
            l.store() == r.store());
  }
 

  bool operator!=(const VarHandleBase& l, const VarHandleBase& r)
  {
    return !(l==r);
  }
 
 
} /* namespace SG */