T_AthenaPoolCustCnv.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
/** @file T_AthenaPoolCustCnv.icc
 *  @brief This file contains the implementation for the templated T_AthenaPoolCustCnv class.
 *  @author Peter van Gemmeren <gemmeren@anl.gov>
 **/
 
#include "AthenaPoolCnvSvc/IAthenaPoolCnvSvc.h"
#include "AthenaPoolCnvSvc/exceptions.h"
 
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IRegistry.h"
 
#include "StorageSvc/DbReflex.h"
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AthenaKernel/ClassName.h"
#include "AthenaKernel/StorableConversions.h"
#include "PersistentDataModel/Token.h"
 
//__________________________________________________________________________
template <class TRANS, class PERS>
T_AthenaPoolCustCnv<TRANS, PERS>::T_AthenaPoolCustCnv(ISvcLocator* pSvcLocator,
                                                      const char* name /*= nullptr*/)
  : T_AthenaPoolCnvBase<TRANS>(pSvcLocator, name), m_className(), m_classDescs() {
}
//______________________________________________________________________________
template <class TRANS, class PERS>
StatusCode T_AthenaPoolCustCnv<TRANS, PERS>::initialize() {
   ATH_MSG_DEBUG("initialize() in T_AthenaPoolCustCnv " << classID());
   if (!T_AthenaPoolCnvBase<TRANS>::initialize().isSuccess()) {
      ATH_MSG_FATAL("Failed to initialize AthenaPoolConverter base class.");
      return(StatusCode::FAILURE);
   }
   return(this->m_athenaPoolCnvSvc->registerCleanUp(this));
}
//__________________________________________________________________________
template <class TRANS, class PERS>
CLID T_AthenaPoolCustCnv<TRANS, PERS>::classID() {
   return(ClassID_traits<TRANS>::ID());
}
//__________________________________________________________________________
template <class TRANS, class PERS>
template <class P>
Placement T_AthenaPoolCustCnv<TRANS, PERS>::setPlacementForP(P& /*p*/, const std::string& key, const std::string& output) {
   const std::string typenm = ClassName<P>::name();
   return(this->setPlacementWithType(typenm, key, output));
}
//__________________________________________________________________________
template <class TRANS, class PERS>
template <class P>
StatusCode T_AthenaPoolCustCnv<TRANS, PERS>::objectToPool(P* pObj, std::unique_ptr<Token>& token, const std::string& key, const std::string& output) {
   const static std::string className = ClassName<P>::name();
   // Check dictionary
   std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
   // Allow for multiple class names
   if (m_className != className) {
      m_className = className;
      // Different class name - get description
      auto itClass = m_classDescs.find(className);
      if (itClass == m_classDescs.end()) {
         // For new class names, check dictionary
         m_classDescs[className] = RootType( typeid(P) );
      }
   }
   Placement placement = setPlacementForP(*pObj, key, output);
   token.reset(this->m_athenaPoolCnvSvc->registerForWrite(&placement, pObj, m_classDescs[m_className]));
   return(StatusCode::SUCCESS);
}
//__________________________________________________________________________
template <class TRANS, class PERS>
template <class P>
StatusCode T_AthenaPoolCustCnv<TRANS, PERS>::poolToObject(const Token* token, P*& pObj) {
   pObj = nullptr;
   void* voidPtr = nullptr;
   try {
      this->m_athenaPoolCnvSvc->setObjPtr(voidPtr, token);
   }
   catch (const std::exception& ex) {
    AthenaPoolCnvSvc::throwExcCaughtException (__PRETTY_FUNCTION__,
                                               "pooltoObject",
                                               ex,
                                               typeid(P),
                                               token != nullptr ? token->toString() : "");
   }
   if (voidPtr == nullptr) {
      ATH_MSG_ERROR("poolToObject: Could not get object for Token = " << (token != nullptr ? token->toString() : ""));
      return(StatusCode::FAILURE);
   }
   pObj = reinterpret_cast<P*>(voidPtr);
   return(StatusCode::SUCCESS);
}
//__________________________________________________________________________
template <class TRANS, class PERS>
StatusCode T_AthenaPoolCustCnv<TRANS, PERS>::DataObjectToPool(IOpaqueAddress* pAddr, DataObject* pObj) {
   const std::string className = ClassName<TRANS>::name();
   ATH_MSG_DEBUG("Called DataObjectToPool for " << pObj << ": " << className << ", with key " << pObj->name());
   PERS* persObj = nullptr;
   TRANS* obj = nullptr;
   bool success = SG::fromStorable(pObj, obj);
   if (!success || obj == nullptr) {
      ATH_MSG_ERROR("failed to cast to T for class (type/key) " << className << "/" << pObj->name());
      return(StatusCode::FAILURE);
   }
   {
      std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
      if (!transToPers(obj, persObj).isSuccess()) {
         ATH_MSG_ERROR("Failed to convert to persistent DataType for class (type/key) " << className << "/" << pObj->name());
         return(StatusCode::FAILURE);
      }
   }
   std::unique_ptr<Token> token;
   StatusCode status = objectToPool<PERS>(persObj, token, pObj->name(), *pAddr->par());
   // Null/empty token means ERROR
   if (token == nullptr || token->classID() == Guid::null()) {
      ATH_MSG_ERROR("Failed to get Token for class (type/key) " << className << "/" << pObj->name());
      return(StatusCode::FAILURE);
   }
   // Update IOpaqueAddress for this object.
   TokenAddress* tokAddr = dynamic_cast<TokenAddress*>(pAddr);
   if (tokAddr != nullptr) {
      tokAddr->setToken(std::move(token));
   } else {
      return(StatusCode::FAILURE);
   }
   return(status);
}
//__________________________________________________________________________
template <class TRANS, class PERS>
StatusCode
T_AthenaPoolCustCnv<TRANS, PERS>::PoolToDataObject(DataObject*& pObj,
                                                   const Token* token,
                                                   const std::string& /*key*/)
{
   TRANS* transObj = nullptr;
   PERS* obj = nullptr;
   if (!poolToObject<PERS>(token, obj).isSuccess()) {
      ATH_MSG_ERROR("Failed to read persistent DataType");
      return(StatusCode::FAILURE);
   }
   {
      std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
      if (!persToTrans(transObj, obj).isSuccess()) {
         delete transObj; transObj = nullptr;
         delete obj; obj = nullptr;
         ATH_MSG_ERROR("Failed to convert to transient DataType");
         return(StatusCode::FAILURE);
      }
   }
   delete obj; obj = nullptr;
   pObj = SG::asStorable(transObj);
   return(StatusCode::SUCCESS);
}
//__________________________________________________________________________
// Compare POOL class GUID with the one from object being read
// To be used in createTransient(const Token* token)
template <class TRANS, class PERS>
inline bool T_AthenaPoolCustCnv<TRANS, PERS>::compareClassGuid(const Token* token, const pool::Guid &guid) const {
   return(token ? (guid == token->classID()) : false);
}