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	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
std::unique_ptr< PoolCollectionConverter >	getCollectionCnv ()
	Return pointer to new PoolCollectionConverter. More...

Private Attributes
ServiceHandle< IAthenaPoolCnvSvc >	m_athenaPoolCnvSvc {this, "ConversionService", "AthenaPoolCnvSvc"}
unsigned int	m_contextId
Gaudi::Property< std::vector< std::string > >	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 {}

Detailed Description

This class is the AddressProvider for conditions data.

Definition at line 31 of file CondProxyProvider.h.

Constructor & Destructor Documentation

CondProxyProvider()

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

Standard Service Constructor.

Definition at line 33 of file CondProxyProvider.cxx.

                                                                                    :
    base_class(name, pSvcLocator),
    m_contextId(IPoolSvc::kInputStream)
    {
}

~CondProxyProvider()

CondProxyProvider::~CondProxyProvider ( )

virtual

Destructor.

Definition at line 39 of file CondProxyProvider.cxx.

                                      {
}

Member Function Documentation

getCollectionCnv()

std::unique_ptr< PoolCollectionConverter > CondProxyProvider::getCollectionCnv ( )

private

Return pointer to new PoolCollectionConverter.

Definition at line 144 of file CondProxyProvider.cxx.

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

initialize()

StatusCode CondProxyProvider::initialize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 42 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();
   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 133 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 64 of file CondProxyProvider.cxx.

                                       {
   if (storeID != StoreID::DETECTOR_STORE) {
      return StatusCode::SUCCESS;
   }
   ServiceHandle<StoreGateSvc> detectorStoreSvc("DetectorStore", name());
   // Retrieve DetectorStoreSvc
   ATH_CHECK( detectorStoreSvc.retrieve() );
 
   // Create an poolCollectionConverter to read the objects in
   std::unique_ptr<PoolCollectionConverter> poolCollectionConverter = getCollectionCnv();
   if (!poolCollectionConverter) {
     return StatusCode::FAILURE;
   }
   // Create DataHeader iterators
   pool::ICollectionCursor* headerIterator = &poolCollectionConverter->selectAll();
 
   for (int verNumber = 0; verNumber < 100; verNumber++) {
      if (!headerIterator->next()) {
         poolCollectionConverter->disconnectDb().ignore();
         poolCollectionConverter.reset();
         ++m_inputCollectionsIterator;
         if (m_inputCollectionsIterator != m_inputCollectionsProp.value().end()) {
            // Create PoolCollectionConverter for input file
            poolCollectionConverter = getCollectionCnv();
            if (!poolCollectionConverter) {
               return StatusCode::FAILURE;
            }
            // Get DataHeader iterator
            headerIterator = &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());
      CxxUtils::RefCountedPtr<TokenAddress> tokenAddr
        (new TokenAddress(pool::POOL_StorageType.type(), ClassID_traits<DataHeader>::ID(), "", myVersKey, m_contextId, std::move(token)));
      if (!detectorStoreSvc->recordAddress(std::move(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 (const auto& version : allVersions) {
      SG::ReadHandle<DataHeader> dataHeader = version.dataObject;
      ATH_MSG_DEBUG("The current File contains: " << dataHeader->size() << " objects");
      for (const auto& element : *dataHeader) {
         SG::TransientAddress* tadd = element.getAddress(pool::POOL_StorageType.type());
         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 138 of file CondProxyProvider.cxx.

                                                                   {
   return StatusCode::FAILURE;
}

Member Data Documentation

m_athenaPoolCnvSvc

ServiceHandle<IAthenaPoolCnvSvc> CondProxyProvider::m_athenaPoolCnvSvc {this, "ConversionService", "AthenaPoolCnvSvc"}

private

Definition at line 56 of file CondProxyProvider.h.

m_contextId

unsigned int CondProxyProvider::m_contextId

private

Definition at line 57 of file CondProxyProvider.h.

m_inputCollectionsIterator

std::vector<std::string>::const_iterator CondProxyProvider::m_inputCollectionsIterator {}

private

Definition at line 63 of file CondProxyProvider.h.

m_inputCollectionsProp

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

private

InputCollections, vector with names of the input collections.

Definition at line 61 of file CondProxyProvider.h.

---

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

• CondProxyProvider.h
• CondProxyProvider.cxx