T_AthenaPoolCustomCnv.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
/** @file T_AthenaPoolCustomCnv.icc
 *  @brief This file contains the implementation for the templated T_AthenaPoolCustomCnv class.
 *  @author Marcin.Nowak@cern.ch
 **/
 
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IOpaqueAddress.h"
 
#include "StorageSvc/DbReflex.h"
 
#include "AthenaKernel/StorableConversions.h"
 
#include "AthenaPoolCnvSvc/exceptions.h"
#include "AthenaPoolCnvTPExtension.h"
 
#include <stdexcept>
 
template <class TRANS, class PERS>
T_AthenaPoolCustomCnvWithKey<TRANS, PERS>::T_AthenaPoolCustomCnvWithKey(ISvcLocator* pSvcLocator,
                                                                        const char* name /*= nullptr*/) : BaseType(pSvcLocator, name) {
}
 
template <class TRANS, class PERS>
StatusCode T_AthenaPoolCustomCnvWithKey<TRANS, PERS>::DataObjectToPool(IOpaqueAddress* pAddr, DataObject* pObj) {
   ATH_MSG_VERBOSE("In DataObjectToPool() for key = " << pObj->name());
   TRANS* obj = nullptr;
   PERS* persObj = nullptr;
   bool success = SG::fromStorable(pObj, obj);
   if (!success || obj == nullptr) {
      ATH_MSG_ERROR("Failed to cast DataObject to transient type");
      return(StatusCode::FAILURE);
   }
   try {
     std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
     persObj = createPersistentWithKey(obj, pObj->name());
   }
   catch (const std::exception& ex) {
    AthenaPoolCnvSvc::throwExcCaughtException (__PRETTY_FUNCTION__,
                                               "creating persistent object",
                                               ex,
                                               typeid(TRANS),
                                               pObj->name());
   }
   std::unique_ptr<Token> token;
   StatusCode status = this->objectToPool(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 " << pObj->name());
      return(StatusCode::FAILURE);
   }
   std::size_t cpos = pAddr->par()->find(':');
   std::size_t bpos = pAddr->par()->find('[');
   if (cpos == std::string::npos) {
      cpos = 0;
   } else {
      cpos++;
   }
   if (bpos != std::string::npos) bpos = bpos - cpos;
   keepPoolObj(persObj, pAddr->par()->substr(cpos, bpos));
   // 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_AthenaPoolCustomCnvWithKey<TRANS, PERS>::PoolToDataObject(DataObject*& pObj,
                                                            const Token* token,
                                                            const std::string& key)
{
   std::lock_guard<AthenaPoolConverter::CallMutex> lock(this->m_conv_mut);
   TRANS* transObj = nullptr;
   AthenaConverterTLPExtension *extCnv = dynamic_cast<AthenaConverterTLPExtension*>(this);
   // reset the TP converter used for reading, so old value is not used
   if (extCnv != nullptr) {
      extCnv->resetTPCnvForReading();
   }
   try {
      transObj = createTransientWithKey(token, key);
   }
   catch(const std::exception& ex) {
    AthenaPoolCnvSvc::throwExcCaughtException (__PRETTY_FUNCTION__,
                                               "creating transient object",
                                               ex,
                                               typeid(TRANS),
                                               key);
   }
   if (extCnv != nullptr) {
      extCnv->deletePersistentObjects();
   }
   pObj = SG::asStorable(transObj);
   return(StatusCode::SUCCESS);
}
 
// Read object of type P.  This is an exception-throwing version of poolToObject()
// plus reading of all extending objects
template <class TRANS, class PERS>
template <class P>
inline P* T_AthenaPoolCustomCnvWithKey<TRANS, PERS>::poolReadObject(const Token* token) {
   P* persObj = nullptr;
   if (this->poolToObject(token, persObj).isFailure()) {
      std::string error("POOL read failed. Token = ");
      throw std::runtime_error(error + (token != nullptr ? token->toString() : ""));
   }
   AthenaConverterTLPExtension *extCnv = dynamic_cast<AthenaConverterTLPExtension*>(this);
   if (extCnv != nullptr) {
      extCnv->readExtendingObjects(persObj);
   }
   return(persObj);
}
 
// Read object of type P (plus all extending objects)
// using the indicated top-level TP converter
template <class TRANS, class PERS>
template <class P>
inline void T_AthenaPoolCustomCnvWithKey<TRANS, PERS>::poolReadObject(TopLevelTPCnvBase& tlp_converter, const Token* token) {
   AthenaPoolCnvTPExtension *extCnv = dynamic_cast<AthenaPoolCnvTPExtension*>(this);
   // set which Top level TP concerter will by used for reading
   // only matters for extended converters
   if (extCnv != nullptr) {
      extCnv->usingTPCnvForReading(tlp_converter);
   }
   // read the object
   P* persObj = poolReadObject<P>(token);
   // remember the object we just read
   tlp_converter.setTLPersObject(persObj);
   // not returning the object - the TLP converter owns it now
   // and it will delete it automatically in createTransient()!
}
 
// Remember the POOL object until commit (then delete it)
template <class TRANS, class PERS>
inline void T_AthenaPoolCustomCnvWithKey<TRANS, PERS>::keepPoolObj(PERS* obj, const std::string& output) {
   std::lock_guard   lock(m_pListMutex);
   (*m_persObjLists)[output].emplace_back(obj);
}
 
// callback from the CleanupSvc to delete persistent objects after commit
template <class TRANS, class PERS>
StatusCode T_AthenaPoolCustomCnvWithKey<TRANS, PERS>::cleanUp(const std::string& output) {
   std::lock_guard   lock(m_pListMutex);
   (*m_persObjLists)[output].clear();
   return(StatusCode::SUCCESS);
}
 
 
template <class TRANS, class PERS>
PERS* T_AthenaPoolCustomCnv<TRANS, PERS>::createPersistentWithKey
  (TRANS* obj, const std::string& /*key*/)
{
  return createPersistent(obj);
}
 
 
template <class TRANS, class PERS>
TRANS* T_AthenaPoolCustomCnv<TRANS, PERS>::createTransientWithKey
  (const Token* token, const std::string& /*key*/)
{
  return createTransient(token);
}