DataProxyHolder.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
 
#include "AthLinks/tools/DataProxyHolder.h"
#include "AthLinks/tools/DataProxyHolderInputRename.h"
#include "AthLinks/exceptions.h"
#include "SGTools/DataProxy.h"
#include "SGTools/DataProxy_cast.h"
#include "SGTools/TransientAddress.h"
#include "SGTools/CurrentEventStore.h"
#include "AthenaKernel/ThinningCache.h"
#include "AthenaKernel/ThinningDecisionBase.h"
#include "AthenaKernel/IProxyDict.h"
#include "AthenaKernel/errorcheck.h"
#include "AthenaKernel/ExtendedEventContext.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/ThreadLocalContext.h"
 
 
namespace {
 

const Athena::IInputRename::InputRenameRCU_t* s_inputRenameMap ATLAS_THREAD_SAFE
  = nullptr;
 
 
}
 
 
namespace SG {
 

DataProxyHolder::sgkey_t
DataProxyHolder::toStorableObject (const_pointer_t obj,
                                   CLID link_clid,
                                   IProxyDict* sg)
{
  sgkey_t key = 0;
  if (obj == 0) {
    // Setting the link to null.
    m_proxy = 0;
  }
  else {
    // Find the store to use.
    if (sg == 0)
      sg = this->source1();
    if (sg == 0)
      sg = SG::CurrentEventStore::store();
 
    if (sg) {
      m_proxy = sg->proxy (obj);
    }
    if (m_proxy == 0) {
      // Didn't find a proxy for this object.
      // Store the object pointer directly, and return 0.
      storeObjpointer (obj);
    }
    else {
      // Found a proxy.  Fetch the SG key and check that the type of the object
      // is consistent with the link type.
      key = m_proxy->sgkey();
      if (link_clid != m_proxy->clID() && !m_proxy->transientID (link_clid)) {
        if (m_proxy->clID() != CLID_NULL)
          throw SG::ExcCLIDMismatch (m_proxy->clID(), link_clid);
 
        // Transient clid was null.
        // This can happen when reading a view vector with xAODRootAccess
        // in an athena build, where the TAD may not get a CLID set.
        // Check based on key.
        if (sg) {
          sgkey_t link_sgkey = sg->stringToKey (m_proxy->name(), link_clid);
          if (link_sgkey != m_proxy->sgkey())
            throw SG::ExcCLIDMismatch (m_proxy->clID(), link_clid);
        }
      }
    }
  }
  return key;
}
 

DataProxyHolder::sgkey_t
DataProxyHolder::toIdentifiedObject (const ID_type& dataID,
                                     CLID link_clid,
                                     IProxyDict* sg)
{
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  if (!sg)
    return 0;
 
  // Look up the proxy.
  m_proxy = sg->proxy (link_clid, dataID);
  if (m_proxy == 0) {
    // Didn't find a proxy; make a dummy.
    SG::TransientAddress tad (link_clid, dataID);
    tad.setSGKey (sg->stringToKey (dataID, link_clid));
    m_proxy = new SG::DataProxy (std::move(tad), static_cast<IConverter*>(nullptr));
    if (sg->addToStore (link_clid, m_proxy).isFailure())
      std::abort();
  }
 
  // Return the proxy's sgkey.
  return m_proxy->sgkey();
}
 

void
DataProxyHolder::toIdentifiedObject (sgkey_t sgkey,
                                     CLID link_clid,
                                     IProxyDict* sg)
{
  if (!sgkey) return;
 
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  if (!sg)
    return;
 
  // Look up the proxy.
  m_proxy = sg->proxy_exact (sgkey);
 
  CLID clid = CLID_NULL;
  const std::string* key = nullptr;
  if (m_proxy == 0) {
    // Didn't find it --- have SG query proxy providers.
    // Try to turn the hashed key into a string key + clid.
    key = sg->keyToString (sgkey, clid);
    if (key) {
      if (link_clid != CLID_NULL && clid != link_clid)
        throw SG::ExcCLIDMismatch (clid, link_clid);
      m_proxy = sg->proxy (clid, *key);
    }
  }
  
  if (m_proxy == 0) {
    // Still didn't find it --- make a dummy.
    SG::TransientAddress tad;
    if (key) {
      tad = SG::TransientAddress (clid, *key);
    }
    tad.setSGKey (sgkey);
    m_proxy = new SG::DataProxy (std::move(tad), static_cast<IConverter*>(nullptr));
    if (sg->addToStore (clid, m_proxy).isFailure())
      std::abort();
  }
  else if (link_clid != CLID_NULL &&
           m_proxy->clID() != CLID_NULL &&
           !m_proxy->transientID(link_clid))
  {
    // Found a proxy, but types don't match.
    throw SG::ExcCLIDMismatch (m_proxy->clID(), link_clid);
  }
}
 

const DataProxyHolder::ID_type&
DataProxyHolder::dataID() const
{
  SG::DataProxy* dp = proxy (true);
  if (dp)
    return dp->name();
 
  static const std::string dummy;
  return dummy;
}
 

void* DataProxyHolder::storableBase (castfn_t* castfn,
                                     CLID clid,
                                     bool isConst) const
{
  // Test for null link.
  if (!m_proxy)
    return 0;
 
  // Test for direct pointer to an object.
  if (isObjpointer())
    return objpointer();
 
  // We have a proxy.  Check that we're not trying to use an object
  // that's been marked const in SG in a non-const way.
  if (!isConst && m_proxy->isConst()) {
    throw SG::ExcConstStorable (m_proxy->clID(),
                                m_proxy->name(),
                                m_proxy->sgkey());
  }
 
  // Ok --- DataProxy is thread-safe.
  SG::DataProxy* proxy_nc ATLAS_THREAD_SAFE = m_proxy;
 
  // Get the object pointer from the proxy.
  // We have to take care of converting to the proper return type, though
  // (as requested by clid).
  void* obj = castfn ? castfn (m_proxy) : SG::DataProxy_cast (proxy_nc, clid);
  if (obj)
    return obj;
 
  // We failed.  It may be that we don't have a conversion
  // between clid and the object type: it may have been stored
  // using a hard cast.  Check to see if this object has actually
  // been registered under the requested clid.
  if (m_proxy->transientID (clid)) {
    DataBucketBase* db =
      dynamic_cast<DataBucketBase*> (proxy_nc->accessData());
 
    // Do a hard cast...
    if (db)
      return db->object();
  }
 
  return 0;
}
 

IProxyDict* DataProxyHolder::source() const
{
  SG::DataProxy* dp = proxy();
  if (!dp)
    return 0;
  return dp->store();
}
 

void
DataProxyHolder::toTransient (sgkey_t sgkey, IProxyDict* sg /*= 0*/)
{
  m_proxy = 0;
 
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  // Do input renaming.
  if (s_inputRenameMap) {
    using InputRenameMap_t = Athena::InputRenameMap_t;
    Athena::RCURead<InputRenameMap_t> r (*s_inputRenameMap);
    auto it = r->find (sgkey);
    if (it != r->end())
      sgkey = it->second.m_sgkey;
  }
 
  if (sgkey)
    toIdentifiedObject (sgkey, CLID_NULL, sg);
}
 

DataProxyHolder::sgkey_t
DataProxyHolder::toTransient (const ID_type& dataID,
                              CLID link_clid,
                              IProxyDict* sg /*= 0*/)
{
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  sgkey_t sgkey = sg->stringToKey (dataID, link_clid);
  toTransient (sgkey, sg);
  return sgkey;
}
 

void DataProxyHolder::toPersistentNoRemap (sgkey_t& sgkey)
{
  if (!sgkey && m_proxy) {
    m_proxy = proxy(); // May throw.
    sgkey = m_proxy->sgkey();
  }
}
 

bool DataProxyHolder::toPersistent (sgkey_t& sgkey, uint64_t& index)
{
  toPersistentNoRemap (sgkey);
  size_t index_s = index;
  bool ret = tryRemap (sgkey, index_s);
  if (ret)
    index = index_s;
  return ret;
}
 

bool DataProxyHolder::toPersistent (sgkey_t& sgkey, uint32_t& index)
{
  toPersistentNoRemap (sgkey);
  size_t index_s = index;
  bool ret = tryRemap (sgkey, index_s);
  if (ret)
    index = static_cast<uint32_t>(index_s);
  return ret;
}
 

bool DataProxyHolder::tryRemap (sgkey_t& sgkey, size_t& index)
{
  if (sgkey) {
    // Check for remapping.
    sgkey_t sgkey_out;
    size_t index_out = 0;
    IProxyDict* sg = this->source();
    if (sg && sg->tryELRemap (sgkey, index, sgkey_out, index_out)) {
      this->toIdentifiedObject (sgkey_out, CLID_NULL, this->source());
      sgkey = sgkey_out;
      index = index_out;
      return true;
    }
  }
 
  return false;
}
 

bool DataProxyHolder::thin (sgkey_t& sgkey, size_t& index,
                            const SG::ThinningCache* thinningCache)
{
  if (!sgkey) {
    return false;
  }
 
  // Check for thinning.
  if (thinningCache) {
    const SG::ThinningDecisionBase* dec = thinningCache->thinning (sgkey);
    if (dec) {
      // Get the updated index:
      const std::size_t persIdx = dec->index( index );
 
      // If the object was thinned away, set the persistent variables to an
      // invalid state. Otherwise update just the index variable.
      if( persIdx == ThinningDecisionBase::RemovedIdx ) {
        sgkey = 0;
        index = 0;
        return true;
      }
      else {
        if (index != persIdx) {
          index = persIdx;
          return true;
        }
      }
    }
  }
 
  return false;
}
 

void DataProxyHolder::throwInvalidLink (sgkey_t sgkey) const
{
  CLID clid = CLID_NULL;
  std::string key;
  SG::DataProxy* dp = proxy();
  if (dp) {
    clid = dp->clID();
    key = dp->name();
  }
  throw SG::ExcInvalidLink (clid, key, sgkey);
}
 

SG::DataProxy* DataProxyHolder::proxy1(bool nothrow) const
{
  const_pointer_t obj = reinterpret_cast<const_pointer_t>
    (reinterpret_cast<unsigned long> (m_proxy) & ~1UL);
  SG::DataProxy* proxy = SG::CurrentEventStore::store()->proxy (obj);
  if (proxy == 0 && !nothrow)
    throw SG::ExcPointerNotInSG (obj);
  return proxy;
}
 
 

bool DataProxyHolder::operator== (const DataProxyHolder& other) const
{
  if (m_proxy == other.m_proxy) return true;
 
  // One could refer to an object directly by pointer, the other could
  // have a proxy.
 
  const_pointer_t ptr = 0;
  const DataProxy* proxy = 0;
  if (isObjpointer() && !other.isObjpointer()) {
    ptr = objpointer();
    proxy = other.m_proxy;
  }
  else if (other.isObjpointer() && !isObjpointer()) {
    ptr = other.objpointer();
    proxy = m_proxy;
  }
  else
    return false;
 
  if (proxy->store()->proxy(ptr) == proxy)
    return true;
 
  return false;
}
 

void setDataProxyHolderInputRenameMap ATLAS_NOT_THREAD_SAFE
  (const Athena::IInputRename::InputRenameRCU_t* map)
{
  s_inputRenameMap = map;
}
 

IProxyDict* DataProxyHolder::source1()
{
  if (!m_proxy || isObjpointer()) {
    return 0;
  }
  return m_proxy->store();
}
 
 
} // namespace SG