DataProxy.icc

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 implementation of DataProxy_cast operator
 -----------------------------------------
 ATLAS Collaboration
***************************************************************************/
 
// $Id: DataProxy.icc,v 1.6 2008-07-14 22:16:25 calaf Exp $
 
#include "AthenaKernel/DataBucketBase.h"
#include "AthenaKernel/StorableConversions.h"
#include "AthenaKernel/ClassID_traits.h"
#ifndef NDEBUG
#  include "AthenaKernel/getMessageSvc.h"
#  include "GaudiKernel/MsgStream.h"
#endif
 
 
class DataObject;
 
 
/// Retrieve data object key == string
inline
const SG::DataProxy::name_type& SG::DataProxy::name() const
{
  // No locking needed.
  return m_tAddress.name();
}
 
 
/// Retrieve data object key == string
/// duplicated for Gaudi folks does same as name()
inline
const SG::DataProxy::id_type& SG::DataProxy::identifier() const
{
  // No locking needed.
  return m_tAddress.name();
}
 
 
/// Retrieve DataObject
inline
DataObject* SG::DataProxy::object ATLAS_NOT_CONST_THREAD_SAFE () const
{
  return m_dObject;
}
 
 
/// Retrieve IOpaqueAddress
inline
IOpaqueAddress* SG::DataProxy::address() const
{
  lock_t lock (m_mutex);
  return m_tAddress.address();
} 
 
 
/// set DataSvc (Gaudi-specific); do nothing for us
inline
IDataProviderSvc* SG::DataProxy::dataSvc() const
{
  return nullptr;
}
 
///< Get the primary (hashed) SG key.
inline
SG::sgkey_t SG::DataProxy::sgkey() const
{
  // No lock; underlying member is atomic.
  return m_tAddress.sgkey();
}
 
 
/// Set the primary (hashed) SG key.
inline
void SG::DataProxy::setSGKey (sgkey_t sgkey)
{
  lock_t lock (m_mutex);
  m_tAddress.setSGKey (sgkey);
}
 
 
///< Return the ID of the store containing this proxy.
inline
StoreID::type SG::DataProxy::storeID() const
{
  lock_t lock (m_mutex);
  return m_tAddress.storeID();
}
 
 
///< check if it is a transient ID (primary or symLinked):
inline
bool SG::DataProxy::transientID (CLID id) const
{
  lock_t lock (m_mutex);
  return m_tAddress.transientID (id);
}
 
 
///< return the list of transient IDs (primary or symLinked):
inline
SG::DataProxy::CLIDCont_t SG::DataProxy::transientID() const
{
  lock_t lock (m_mutex);
  return m_tAddress.transientID();
}
 
 
/// Add a new transient ID
inline
void SG::DataProxy::setTransientID(CLID id)
{
  lock_t lock (m_mutex);
  m_tAddress.setTransientID (id);
}
 
 
/// access set of proxy aliases
/// Returns a COPY of the alias set.
inline
SG::DataProxy::AliasCont_t SG::DataProxy::alias() const
{
  lock_t lock (m_mutex);
  return m_tAddress.alias();
}
 
 
/// Add a new proxy alias.
inline
void SG::DataProxy::setAlias(const std::string& key)
{
  lock_t lock (m_mutex);
  m_tAddress.setAlias (key);
}
 
 
/// Test to see if a given string is in the alias set.
inline
bool SG::DataProxy::hasAlias(const std::string& key) const
{
  lock_t lock (m_mutex);
  const AliasCont_t& alias = m_tAddress.alias();
  return alias.find(key) != alias.end();
}
 
 
/// remove alias from proxy
inline
bool SG::DataProxy::removeAlias(const std::string& key)
{
  lock_t lock (m_mutex);
  return m_tAddress.removeAlias (key);
}
 
 
/// Return the address provider.
inline
IAddressProvider* SG::DataProxy::provider()
{
  lock_t lock (m_mutex);
  return m_tAddress.provider();
}
 
 
/// Set the address provider.
inline
void SG::DataProxy::setProvider(IAddressProvider* provider,
                                StoreID::type storeID)
{
  lock_t lock (m_mutex);
  m_tAddress.setProvider (provider, storeID);
}
 
 
/// Set the CLID / key.
/// This will only succeed if the clid/key are currently clear.
inline
void SG::DataProxy::setID (CLID id, const std::string& key)
{
  lock_t lock (m_mutex);
  m_tAddress.setID (id, key);
}
 
 
/// am I valid?
inline
bool SG::DataProxy::isValid() const
{
  return (isValidObject() || isValidAddress());
}
 
 
/// is the object valid?
inline
bool SG::DataProxy::isValidObject() const
{
  // FIXME: should we try to chase?
  return (0!= m_dObject);
}
 
 
/// Access DataObject on-demand using conversion service
///@throws runtime_error when converter fails
inline
DataObject* SG::DataProxy::accessData()
{
  // Inlined part: return m_dObject if it's valid.
  // Otherwise, call the out-of-line part of the code.
  if (0 != m_dObject) return m_dObject;  // cached object
  return accessDataOol();
}
 
 
inline
SG::DataProxy::ErrNo SG::DataProxy::errNo() const
{
  lock_t lock (m_objMutex);
  return m_errno;
}
 
 
/// Retrieve clid
inline
CLID SG::DataProxy::clID() const
{
  // No lock; underlying member is atomic.
  return m_tAddress.clID();
}
 
 
/// Check if it is a const object
inline
bool SG::DataProxy::isConst() const
{
  // No lock; underlying member is atomic.
  return m_const;
}
 
 
/// set the reset only flag: Clear Store will reset and not delete.
inline
void SG::DataProxy::resetOnly(const bool& flag)
{
  lock_t lock (m_mutex);
  m_resetFlag = flag;
}
 
 
/// Check reset only:
inline
bool SG::DataProxy::isResetOnly() const
{
  lock_t lock (m_mutex);
  return m_resetFlag;
}
 
 
/// Set the store of which we're a part.
inline
void SG::DataProxy::setStore (IProxyDict* store)
{
  m_store = store;
}
 
