CondProxyProvider Class Reference

This class is the AddressProvider for conditions data. More...

#include <CondProxyProvider.h>

Inheritance diagram for CondProxyProvider:

Collaboration diagram for CondProxyProvider:

Public Member Functions
	CondProxyProvider (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor. More...
virtual	~CondProxyProvider ()
	Destructor. More...
virtual StatusCode	initialize () override
	Required of all Gaudi Services. More...
virtual StatusCode	finalize () override
	Required of all Gaudi Services. More...
virtual StatusCode	preLoadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
	Get all addresses from provider. More...
virtual StatusCode	loadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
	Implementation of the loadAddresses function without any functionality. More...
virtual StatusCode	updateAddress (StoreID::type storeID, SG::TransientAddress *tad, const EventContext &ctx) override
	Update a transient address. More...

Private Member Functions
PoolCollectionConverter *	getCollectionCnv ()
	Return pointer to new PoolCollectionConverter. More...

Private Attributes
ServiceHandle< IAthenaPoolCnvSvc >	m_athenaPoolCnvSvc
PoolCollectionConverter *m_poolCollectionConverter	ATLAS_THREAD_SAFE
unsigned int	m_contextId
StringArrayProperty	m_inputCollectionsProp { this, "InputCollections", {}, "Files to read", "OrderedSet<std::string>" }
	InputCollections, vector with names of the input collections. More...
std::vector< std::string >::const_iterator m_inputCollectionsIterator	ATLAS_THREAD_SAFE

Detailed Description

This class is the AddressProvider for conditions data.

Definition at line 30 of file CondProxyProvider.h.

Constructor & Destructor Documentation

CondProxyProvider()

CondProxyProvider::CondProxyProvider	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard Service Constructor.

Definition at line 32 of file CondProxyProvider.cxx.

                                                                                    :
    base_class(name, pSvcLocator),
    m_athenaPoolCnvSvc("AthenaPoolCnvSvc", name),
    m_poolCollectionConverter(0),
    m_contextId(IPoolSvc::kInputStream)
    {
}

~CondProxyProvider()

CondProxyProvider::~CondProxyProvider ( )

virtual

Destructor.

Definition at line 40 of file CondProxyProvider.cxx.

                                      {
}

Member Function Documentation

finalize()

StatusCode CondProxyProvider::finalize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 70 of file CondProxyProvider.cxx.

                                       {
   if (m_poolCollectionConverter != 0) {
      m_poolCollectionConverter->disconnectDb().ignore();
      delete m_poolCollectionConverter; m_poolCollectionConverter = 0;
   }
   // Release AthenaPoolCnvSvc
   if (!m_athenaPoolCnvSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release AthenaPoolCnvSvc.");
   }
   return(StatusCode::SUCCESS);
}

getCollectionCnv()

PoolCollectionConverter * CondProxyProvider::getCollectionCnv ( )

private

Return pointer to new PoolCollectionConverter.

Definition at line 161 of file CondProxyProvider.cxx.

                                                             {
   ATH_MSG_DEBUG("Try item: \"" << *m_inputCollectionsIterator << "\" from the collection list.");
   PoolCollectionConverter* pCollCnv = new PoolCollectionConverter(std::string("ImplicitROOT:") + APRDefaults::TTreeNames::DataHeader,
       *m_inputCollectionsIterator,
       m_contextId,
       m_athenaPoolCnvSvc->getPoolSvc());
   if (!pCollCnv->initialize().isSuccess()) {
      // Close previous collection.
      delete pCollCnv; pCollCnv = 0;
      ATH_MSG_ERROR("Unable to open: " << *m_inputCollectionsIterator);
   }
   return(pCollCnv);
}

initialize()

StatusCode CondProxyProvider::initialize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 43 of file CondProxyProvider.cxx.

                                         {
   ATH_MSG_INFO("Initializing " << name());
   // Check for input collection
   if (m_inputCollectionsProp.value().size() == 0) {
      return(StatusCode::FAILURE);
   }
   // Retrieve AthenaPoolCnvSvc
   ATH_CHECK( m_athenaPoolCnvSvc.retrieve() );
 
   // Get PoolSvc and connect as "Conditions"
   IPoolSvc *poolSvc = m_athenaPoolCnvSvc->getPoolSvc();
   m_contextId = poolSvc->getInputContext("Conditions");
   ATH_CHECK( poolSvc->connect(pool::ITransaction::READ, m_contextId) );
 
   for( const auto &inp : m_inputCollectionsProp.value() ) {
      ATH_MSG_INFO("Inputs: " << inp);
   }
   // Initialize
   m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
   // Create an m_poolCollectionConverter to read the objects in
   m_poolCollectionConverter = getCollectionCnv();
   if (m_poolCollectionConverter == 0) {
      return(StatusCode::FAILURE);
   }
   return(StatusCode::SUCCESS);
}

loadAddresses()

StatusCode CondProxyProvider::loadAddresses ( StoreID::type  storeID, IAddressProvider::tadList &  tads  )

overridevirtual

Implementation of the loadAddresses function without any functionality.

Definition at line 150 of file CondProxyProvider.cxx.

                                {
   return(StatusCode::SUCCESS);
}

preLoadAddresses()

StatusCode CondProxyProvider::preLoadAddresses ( StoreID::type  storeID, IAddressProvider::tadList &  tads  )

overridevirtual

Get all addresses from provider.

Called before begin event.

Parameters

storeID	[IN] store ID, this function only preloads detector store addresses.
tads	[OUT] list of the transient addresses which were preloaded.

Definition at line 82 of file CondProxyProvider.cxx.

                                       {
   if (storeID != StoreID::DETECTOR_STORE) {
      return(StatusCode::SUCCESS);
   }
   ServiceHandle<StoreGateSvc> detectorStoreSvc("DetectorStore", name());
   // Retrieve DetectorStoreSvc
   ATH_CHECK( detectorStoreSvc.retrieve() );
 
   if (m_poolCollectionConverter == nullptr) {
     return StatusCode::FAILURE;
   }
   
   // Create DataHeader iterators
   pool::ICollectionCursor* headerIterator = &m_poolCollectionConverter->selectAll();
   for (int verNumber = 0; verNumber < 100; verNumber++) {
      if (!headerIterator->next()) {
         m_poolCollectionConverter->disconnectDb().ignore();
         delete m_poolCollectionConverter; m_poolCollectionConverter = 0;
         ++m_inputCollectionsIterator;
         if (m_inputCollectionsIterator != m_inputCollectionsProp.value().end()) {
            // Create PoolCollectionConverter for input file
            m_poolCollectionConverter = getCollectionCnv();
            if (m_poolCollectionConverter == 0) {
               return(StatusCode::FAILURE);
            }
            // Get DataHeader iterator
            headerIterator = &m_poolCollectionConverter->selectAll();
            if (!headerIterator->next()) {
               return(StatusCode::FAILURE);
            }
         } else {
            break;
         }
      }
      SG::VersionedKey myVersKey(name(), verNumber);
      auto token = std::make_unique<Token>();
      token->fromString(headerIterator->eventRef().toString());
      TokenAddress* tokenAddr = new TokenAddress(POOL_StorageType, ClassID_traits<DataHeader>::ID(), "", myVersKey, m_contextId, std::move(token));
      if (!detectorStoreSvc->recordAddress(tokenAddr).isSuccess()) {
         ATH_MSG_ERROR("Cannot record DataHeader.");
         return(StatusCode::FAILURE);
      }
   }
   std::list<SG::ObjectWithVersion<DataHeader> > allVersions;
   if (!detectorStoreSvc->retrieveAllVersions(allVersions, name()).isSuccess()) {
      ATH_MSG_DEBUG("Cannot retrieve DataHeader from DetectorStore.");
      return(StatusCode::SUCCESS);
   }
   for (std::list<SG::ObjectWithVersion<DataHeader> >::iterator iter = allVersions.begin();
                   iter != allVersions.end(); ++iter) {
      SG::ReadHandle<DataHeader> dataHeader = iter->dataObject;
      ATH_MSG_DEBUG("The current File contains: " << dataHeader->size() << " objects");
      for (const auto& element : *dataHeader) {
         SG::TransientAddress* tadd = element.getAddress();
         if (tadd->clID() == ClassID_traits<DataHeader>::ID()) {
            delete tadd; tadd = 0;
         } else {
            ATH_MSG_DEBUG("preLoadAddresses: DataObject address, clid = " << tadd->clID() << ", name = " << tadd->name());
            tads.push_back(tadd);
         }
         EventSelectorAthenaPoolUtil::registerKeys(element, &*detectorStoreSvc);
      }
   }
 
   return(StatusCode::SUCCESS);
}

updateAddress()

StatusCode CondProxyProvider::updateAddress ( StoreID::type  storeID, SG::TransientAddress *  tad, const EventContext &  ctx  )

overridevirtual

Update a transient address.

Parameters

storeID	[IN] store ID, this function only preloads detector store addresses.
tad	[IN] transient address to be updated.

Definition at line 155 of file CondProxyProvider.cxx.

                                                                   {
   return(StatusCode::FAILURE);
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

PoolCollectionConverter* m_poolCollectionConverter CondProxyProvider::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 59 of file CondProxyProvider.h.

ATLAS_THREAD_SAFE [2/2]

std::vector<std::string>::const_iterator m_inputCollectionsIterator CondProxyProvider::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 66 of file CondProxyProvider.h.

m_athenaPoolCnvSvc

ServiceHandle<IAthenaPoolCnvSvc> CondProxyProvider::m_athenaPoolCnvSvc

private

Definition at line 57 of file CondProxyProvider.h.

m_contextId

unsigned int CondProxyProvider::m_contextId

private

Definition at line 60 of file CondProxyProvider.h.

m_inputCollectionsProp

StringArrayProperty CondProxyProvider::m_inputCollectionsProp { this, "InputCollections", {}, "Files to read", "OrderedSet<std::string>" }

private

InputCollections, vector with names of the input collections.

Definition at line 64 of file CondProxyProvider.h.

---

The documentation for this class was generated from the following files:

• CondProxyProvider.h
• CondProxyProvider.cxx