PoolCollectionConverter Class Reference

This class provides an interface to POOL collections. More...

#include <PoolCollectionConverter.h>

Collaboration diagram for PoolCollectionConverter:

Public Member Functions
	PoolCollectionConverter (const std::string &collectionType, const std::string &inputCollection, unsigned int contextId, const IPoolSvc *svc)
	Constructor.
virtual	~PoolCollectionConverter ()
	Destructor.
StatusCode	initialize ()
	Required by all Gaudi Services.
pool::ICollection *	createCollection (const std::string &connection, const std::string &collectionName, const pool::DbType &collectionType, unsigned int contextId) const
StatusCode	disconnectDb ()
	Disconnect Database.
StatusCode	isValid () const
	Check whether has valid pool::ICollection*.
std::unique_ptr< pool::ICollectionCursor >	selectAll ()

Private Member Functions
	PoolCollectionConverter (const PoolCollectionConverter &rhs)
PoolCollectionConverter &	operator= (const PoolCollectionConverter &rhs)

Private Attributes
std::string	m_collectionType
std::string	m_inputCollection
unsigned int	m_contextId
const IPoolSvc *	m_poolSvc
pool::ICollection *	m_poolCollection

Detailed Description

This class provides an interface to POOL collections.

Definition at line 28 of file PoolCollectionConverter.h.

Constructor & Destructor Documentation

PoolCollectionConverter() [1/2]

PoolCollectionConverter::PoolCollectionConverter	(	const std::string &	collectionType,
		const std::string &	inputCollection,
		unsigned int	contextId,
		const IPoolSvc *	svc )

Constructor.

Parameters

collectionType	[IN] type of the collection ("RootCollection", or "ImplicitCollection").
svc	[IN] pointer to the PoolSvc.
contextId	[IN] id for PoolSvc persistency service to use for input.

Definition at line 30 of file PoolCollectionConverter.cxx.

                         :
    m_collectionType(collectionType),
    m_inputCollection(inputCollection),
    m_contextId(contextId),
    m_poolSvc(svc),
    m_poolCollection(nullptr) {
}

~PoolCollectionConverter()

PoolCollectionConverter::~PoolCollectionConverter ( )

virtual

Destructor.

Definition at line 41 of file PoolCollectionConverter.cxx.

                                                  {
   if (m_poolCollection) {
      m_poolCollection->close();
      delete m_poolCollection; m_poolCollection = nullptr;
   }
}

PoolCollectionConverter() [2/2]

PoolCollectionConverter::PoolCollectionConverter ( const PoolCollectionConverter & rhs )

private

Member Function Documentation

createCollection()

pool::ICollection * PoolCollectionConverter::createCollection	(	const std::string &	connection,
		const std::string &	collectionName,
		const pool::DbType &	collectionType,
		unsigned int	contextId ) const

Returns

a pointer to a Pool Collection.

Parameters

collectionType	[IN] string containing the collection type.
connection	[IN] string containing the connection.
collectionName	[IN] string containing the persistent name of the collection.
contextId	[IN] id for PoolSvc persistency service to use for input.

Definition at line 81 of file PoolCollectionConverter.cxx.

                                              {
   // access to these variables is serial, since this is called by event selector only
   pool::CollectionService collSvc ATLAS_THREAD_SAFE = pool::CollectionService();
   pool::ICollection* collPtr ATLAS_THREAD_SAFE = nullptr;
 
   // Try to open EventTags Collection in the input file
   try {
      collPtr = collSvc.open(collectionName, collectionType, connection, m_poolSvc->getInputContextSession(contextId));
   } catch (std::exception &e) {
      collPtr = nullptr;
   }
   return(collPtr);
}

disconnectDb()

StatusCode PoolCollectionConverter::disconnectDb

(

)

Disconnect Database.

Definition at line 98 of file PoolCollectionConverter.cxx.

                                                 {
   if (m_poolCollection == nullptr) {
      return StatusCode::SUCCESS;
   }
   return m_poolSvc->disconnectDb(m_inputCollection);
}

initialize()

StatusCode PoolCollectionConverter::initialize

(

)

Required by all Gaudi Services.

Definition at line 48 of file PoolCollectionConverter.cxx.

                                               {
   // Check if already prefixed
   if (!m_inputCollection.starts_with( "PFN:")
           && !m_inputCollection.starts_with( "LFN:")
           && !m_inputCollection.starts_with( "FID:")) {
      // Prefix with PFN:
      m_inputCollection = std::format("PFN:{}", m_inputCollection);
   }
   StatusCode sc = StatusCode::SUCCESS;
   try {
      if (m_collectionType == "RootCollection") {
         sc = m_poolSvc->connectCollection(m_inputCollection, "Input", pool::ROOT_StorageType.type(), m_contextId);
         m_poolCollection = createCollection(m_inputCollection, "Input", pool::ROOT_StorageType.type(), m_contextId);
      }
      if (m_poolCollection == nullptr) { // Open as ImplicitCollection if technologies fail, or none was specified
         sc = m_poolSvc->connectCollection(m_inputCollection, "Input", pool::POOL_StorageType.type(), m_contextId);
         m_poolCollection = createCollection(m_inputCollection, "Input", pool::POOL_StorageType.type(), m_contextId);
      }
   } catch (std::exception &e) {
      if (m_poolCollection == nullptr) return StatusCode::RECOVERABLE;
   }
   bool insertFile = false;
   if (sc.isRecoverable()) {
      insertFile = true;
   } else if (sc.isFailure()) {
      return StatusCode::FAILURE;
   }
   if (m_poolCollection == nullptr || insertFile) {
      return m_poolSvc->checkCollection(m_inputCollection, m_contextId, m_poolCollection == nullptr);
   }
   return StatusCode::SUCCESS;
}

isValid()

StatusCode PoolCollectionConverter::isValid

(

)

const

Check whether has valid pool::ICollection*.

Definition at line 105 of file PoolCollectionConverter.cxx.

                                                  {
   return m_poolCollection != nullptr ? StatusCode::SUCCESS : StatusCode::FAILURE;
}

operator=()

PoolCollectionConverter & PoolCollectionConverter::operator= ( const PoolCollectionConverter & rhs )

private

selectAll()

std::unique_ptr< pool::ICollectionCursor > PoolCollectionConverter::selectAll

(

)

Returns

ICollectionCursor over all entries

Definition at line 109 of file PoolCollectionConverter.cxx.

                                                                        {
   if (m_poolCollection == nullptr)[[unlikely]] {
     throw std::runtime_error("PoolCollectionConverter::selectAll: m_poolCollection is nullptr.");
   }
   return m_poolCollection->cursor();
}

Member Data Documentation

m_collectionType

std::string PoolCollectionConverter::m_collectionType

private

Definition at line 67 of file PoolCollectionConverter.h.

m_contextId

unsigned int PoolCollectionConverter::m_contextId

private

Definition at line 69 of file PoolCollectionConverter.h.

m_inputCollection

std::string PoolCollectionConverter::m_inputCollection

private

Definition at line 68 of file PoolCollectionConverter.h.

m_poolCollection

pool::ICollection* PoolCollectionConverter::m_poolCollection

private

Definition at line 71 of file PoolCollectionConverter.h.

m_poolSvc

const IPoolSvc* PoolCollectionConverter::m_poolSvc

private

Definition at line 70 of file PoolCollectionConverter.h.

---

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

• PoolCollectionConverter.h
• PoolCollectionConverter.cxx