/// Return the store of which we're a part.
inline
IProxyDict* SG::DataProxy::store()
{
  return m_store;
}
 
 
/// Return the store of which we're a part.
inline
const IProxyDict* SG::DataProxy::store() const
{
  return m_store;
}
 
 
inline
IConverter* SG::DataProxy::loader()
{
  lock_t lock (m_mutex);
  return m_dataLoader;
}
 
 
template <typename DATA>
DATA* SG::DataProxy_cast(SG::DataProxy* proxy) {
  DATA* result(0);
 
  if (0 != proxy && proxy->isValid()) {
    DataObject* pObject(proxy->accessData());
 
    if (0 != pObject) {
      const CLID& dataID(ClassID_traits<DATA>::ID());
      result = SG::Storable_cast<DATA>(pObject, true, proxy, proxy->isConst());
      if (0 == result) { 
        //if result is 0, probably DATA is neither the type the object was
        // stored with, nor it inherits from it. 
        // Before giving up let's check its transient CLIDs
        DataBucketBase* db(0);
        if (proxy->transientID(dataID) &&
            0 != (db = dynamic_cast<DataBucketBase*>(pObject)) )
          {
            //it is a symlink after all. Let's hard cast and keep our fingers Xed
            // But first: if this is a non-const proxy, then the cast
            // may have failed because it needed to go via a copying conversion
            // that's not allowed for non-const objects.  So try the conversion
            // again as const; if that works, then don't do the hard cast.
            if (!proxy->isConst() &&
                SG::Storable_cast<DATA>(pObject, true, proxy, true) != 0)
              {
#ifndef NDEBUG
                MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
                gLog << MSG::WARNING 
                     << "Request for a non-const object via copying conversion; "
                     << "requested CLID = " << dataID 
                     << ", proxy primary ID is " << proxy->clID() << endmsg   ;
#endif
              }
            else {
              // ok, hard cast.
              result = static_cast<DATA*>(db->object());
            }
          }
        else { 
#ifndef NDEBUG
          MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
          gLog << MSG::WARNING 
               << "Request for an invalid object; requested CLID = " 
               << dataID 
               << ", proxy primary ID is " << proxy->clID() << endmsg   ;
#endif
        } //try symlink
      } //result 0
    } else { // invalid pObject
#ifndef NDEBUG
      MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
      gLog << MSG::WARNING 
           << "this proxy " << MSG::hex << proxy
           << MSG::dec << " has a NULL data object ptr" << endmsg;
#endif
    }
  } else {//    invalid proxy
#if 0
#ifndef NDEBUG
    MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
    gLog << MSG::WARNING 
         << "this proxy " << MSG::hex << proxy
         << MSG::dec << " [" << proxy->clID() << "/" << proxy->name()
         << "] is in an invalid state" << endmsg;
#endif
#endif
  }
  return result;
}
 
 
///const ref version of the cast. @throws SG::ExcBadDataProxyCast.
template<typename DATA>
DATA SG::DataProxy_cast(const SG::DataProxy& proxy)
{
  const DATA* result = SG::DataProxy_cast<DATA>(&proxy);
  if (!result) SG::throwExcBadDataProxyCast(proxy.clID(), typeid(DATA));
  return *result;
}