ATLAS Offline Software
Loading...
Searching...
No Matches
SessionTool Class Reference

#include <SessionTool.h>

Inheritance diagram for SessionTool:
Collaboration diagram for SessionTool:

Public Member Functions

 SessionTool (const std::string &type, const std::string &name, const IInterface *parent)
 Constructors.
virtual ~SessionTool ()
 Destructor.
 SessionTool (const SessionTool &)=delete
SessionTool & operator= (const SessionTool &)=delete
virtual void setupFC (Gaudi::IFileCatalog &fileCatalog, int ageLimit=-1)
virtual void * readObject (const Token &token, void *object=0)
 Retrieves an object from persistent store and return with type information The handle to the reflection class is necessary to later delete the object.
virtual Token * registerForWrite (const Placement &place, const void *object, const RootType &type)
 registerForWrite registers an object for writing to the persistent medium higher level interactions with the framework are necessary.
void registerDatabaseHandler (DatabaseHandler *dbHandler, const std::string &lfn="")
 Registers a database.
void deregisterDatabaseHandler (DatabaseHandler *dbHandler)
 Deregisters a database.
DatabaseHandler * lookupByFID (const std::string &fid)
 Looks up a database by its file id.
DatabaseHandler * lookupByPFN (const std::string &pfn)
 Looks up a database by its physical file name.
DatabaseHandler * lookupByLFN (const std::string &lfn)
 Looks up a database by its logical file name.
virtual bool disconnectAll ()
 Explicitly disconnects all the databases.
virtual bool startTransaction (Io::IoFlag type=Io::READ)
 Starts a new transaction. Returns the success of the operation.
virtual bool commit ()
 Commits the transaction.
virtual bool commitAndHold ()
 Commits and holds the transaction.
virtual Io::IoFlag openMode () const
 Returns the transaction type.
virtual std::unique_ptr< Database > databaseHandle (const std::string &dbName, Database::Specification::NameType dbNameType)
 Creates and returns a new database handle object.
virtual Gaudi::IFileCatalog & fileCatalog ()
 Returns the file catalog in use.
DatabaseHandler * connect (long technology, Io::IoFlag transType, const std::string &fid, const std::string &pfn)
 Connects to a database.
void disconnect (DatabaseHandler *database)
 Disconnects from a database.
std::string fidForPfn (long technology, const std::string &pfn)
 Fetches the FID by trying to temporatily connect to a database.
bool attributeOfType (long technology, const std::string &attributeName, void *data, const std::type_info &typeInfo, const std::string &option)
bool setAttributeOfType (long technology, const std::string &attributeName, const void *data, const std::type_info &typeInfo, const std::string &option)
void closeSession ()
StatusCode finalize () override final
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

MicroSessionManager & microSessionManager (long technology)
 Returns the technology given a technology type.
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

Gaudi::IFileCatalog * m_catalog
int m_ageLimit
Io::IoFlag m_transactionType
std::map< long, std::unique_ptr< MicroSessionManager > > m_technologies
std::set< DatabaseHandler * > m_databases
std::map< std::string, DatabaseHandler * > m_fidToDb
std::map< std::string, DatabaseHandler * > m_pfnToDb
std::map< std::string, DatabaseHandler * > m_lfnToDb
std::map< std::string, std::set< std::string > > m_fidToLfns
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 27 of file SessionTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ SessionTool() [1/2]

SessionTool::SessionTool ( const std::string & type,
const std::string & name,
const IInterface * parent )
explicit

Constructors.

Definition at line 16 of file SessionTool.cxx.

19 : AthAlgTool(type, name, parent),
20 m_catalog(nullptr),
21 m_ageLimit(-1),
22 m_transactionType(Io::INVALID) {
23}
AthAlgTool()
Default constructor:
Gaudi::IFileCatalog * m_catalog
Io::IoFlag m_transactionType

◆ ~SessionTool()

SessionTool::~SessionTool ( )
virtual

Destructor.

Definition at line 30 of file SessionTool.cxx.

30 {
32}
void closeSession()

◆ SessionTool() [2/2]

SessionTool::SessionTool ( const SessionTool & )
delete

Member Function Documentation

◆ attributeOfType()

bool SessionTool::attributeOfType ( long technology,
const std::string & attributeName,
void * data,
const std::type_info & typeInfo,
const std::string & option )

Definition at line 205 of file SessionTool.cxx.

209 {
210 return this->microSessionManager(technology).attributeOfType(attributeName, data, typeInfo, option);
211}
bool attributeOfType(const std::string &attributeName, void *data, const std::type_info &typeInfo, const std::string &option)
MicroSessionManager & microSessionManager(long technology)
Returns the technology given a technology type.

