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 std::string &query, const IPoolSvc *svc)
	Constructor. More...
virtual	~PoolCollectionConverter ()
	Destructor. More...
StatusCode	initialize ()
	Required by all Gaudi Services. More...
StatusCode	disconnectDb ()
	Disconnect Database. More...
StatusCode	isValid () const
	Check whether has valid pool::ICollection*. More...
pool::ICollectionCursor &	selectAll ()
pool::ICollectionCursor &	executeQuery ()
	Query the collection. More...
std::string	retrieveToken (const pool::ICollectionCursor *cursor, const std::string &refName) const

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

Private Attributes
std::string	m_collectionType
std::string	m_connection
std::string	m_inputCollection
unsigned int	m_contextId
std::string	m_query
const IPoolSvc *	m_poolSvc
pool::ICollection *	m_poolCollection
pool::ICollectionQuery *	m_collectionQuery
std::string	m_inputContainer

Detailed Description

This class provides an interface to POOL collections.

Definition at line 27 of file PoolCollectionConverter.h.

Constructor & Destructor Documentation

PoolCollectionConverter() [1/2]

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

Constructor.

Parameters

collectionType	[IN] type of the collection ("ExplicitROOT", "ExplicitMySQL", "ExplicitMySQLlt" or "ImplicitROOT").
inputCollection	[IN] name of the collection.
query	[IN] query string.
svc	[IN] pointer to the PoolSvc.
contextId	[IN] id for PoolSvc persistency service to use for input.

Definition at line 31 of file PoolCollectionConverter.cxx.

                         :
    m_collectionType(),
    m_connection(),
    m_inputCollection(inputCollection),
    m_contextId(contextId),
    m_query(query),
    m_poolSvc(svc),
    m_poolCollection(nullptr),
    m_collectionQuery(nullptr),
    m_inputContainer() {
   // Find out if the user specified a container
   std::string::size_type p_colon = collectionType.rfind(':');
   if (p_colon != std::string::npos) {
      m_inputContainer = collectionType.substr(p_colon + 1);
      m_collectionType = collectionType.substr(0, p_colon);
   } else {
      // The user didn't specify any container. Using the default one.
      m_inputContainer = "POOLContainer";
      m_collectionType = collectionType;
   }
   std::string::size_type p_slash = m_inputContainer.find('/');
   if (p_slash != std::string::npos) {
      m_inputContainer.resize(p_slash);
   }
}

~PoolCollectionConverter()

PoolCollectionConverter::~PoolCollectionConverter ( )

virtual

Destructor.

Definition at line 61 of file PoolCollectionConverter.cxx.

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

PoolCollectionConverter() [2/2]

PoolCollectionConverter::PoolCollectionConverter ( const PoolCollectionConverter &  rhs )

private

Member Function Documentation

disconnectDb()

StatusCode PoolCollectionConverter::disconnectDb

(

)

Disconnect Database.

Definition at line 113 of file PoolCollectionConverter.cxx.

                                                 {
   if (m_poolCollection == nullptr) {
      return(StatusCode::SUCCESS);
   }
   if (m_poolCollection->description().type() == "ImplicitCollection") {
      return(m_poolSvc->disconnectDb(m_connection));
   }
   return(StatusCode::SUCCESS);
}

executeQuery()

pool::ICollectionCursor & PoolCollectionConverter::executeQuery

(

)

Query the collection.

Returns

ICollectionCursor over the results of the query

Definition at line 135 of file PoolCollectionConverter.cxx.

                                                             {
   assert(m_poolCollection);
   delete m_collectionQuery; m_collectionQuery = nullptr;
   m_collectionQuery = m_poolCollection->newQuery();
   m_collectionQuery->selectAll();
   m_collectionQuery->setCondition(m_query);
   m_collectionQuery->setRowCacheSize(100);   //MN: FIXME - just an arbitrary number
   return(m_collectionQuery->execute());
}

initialize()

StatusCode PoolCollectionConverter::initialize

(

)

Required by all Gaudi Services.

