T_AthenaPoolCoolMultChanCnv.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
/** @file T_AthenaPoolCoolMultChanCnv.icc
 *  @brief This templated class provides the POOL converter to
 *  translate a DataVector<ELEM_T> to and from a CondAttrListCollection. In
 *  this case, the elements of T are written/read and their POOL
 *  tokens are stored in CondAttrListCollection.
 *  @author RD Schaffer <R.D.Schaffer@cern.ch>
 **/
 
#include "AthenaPoolCnvSvc/IAthenaPoolCnvSvc.h"
#include "AthenaPoolUtilities/AthenaAttributeList.h"
#include "AthenaPoolUtilities/CondAttrListCollection.h"
#include "AthenaPoolUtilities/CondAttrListCollAddress.h"
#include "AthenaPoolUtilities/CondMultChanCollection.h"
 
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/MsgStream.h"
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AthenaKernel/StorableConversions.h"
 
#include "CxxUtils/checker_macros.h"
 
#include <exception>
#include <string>
#include <format>
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::T_AthenaPoolCoolMultChanCnv(ISvcLocator* svcloc)
    :
    T_AthenaPoolCustCnv<COLL_T, ELEM_T>(svcloc)
{
   ATH_MSG_DEBUG("AthenaPool Converter Constructor for " << this->classID());
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
StatusCode T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::createObj(IOpaqueAddress* pAddr, DataObject*& pObj)
{
    // This is the "read" method for a collection T (i.e. DataObject
    // pObj) which contains objects of type T::value_type.
    //
    // There are two situations we must allow for:
    //
    //   1) When reading from COOL - the "standard production" scenario
    //   2) When reading directly the collection from a pool file/db.
    //      This is used by "developers" who are testing their
    //      conditions objects
    //
    // For 1) the IOpaqueAddress contains a ptr to a
    // CondAttrListCollection, and this contains tokens to each of the
    // objects in the collection to be read.
    //
    // For 2) the IOpaqueAddress DOES NOT contain a ptr to a
    // CondAttrListCollection, rather we simply use the collection
    // token and read in the CondMultChanCollImpl and build a
    // CondAttrListCollection
    //
 
    ATH_MSG_DEBUG("Read in objects for collection");
 
    m_persCtx = pAddr->ipar()[0];
 
    CondAttrListCollAddress* addr = dynamic_cast<CondAttrListCollAddress*>(pAddr);
 
    std::unique_ptr<COLL_T> obj;
    if (addr) {
    // Successful cast - situation 1)
 
    // Loop over tokens inside the CondAttrListCollection, read
    // them in and add them to the data object.
    CondAttrListCollection* coll = addr->attrListColl();
        COLL_T* pobj = nullptr;
    StatusCode sc = attrListCollToObject(coll, pobj);
        obj = std::unique_ptr<COLL_T>(pobj);
    if (sc != StatusCode::SUCCESS) {
        ATH_MSG_ERROR("Unable to read in tokens from CondAttrListCollection");
        return(StatusCode::FAILURE);
    }
    ATH_MSG_DEBUG("Created CondAttrListCollection from an CondAttrListCollAddress");
    } else {
    // Situation 2) - read in the CondMultChanCollImpl and build a
    // CondAttrListCollection from the CondMultChanCollImpl
        COLL_T* pobj = nullptr;
    StatusCode sc = condMultChanCollImplToObject( *(pAddr->par()), pobj);
        obj = std::unique_ptr<COLL_T>(pobj);
    if (sc != StatusCode::SUCCESS) {
        ATH_MSG_ERROR("Unable to read in CondMultChanCollImpl");
        return(StatusCode::FAILURE);
    }
    ATH_MSG_DEBUG("Created CondAttrListCollection from an CondMultChanCollImpl");
    }
 
    // Initialize object after having been read in
    StatusCode sc = obj->initialize();
    if (sc != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Unable to initialize object read in");
    return(StatusCode::FAILURE);
    }
 
    // Convert to DataObject
    pObj = SG::asStorable (std::move (obj));
    if (!pObj) {
    ATH_MSG_ERROR("Cannot get DataObject from COLL_T");
    return(StatusCode::FAILURE);
    }
    ATH_MSG_DEBUG("End createObj");
    return(StatusCode::SUCCESS);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
StatusCode
T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::objectToAttrListColl ATLAS_NOT_THREAD_SAFE
  (COLL_T* obj, IOpaqueAddress*& pAddr,
   CondAttrListCollection*& attrListColl,
   std::unique_ptr<Token>& implToken)
{
    ATH_MSG_DEBUG("Creating a CondAttrListCollection from a collection");
 
 
    attrListColl = new CondAttrListCollection(true); // set hasRunEventTime
 
    // Make sure the channel vector is filled
    if (obj->size() != obj->chan_size()) {
    ATH_MSG_ERROR("Must fill in channel numbers! Number of objects: " << obj->size()
        << "  Number of channels: " << obj->chan_size());
    return(StatusCode::FAILURE);
    }
 
    // Fill IOVs if they are there
    bool hasIOVs = (obj->iov_size() == obj->size());
 
    // Get the contained object in the COLL_T
    CondMultChanCollImpl*  impl = obj->implementation();
 
    // Reset tokens in case this object was previously written out
    impl->resetTokens();
 
    // Loop over objects in COLL_T*
    typename COLL_T::chan_const_iterator itChan = obj->chan_begin();
    typename COLL_T::iov_const_iterator  itIOV  = obj->iov_begin();
    std::string token_str;
    std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
    for (unsigned int chan = 0; chan < obj->size(); ++chan, ++itChan) {
    ELEM_T* elem = (*obj)[chan];
        // Allow for T/P separation, convert to persistent object
        ELEM_P* elem_p = this->createPersistent(elem);
        std::unique_ptr<Token> token;
    StatusCode sc = this->objectToPool(elem_p, token, "", *pAddr->par());
    if (sc != StatusCode::SUCCESS || !token) {
        ATH_MSG_ERROR("Unable to write out object");
        return(StatusCode::FAILURE);
    }
        token_str = token->toString();
 
    // Create a new AthenaAttributeList
    AthenaAttributeList attrList;
        attrList.extend("PoolRef","string");
    attrList["PoolRef"].setValue( token_str );
    attrListColl->add((*itChan), attrList);
    if (hasIOVs) {
        attrListColl->add((*itChan), (*itIOV));
        ++itIOV;
    }
    ATH_MSG_DEBUG("Adding new attrList for token: " << token_str);
 
    // Save as well in implementation
    impl->add(token_str);
    }
 
    // Print out tokens
    ATH_MSG_DEBUG("Print out tokens in implementaion:");
    CondMultChanCollImpl::token_const_iterator itToken    = impl->token_begin();
    CondMultChanCollImpl::token_const_iterator itTokenEnd = impl->token_end();
    CondMultChanCollImpl::chan_const_iterator  itChan1  = impl->chan_begin();
    for (; itToken != itTokenEnd; ++itToken, ++itChan1) {
    ATH_MSG_DEBUG(*itToken);
    ATH_MSG_DEBUG("Chan " << *itChan1);
    }
 
    StatusCode sc = this->objectToPool(impl, implToken, "", *pAddr->par());
    if (sc != StatusCode::SUCCESS || !implToken) {
    ATH_MSG_ERROR("Unable to write out CondMultChanCollImpl");
    return(StatusCode::FAILURE);
    }
    ATH_MSG_DEBUG("Wrote out CondMultChanCollImpl - token: " << implToken->toString());
 
    ATH_MSG_DEBUG("End objectToAttrListColl");
    return(StatusCode::SUCCESS);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
StatusCode T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::createRep(DataObject* pObj, IOpaqueAddress*& pAddr)
{
    // This is the "write" method for a collection of COLL_T*
    // (i.e. DataObject pObj). Each element of the collection is
    // written out and the tokens are stored in a
    // CondAttrListCollection.
 
    ATH_MSG_DEBUG("Write out objects in collection");
 
    COLL_T* obj = 0;
    SG::fromStorable(pObj, obj);
    if (!obj) {
    ATH_MSG_ERROR("Unable to convert DataObject");
    return(StatusCode::FAILURE);
    }
    CondAttrListCollection* coll = 0;
    std::unique_ptr<Token> token;
    // Ok, because it's just creating a new list.
    StatusCode sc ATLAS_THREAD_SAFE = objectToAttrListColl(obj, pAddr, coll, token);
    if (sc != StatusCode::SUCCESS || !token) {
    ATH_MSG_ERROR("Unable to get objects and fill CondAttrListCollection with tokens");
    return(StatusCode::FAILURE);
    }
    CondAttrListCollAddress* addr = new CondAttrListCollAddress(POOL_StorageType,
                                this->classID(),
                                token->toString());
    addr->setAttrListColl(coll);
    delete pAddr; pAddr = addr;
    pAddr->addRef();
 
    ATH_MSG_DEBUG("End createRep");
    return(StatusCode::SUCCESS);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
StatusCode T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::fillRepRefs(IOpaqueAddress* /*pAddr*/, DataObject* /*pObj*/)
{
    ATH_MSG_DEBUG("End fillRepRefs");
    return(StatusCode::SUCCESS);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
StatusCode
T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::attrListCollToObject(CondAttrListCollection* attrListColl,
                                  COLL_T*& obj)
{
 
    ATH_MSG_DEBUG("Creating a collection from a CondAttrListCollection");
 
    // Create collection
    obj          = new COLL_T();
 
    // Check the sizes of objs and IOVs
    if (attrListColl->size() != attrListColl->iov_size()) {
    ATH_MSG_ERROR("CondAttrListCollection incorrect size for IOVs! "
        << "  Number of objects: " << attrListColl->size()
        << "  Number of IOVs:    " << attrListColl->iov_size());
    return(StatusCode::FAILURE);
    }
 
    /// Add the pointer to the CondAttrListCollection to COLL_T
    /// object. This will allow subsequent addition of IOVRange
    /// objects added to COLL_T to be propagated to the
    /// CondAttrListCollection. This is needed for IOV registration
    /// which may happen AFTER a read back of the COLL_T.
    obj->implementation()->setAttrListColl(attrListColl);
 
    // Loop over objects in COLL_T*
    std::string token;
    CondAttrListCollection::const_iterator      it    = attrListColl->begin();
    CondAttrListCollection::const_iterator      last  = attrListColl->end();
    CondAttrListCollection::iov_const_iterator  itIOV = attrListColl->iov_begin();
    Token poolToken;
    char context[32];
    const std::string contextStr = std::format("[CTXT={:08X}]", m_persCtx);
    std::strncpy(context, contextStr.c_str(), sizeof(context) - 1);
    for (; it != last; ++it, ++itIOV) {
    try {
        // pool token/ref
            const coral::AttributeList& attrList = (*it).second;
            token=attrList["PoolRef"].data<std::string>();
    }
        // FIXME exception
    catch(const std::exception& x) {
        ATH_MSG_ERROR("PoolRef not found in attribute list");
        return(StatusCode::FAILURE);
    }
        // Allow T/P separation - set token and use createTransient
        ELEM_T* elem {nullptr};
        {
           std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
           poolToken.fromString(token + context);
           elem = this->createTransient(&poolToken);
        }
    // Add elem, channel number and IOV
    obj->push_back(elem);
    obj->add((*it).first);
    obj->add((*itIOV).second);
 
    ATH_MSG_DEBUG("Read in new object for token: " << token);
 
    }
 
    ATH_MSG_DEBUG("End attrListCollToObject");
    return(StatusCode::SUCCESS);
}
 
/// Read in CondMultChanCollImpl and the objects for its tokens,
/// saving them in the output collection
/// @param collImpl     [IN]  CondMultChanCollImpl token
/// @param obj          [OUT] pointer to the collection of objects.
template <class COLL_T, class ELEM_T, class ELEM_P>
StatusCode
T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::condMultChanCollImplToObject(const std::string& collImplToken,
                                      COLL_T*& obj)
{
 
    ATH_MSG_DEBUG("Creating a collection from a CondMultChanCollImpl for token");
 
    // Create collection
    obj          = new COLL_T();
    ELEM_T* elem = 0;
 
    // Read in the CondMultChanCollImpl
    std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
    CondMultChanCollImpl* impl = 0;
    Token poolToken;
    char context[32];
    const std::string contextStr = std::format("[CTXT={:08X}]", m_persCtx);
    std::strncpy(context, contextStr.c_str(), sizeof(context) - 1);
    poolToken.fromString(collImplToken + context);
    StatusCode sc = this->poolToObject(&poolToken, impl);
    if (sc != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Unable to read in CondMultChanCollImpl");
    return(StatusCode::FAILURE);
    }
 
    // Make sure the channel vector is filled
    if (impl->token_size() != impl->chan_size()) {
    ATH_MSG_ERROR("Token and channel vectors are not the same size! Number of tokens: " << impl->token_size()
        << "  Number of channels: " << impl->chan_size());
    return(StatusCode::FAILURE);
    }
 
    // Fill IOVs if they are there
    bool hasIOVs = (impl->iov_size() == impl->token_size());
 
    // Loop over tokens in Impl and retrieve objects
    CondMultChanCollImpl::chan_const_iterator  itChan  = impl->chan_begin();
    CondMultChanCollImpl::iov_const_iterator   itIOV   = impl->iov_begin();
    CondMultChanCollImpl::token_const_iterator itToken = impl->token_begin();
    for (unsigned int i = 0; i < impl->chan_size(); ++i, ++itChan, ++itIOV, ++itToken) {
 
        // Allow T/P separation
        poolToken.fromString(*itToken + context);
        elem = this->createTransient(&poolToken);
 
    // Add elem, channel number and IOV
    obj->push_back(elem);
    obj->add(*itChan);
    if (hasIOVs)obj->add(*itIOV);
 
    ATH_MSG_DEBUG("Read in new object for token: " << *itToken);
    }
 
    // Now remove impl
    delete impl;
 
    ATH_MSG_DEBUG("End condMultChanCollImplToObject");
    return(StatusCode::SUCCESS);
}
 
/// Dummy methods not needed here
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
inline
StatusCode T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::transToPers(COLL_T* /*obj*/, ELEM_T*& /*persObj*/)
{
    return(StatusCode::SUCCESS);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
inline
StatusCode T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::persToTrans(COLL_T*& /*transObj*/, ELEM_T* /*obj*/)
{
    return(StatusCode::SUCCESS);
}
 
//__________________________________________________________________________
// Read object of type P.  This is an exception-throwing version of poolToObject()
// plus reading of all extending objects
template <class COLL_T, class ELEM_T, class ELEM_P>
template <class P>
inline
P* T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::poolReadObject(const Token* token) {
   P* persObj = 0;
   if( this->poolToObject( token , persObj ).isFailure() ) {
      throw std::runtime_error("POOL read failed");
   }
   return(persObj);
}
 
//__________________________________________________________________________
// Read object of type P.  This is an exception-throwing version of poolToObject()
// plus reading of all extending objects
template <class COLL_T, class ELEM_T, class ELEM_P>
inline
ELEM_T* T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::poolReadObject(const Token* token) {
   ELEM_T* persObj = 0;
   if( this->poolToObject( token, persObj ).isFailure() ) {
      throw std::runtime_error("POOL read failed");
   }
   return(persObj);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
ELEM_P* T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::createPersistent(ELEM_T* tobj)
{
    // Default implementation - ELEM_T == ELEM_P so just return input
    ELEM_P* obj = dynamic_cast<ELEM_P*>(tobj);
    return(obj);
}
 
//__________________________________________________________________________
template <class COLL_T, class ELEM_T, class ELEM_P>
ELEM_T* T_AthenaPoolCoolMultChanCnv<COLL_T, ELEM_T, ELEM_P>::createTransient(const Token* token)
{
    // Default version - no T/P separation. We read in transient
    // object
    //ELEM_T* elem = 0;
    ELEM_T* elem = this->poolReadObject(token);
    return(elem);
}