◆ closeSession()

void SessionTool::closeSession ( )

Definition at line 34 of file SessionTool.cxx.

34 {
35 // order is important
37 m_transactionType = Io::INVALID;
38 m_technologies.clear();
39}
std::map< long, std::unique_ptr< MicroSessionManager > > m_technologies
virtual bool disconnectAll()
Explicitly disconnects all the databases.

◆ commit()

bool SessionTool::commit ( )
virtual

Commits the transaction.

Definition at line 132 of file SessionTool.cxx.

132 {
133 if( m_transactionType != Io::INVALID ) {
134 bool OK = true;
135 for( auto db : m_databases ) {
136 bool bCommit = db->commitTransaction(); // This has to be replaced with a two phase commit
137 if ( ! bCommit ) {
138 ATH_MSG_ERROR("Could not commit the transaction for the database with:" << endmsg
139 << "FID = " << db->fid() << endmsg << "PFN = " << db->pfn() );
140 }
141 OK = OK && bCommit;
142 }
143 m_transactionType = Io::INVALID;
144 return OK;
145 }
146 return false;
147}
#define endmsg
#define ATH_MSG_ERROR(x,...)
std::set< DatabaseHandler * > m_databases

◆ commitAndHold()

bool SessionTool::commitAndHold ( )
virtual

Commits and holds the transaction.

Definition at line 149 of file SessionTool.cxx.

149 {
150 if( m_transactionType != Io::INVALID ) {
151 bool OK = true;
152 for( auto db : m_databases ) {
153 bool bCommit = db->commitAndHoldTransaction(); // This has to be replaced with a two phase commit
154 if ( ! bCommit ) {
155 ATH_MSG_ERROR("Could not commit and hold the transaction for the database with:" << endmsg
156 << "FID = " << db->fid() << endmsg << "PFN = " << db->pfn() );
157 }
158 OK = OK && bCommit;
159 }
160 return OK;
161 }
162 return false;
163}

◆ connect()

DatabaseHandler * SessionTool::connect ( long technology,
Io::IoFlag transType,
const std::string & fid,
const std::string & pfn )

Connects to a database.

Definition at line 190 of file SessionTool.cxx.

193 {
194 return this->microSessionManager(technology).connect(mode, fid, pfn);
195}
DatabaseHandler * connect(Io::IoFlag transType, const std::string &fid, const std::string &pfn)
Connects to a database.

◆ databaseHandle()

std::unique_ptr< Database > SessionTool::databaseHandle ( const std::string & dbName,
Database::Specification::NameType dbNameType )
virtual

Creates and returns a new database handle object.

Definition at line 165 of file SessionTool.cxx.

166 {
167 if( m_transactionType != Io::INVALID ) {
168 return std::make_unique<Database>( *this, dbName, dbNameType );
169 }
170 return nullptr;
171}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ deregisterDatabaseHandler()

void SessionTool::deregisterDatabaseHandler ( DatabaseHandler * dbHandler)

Deregisters a database.

Definition at line 87 of file SessionTool.cxx.

87 {
88 std::set< DatabaseHandler* >::iterator idb = m_databases.find( dbHandler );
89 if ( idb != m_databases.end() ) {
90 m_fidToDb.erase( (*idb)->fid() );
91 m_pfnToDb.erase( (*idb)->pfn() );
92 std::map< std::string, std::set< std::string > >::iterator iLfnSet = m_fidToLfns.find( (*idb)->fid() );
93 if ( iLfnSet != m_fidToLfns.end() ) {
94 for ( std::set< std::string >::iterator iLfn = iLfnSet->second.begin(); iLfn != iLfnSet->second.end(); ++iLfn ) {
95 m_lfnToDb.erase( *iLfn );
96 }
97 m_fidToLfns.erase( iLfnSet );
98 }
99 m_databases.erase( idb );
100 }
101}
std::map< std::string, DatabaseHandler * > m_pfnToDb
std::map< std::string, DatabaseHandler * > m_fidToDb
std::map< std::string, DatabaseHandler * > m_lfnToDb
std::map< std::string, std::set< std::string > > m_fidToLfns

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

◆ disconnect()

void SessionTool::disconnect ( DatabaseHandler * database)

Disconnects from a database.

Definition at line 197 of file SessionTool.cxx.

197 {
198 return this->microSessionManager(database->technology()).disconnect(database);
199}
void disconnect(DatabaseHandler *database)
Disconnects from a database.

◆ disconnectAll()