Definition at line 69 of file PoolCollectionConverter.cxx.

                                               {
   std::string collectionTypeString;
   if (m_collectionType == "ExplicitROOT") {
      collectionTypeString = "RootCollection";
   } else if (m_collectionType == "ImplicitROOT") {
      collectionTypeString = "ImplicitCollection";
   } else {
      return(StatusCode::FAILURE);
   }
   if (collectionTypeString == "ImplicitCollection") {
      // Check if already prefixed
      if (m_inputCollection.starts_with( "PFN:")
          || m_inputCollection.starts_with( "LFN:")
          || m_inputCollection.starts_with( "FID:")) {
         // Aready prefixed
         m_connection = m_inputCollection;
      } else {
         // Prefix with PFN:
         m_connection = "PFN:" + m_inputCollection;
      }
      try {
         m_poolCollection = m_poolSvc->createCollection("RootCollection", m_connection, m_inputCollection, m_contextId);
      } catch (std::exception &e) {
         m_poolCollection = nullptr;
      }
      if (m_poolCollection == nullptr) {
         // Now set where to look in the implicit file
         m_inputCollection = m_inputContainer + "(DataHeader)";
      }
   }
   try {
      if (m_poolCollection == nullptr) {
         m_poolCollection = m_poolSvc->createCollection(collectionTypeString, m_connection, m_inputCollection, m_contextId);
      }
      if (m_poolCollection == nullptr && collectionTypeString == "ImplicitCollection") {
         m_inputCollection = m_inputContainer + "_DataHeader";
         m_poolCollection = m_poolSvc->createCollection(collectionTypeString, m_connection, m_inputCollection, m_contextId);
      }
   } catch (std::exception &e) {
      return(StatusCode::RECOVERABLE);
   }
   return(StatusCode::SUCCESS);
}

isValid()

StatusCode PoolCollectionConverter::isValid

(

)

const

Check whether has valid pool::ICollection*.

Definition at line 123 of file PoolCollectionConverter.cxx.

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

operator=()

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

private

retrieveToken()

std::string PoolCollectionConverter::retrieveToken	(	const pool::ICollectionCursor *	cursor,
		const std::string &	refName
	)		const

Parameters

it	[IN] collection iterator.
refName	[IN] attribute name.

Definition at line 145 of file PoolCollectionConverter.cxx.

                                        {
// Retrieve the DataHeader Token from POOL.
// If header name is non-zero, then search the attibute list for
// the corresponding ref. Otherwise, use the main token
   std::string tokenStr;
   if (!refName.empty()) {
      std::string attrName = refName + "_ref";
      try {
     tokenStr = cursor->currentRow().tokenList()[attrName].toString();
      } catch (...) {
     // check also in attributes, for backward compatibility
     try {
            tokenStr = cursor->currentRow().attributeList()[attrName].data<std::string>();
     } catch (std::exception& e) {
        return("");
     }
      }
   } else {
      tokenStr = cursor->eventRef().toString();
   }
   return(tokenStr);
}

selectAll()

pool::ICollectionCursor & PoolCollectionConverter::selectAll

(

)

Returns

ICollectionCursor over all entries

Definition at line 127 of file PoolCollectionConverter.cxx.

                                                          {
   assert(m_poolCollection);
   delete m_collectionQuery; m_collectionQuery = nullptr;
   m_collectionQuery = m_poolCollection->newQuery();
   m_collectionQuery->setRowCacheSize(100);   //MN: FIXME - just an arbitrary number
   return(m_collectionQuery->execute());
}

Member Data Documentation

m_collectionQuery

pool::ICollectionQuery* PoolCollectionConverter::m_collectionQuery

private

Definition at line 74 of file PoolCollectionConverter.h.

m_collectionType

std::string PoolCollectionConverter::m_collectionType

private

Definition at line 67 of file PoolCollectionConverter.h.

m_connection

std::string PoolCollectionConverter::m_connection

private

Definition at line 68 of file PoolCollectionConverter.h.

m_contextId

unsigned int PoolCollectionConverter::m_contextId

private

Definition at line 70 of file PoolCollectionConverter.h.

m_inputCollection

std::string PoolCollectionConverter::m_inputCollection

private

Definition at line 69 of file PoolCollectionConverter.h.

m_inputContainer

std::string PoolCollectionConverter::m_inputContainer

private

Definition at line 75 of file PoolCollectionConverter.h.

m_poolCollection

pool::ICollection* PoolCollectionConverter::m_poolCollection

private

Definition at line 73 of file PoolCollectionConverter.h.

m_poolSvc

const IPoolSvc* PoolCollectionConverter::m_poolSvc

private

Definition at line 72 of file PoolCollectionConverter.h.

m_query

std::string PoolCollectionConverter::m_query

private

Definition at line 71 of file PoolCollectionConverter.h.

---

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

• PoolCollectionConverter.h
• PoolCollectionConverter.cxx