bool SessionTool::disconnectAll ( )
virtual

Explicitly disconnects all the databases.

If a transaction is active, then all the changes since the last commit are aborted.

Definition at line 118 of file SessionTool.cxx.

118 {
119 bool ret = true;
120 for( auto& iManager : m_technologies ) {
121 if( !iManager.second->disconnectAll() ) ret = false;
122 }
123 return ret;
124}

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fidForPfn()

std::string SessionTool::fidForPfn ( long technology,
const std::string & pfn )

Fetches the FID by trying to temporatily connect to a database.

Definition at line 201 of file SessionTool.cxx.

201 {
202 return this->microSessionManager(technology).fidForPfn(pfn);
203}
std::string fidForPfn(const std::string &pfn)
Fetches the FID by trying to temporatily connect to a database.

◆ fileCatalog()

Gaudi::IFileCatalog & SessionTool::fileCatalog ( )
virtual

Returns the file catalog in use.

Definition at line 173 of file SessionTool.cxx.

173 {
174 return *m_catalog;
175}

◆ finalize()

StatusCode SessionTool::finalize ( )
finaloverride

Definition at line 41 of file SessionTool.cxx.

41 {
43 return AthAlgTool::finalize();
44}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ lookupByFID()

DatabaseHandler * SessionTool::lookupByFID ( const std::string & fid)

Looks up a database by its file id.

Definition at line 103 of file SessionTool.cxx.

103 {
104 std::map< std::string, DatabaseHandler* >::iterator idb = m_fidToDb.find( fid );
105 return idb == m_fidToDb.end() ? 0 : idb->second;
106}

◆ lookupByLFN()

DatabaseHandler * SessionTool::lookupByLFN ( const std::string & lfn)

Looks up a database by its logical file name.

Definition at line 113 of file SessionTool.cxx.

113 {
114 std::map< std::string, DatabaseHandler* >::iterator idb = m_lfnToDb.find( lfn );
115 return idb == m_lfnToDb.end() ? 0 : idb->second;
116}

◆ lookupByPFN()

DatabaseHandler * SessionTool::lookupByPFN ( const std::string & pfn)

Looks up a database by its physical file name.

Definition at line 108 of file SessionTool.cxx.

108 {
109 std::map< std::string, DatabaseHandler* >::iterator idb = m_pfnToDb.find( pfn );
110 return idb == m_pfnToDb.end() ? 0 : idb->second;
111}

◆ microSessionManager()

MicroSessionManager & SessionTool::microSessionManager ( long technology)
private

Returns the technology given a technology type.

Definition at line 177 of file SessionTool.cxx.

177 {
178 DbType dbType( technology );
179 long majorType = dbType.majorType();
180 auto iManager = m_technologies.find( majorType );
181 if ( iManager != m_technologies.end() ) {
182 return *(iManager->second);
183 }
184 // Technology does not exist. Create the new session.
185 auto mgr = new MicroSessionManager( *this, majorType, m_ageLimit );
186 m_technologies.insert( std::make_pair( majorType, mgr ) );
187 return *mgr;
188}

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ openMode()

virtual Io::IoFlag SessionTool::openMode ( ) const
inlinevirtual

Returns the transaction type.

Definition at line 97 of file SessionTool.h.

97{ return m_transactionType; }

◆ operator=()

SessionTool & SessionTool::operator= ( const SessionTool & )
delete

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ readObject()

void * SessionTool::readObject ( const Token & token,
void * object = 0 )
virtual

Retrieves an object from persistent store and return with type information The handle to the reflection class is necessary to later delete the object.

The Guid of the transient class is assumed to be the classID of the token

Parameters
token[IN] reference to the token for the object
object[IN] pointer to memory for the object (created if 0)
Returns
void* The data.

In case of failure zero is returned.

Definition at line 46 of file SessionTool.cxx.

46 {
47 void* result {};
48 if( m_transactionType != Io::INVALID ) {
50 if ( db.openMode() == Io::INVALID ) {
51 db.setTechnology( token.technology() );
52 db.connectForRead();
53 }
54 result = db.readObject( token, object );
55 }
56 return result;
57}
constexpr void toString(std::span< char, StrLen > buf, bool uppercase=true) const noexcept
Automatic conversion to string representation.
int technology() const
Access technology type.
Definition Token.h:78
const Guid & dbID() const
Access database identifier.
Definition Token.h:65

◆ registerDatabaseHandler()

void SessionTool::registerDatabaseHandler ( DatabaseHandler * dbHandler,
const std::string & lfn = "" )

Registers a database.

Definition at line 73 of file SessionTool.cxx.

73 {
74 std::set< DatabaseHandler* >::iterator iDatabase = m_databases.find( dbHandler );
75 if ( iDatabase == m_databases.end() ) {
76 iDatabase = m_databases.insert( dbHandler ).first;
77 m_fidToDb.insert( std::make_pair( dbHandler->fid(), dbHandler ) );
78 m_pfnToDb.insert( std::make_pair( dbHandler->pfn(), dbHandler ) );
79 m_fidToLfns.insert( std::make_pair( dbHandler->fid(), std::set< std::string >() ) );
80 }
81 if ( ! lfn.empty() ) {
82 m_fidToLfns.find( dbHandler->fid() )->second.insert( lfn );
83 m_lfnToDb.insert( std::make_pair( lfn, *iDatabase ) );
84 }
85}
const std::string & fid() const
Returns the file identifier.
const std::string & pfn() const
Returns the physical file name.

◆ registerForWrite()

Token * SessionTool::registerForWrite ( const Placement & place,
const void * object,
const RootType & type )
virtual

registerForWrite registers an object for writing to the persistent medium higher level interactions with the framework are necessary.

Parameters
place[IN] the placement hint
object[IN] pointer to transient object which will be written
type[IN] reflection class description with the layout of transient object
Returns
Token* the token address of the persistent object. I case of failure 0 is returned.

Definition at line 59 of file SessionTool.cxx.

61 {
62 if( m_transactionType != Io::WRITE && m_transactionType != Io::APPEND ) {
63 return 0;
64 }
66 if ( db.openMode() == Io::INVALID ) {
67 db.setTechnology( place.technology() );
68 db.connectForWrite();
69 }
70 return db.writeObject( place.containerName(), place.technology(), object, type );
71}
const std::string & containerName() const
Access container name.
Definition Placement.h:33
const std::string & fileName() const
Access file name.
Definition Placement.h:29
int technology() const
Access technology type.
Definition Placement.h:37

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ setAttributeOfType()

bool SessionTool::setAttributeOfType ( long technology,
const std::string & attributeName,
const void * data,
const std::type_info & typeInfo,
const std::string & option )

Definition at line 213 of file SessionTool.cxx.

217 {
218 return this->microSessionManager(technology).setAttributeOfType(attributeName, data, typeInfo, option);
219}
bool setAttributeOfType(const std::string &attributeName, const void *data, const std::type_info &typeInfo, const std::string &option)

◆ setupFC()

void SessionTool::setupFC ( Gaudi::IFileCatalog & fileCatalog,
int ageLimit = -1 )
virtual

Definition at line 25 of file SessionTool.cxx.

25 {
27 m_ageLimit = ageLimit;
28}
virtual Gaudi::IFileCatalog & fileCatalog()
Returns the file catalog in use.

◆ startTransaction()

bool SessionTool::startTransaction ( Io::IoFlag type = Io::READ)
virtual

Starts a new transaction. Returns the success of the operation.

Definition at line 126 of file SessionTool.cxx.

126 {
127 if( m_transactionType != Io::INVALID ) return false;
129 return true;
130}

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }
std::vector< SG::VarHandleKeyArray * > m_vhka

Member Data Documentation

◆ m_ageLimit

int SessionTool::m_ageLimit
private

Definition at line 138 of file SessionTool.h.

◆ m_catalog

Gaudi::IFileCatalog* SessionTool::m_catalog
private

Definition at line 137 of file SessionTool.h.

◆ m_databases

std::set< DatabaseHandler* > SessionTool::m_databases
private

Definition at line 141 of file SessionTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_fidToDb

std::map< std::string, DatabaseHandler* > SessionTool::m_fidToDb
private

Definition at line 142 of file SessionTool.h.

◆ m_fidToLfns

std::map< std::string, std::set< std::string > > SessionTool::m_fidToLfns
private

Definition at line 145 of file SessionTool.h.

◆ m_lfnToDb

std::map< std::string, DatabaseHandler* > SessionTool::m_lfnToDb
private

Definition at line 144 of file SessionTool.h.

◆ m_pfnToDb

std::map< std::string, DatabaseHandler* > SessionTool::m_pfnToDb
private

Definition at line 143 of file SessionTool.h.

◆ m_technologies

std::map< long, std::unique_ptr<MicroSessionManager> > SessionTool::m_technologies
private

Definition at line 140 of file SessionTool.h.

◆ m_transactionType

Io::IoFlag SessionTool::m_transactionType
private

Definition at line 139 of file SessionTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 386 of file AthCommonDataStore.h.


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