ATLAS Offline Software
Loading...
Searching...
No Matches
Database Class Referencefinal

#include <Database.h>

Inheritance diagram for Database:
Collaboration diagram for Database:

Classes

struct  Specification

Public Member Functions

 Database (SessionTool &session, const std::string &name, const Specification::NameType nameType)
 Constructor.
 ~Database ()
 Destructor.
void connectForRead ()
 Connects explicitly to the database for read operations.
void * readObject (const Token &token, void *object=0)
 Reads an object given a token.
void connectForWrite ()
 Connects explicitly to the database for write/update operations.
Token * writeObject (const std::string &containerName, long minorTechnology, const void *object, const RootType &type)
 Writes an object and returns a token.
void disconnect ()
 Disconnects from the database.
Io::IoFlag openMode () const
 Returns the opening mode. It can be used to check whether the database is connected.
const std::string & fid ()
 Returns the file identifier of this database.
const std::string & pfn ()
 Returns the physical file name of this database.
bool setTechnology (long technology)
 Sets the technology identifier for this database.
std::vector< std::string > containers ()
 Returns the names of the containers in this database.
Container * containerHandle (const std::string &name)
 Returns a pointer to a container object. The user acquires ownership of that object.
FileDescriptor * fileDescriptor ()
bool attributeOfType (const std::string &attributeName, void *data, const std::type_info &typeInfo, const std::string &option)
bool setAttributeOfType (const std::string &attributeName, const void *data, const std::type_info &typeInfo, const std::string &option)
bool msgLvl (const MSG::Level lvl) const
 Test the output level.
MsgStream & msg () const
 The standard message stream.
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream.
void setLevel (MSG::Level lvl)
 Change the current logging level.

Private Member Functions

bool checkInRegistry ()
 Checks in the registry if the database handler already exists.
void initMessaging () const
 Initialize our message level and MessageSvc.

Private Attributes

SessionTool & m_session
 Reference to the session.
Gaudi::IFileCatalog & m_catalog
 Reference to the file catalog.
Io::IoFlag m_transactionType
 Transaction type (read/update).
std::string m_name
 The database name.
Specification::NameType m_nameType
 The database name spacification.
long m_technology
 The technology identifier of the database.
bool m_technologySet
 Checks if the technology identifier has been set.
DatabaseHandler * m_databaseHandler
 The underlying database handler.
Io::IoFlag m_openMode
 Current open mode.
bool m_alreadyConnected
 Flag indicating whether a connection has been already made once.
std::string m_the_fid
 Other names used.
std::string m_the_pfn
std::string m_nm
 Message source name.
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer.
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level.
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging).

Detailed Description

Definition at line 23 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

Constructor & Destructor Documentation

◆ Database()

Database::Database ( SessionTool & session,
const std::string & name,
const Specification::NameType nameType )

Constructor.

Definition at line 17 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

19 : AthMessaging("PoolSvc.Database"),
20 m_session( session ),
21 m_catalog( session.fileCatalog() ),
22 m_transactionType( session.openMode() ),
23 m_name( name ),
24 m_nameType( nameType ),
25 m_technology( 0 ),
26 m_technologySet( false ),
28 m_openMode( Io::INVALID ),
29 m_alreadyConnected( false ),
30 m_the_fid( "" ),
31 m_the_pfn( "" ) {
32 this->checkInRegistry();
33}
AthMessaging()
Default constructor:
Specification::NameType m_nameType
The database name spacification.
long m_technology
The technology identifier of the database.
Io::IoFlag m_openMode
Current open mode.
bool checkInRegistry()
Checks in the registry if the database handler already exists.
std::string m_name
The database name.
SessionTool & m_session
Reference to the session.
std::string m_the_fid
Other names used.
DatabaseHandler * m_databaseHandler
The underlying database handler.
bool m_alreadyConnected
Flag indicating whether a connection has been already made once.
Io::IoFlag m_transactionType
Transaction type (read/update).
Gaudi::IFileCatalog & m_catalog
Reference to the file catalog.
bool m_technologySet
Checks if the technology identifier has been set.
virtual Io::IoFlag openMode() const
Returns the transaction type.
Definition SessionTool.h:97
virtual Gaudi::IFileCatalog & fileCatalog()
Returns the file catalog in use.

◆ ~Database()

Database::~Database ( )

Destructor.

Definition at line 35 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

35{}

Member Function Documentation

◆ attributeOfType()

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

Definition at line 314 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

317 {
318 if ( ! m_databaseHandler ) return false;
319 else return m_databaseHandler->attribute( attributeName, data, typeInfo, option );
320}

◆ checkInRegistry()

bool Database::checkInRegistry ( )
private

Checks in the registry if the database handler already exists.

Definition at line 283 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

283 {
284 // Check first if the database is already connected.
285 switch( m_nameType ) {
287 m_databaseHandler = m_session.lookupByPFN( m_name );
288 break;
290 m_databaseHandler = m_session.lookupByFID( m_name );
291 break;
293 m_databaseHandler = m_session.lookupByLFN( m_name );
294 break;
295 default:
296 throw std::runtime_error( "Only PFN, LFN and FID database types are currently supported (APR: \" Database::checkInRegistry \" from \" PersistencySvc \")" );
297 };
298 if ( m_databaseHandler ) {
299 m_alreadyConnected = true;
300 m_technology = m_databaseHandler->technology();
301 m_openMode = m_databaseHandler->accessMode();
305 return true;
306 }
307 else return false;
308}

◆ connectForRead()

void Database::connectForRead ( )

Connects explicitly to the database for read operations.

Definition at line 37 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

37 {
38 if( !m_databaseHandler && m_transactionType != Io::INVALID ) {
39 // Check if the database is already connected
40 if( !checkInRegistry() ) {
41 // It is not. Connect !
42 switch( m_nameType ) {
44 if ( this->fid().empty() ) {
45 throw std::runtime_error( "PFN \"" + m_name + "\" is not existing (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
46 }
47 break;
49 if ( this->pfn().empty() ) {
50 throw std::runtime_error( "FID \"" + m_name + "\" is not existing in the catalog (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
51 }
52 break;
54 {
55 std::string lfn = m_name;
56 if ( this->fid().empty() ) {
57 throw std::runtime_error( "LFN \"" + m_name + "\" is not existing in the catalog (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
58 }
59 this->connectForRead();
60 m_session.registerDatabaseHandler( m_databaseHandler, lfn );
61 }
62 return;
63 break;
64 default:
65 throw std::runtime_error( "Unknown database name type (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
66 };
67
68 // Now we have all the usefull information to open the file.
69 // Check the registry now that we have the FID (in case of ambiguous PFNs)
70 m_databaseHandler = m_session.lookupByFID( m_the_fid );
71 if( !m_databaseHandler ) {
72 // still no luck - make a new connection
74 }
75 if( m_databaseHandler ) {
76 m_openMode = Io::READ;
77 }
78 else {
79 throw std::runtime_error( "Could not connect to the file (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
80 }
81 }
82 }
83}
static const Attributes_t empty
void connectForRead()
Connects explicitly to the database for read operations.
const std::string & fid()
Returns the file identifier of this database.
const std::string & pfn()
Returns the physical file name of this database.

◆ connectForWrite()

void Database::connectForWrite ( )

Connects explicitly to the database for write/update operations.

Definition at line 92 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

92 {
93 if( !m_databaseHandler && m_transactionType != Io::INVALID ) {
94 if ( m_transactionType != Io::WRITE && m_transactionType != Io::APPEND ) {
95 throw std::runtime_error( "Could not open a database for write outside an update transaction. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
96 }
97
98 if ( this->checkInRegistry() ) {
99 if ( m_openMode == Io::READ ) {
100 throw std::runtime_error( "Could not open a database for write that is already connected for read. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
101 }
102 } else { // The database is not yet connected.
103 bool dbRegistered = false;
104 switch( m_nameType ) {
107 if ( this->fid().empty() ) {
108 // Check if the technology is already set
109 if( ! m_technologySet ) {
110 throw std::runtime_error( "The back end technology has not been specified (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
111 }
112 // register in the catalog
113 DbType dbType( m_technology );
114 DbType dbTypeMajor( dbType.majorType() );
115 FileCatalogUtils::registerPFN( m_catalog, m_the_pfn.substr(0, m_the_pfn.find('?')), dbTypeMajor.storageName(), m_the_fid );
116 ATH_MSG_DEBUG("registered PFN: " << m_the_pfn << " with FID:" << m_the_fid);
117 dbRegistered = true;
118 }
119 break;
122 if ( this->pfn().empty() ) {
123 throw std::runtime_error( "Could not find the FID \"" + m_name + "\" in the file catalog (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
124 }
125 break;
127 {
128 std::string lfn = m_name;
129 if ( this->fid().empty() ) {
130 throw std::runtime_error( "Could not find the LFN \"" + m_name + "\" in the file catalog (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
131 }
132 this->connectForWrite();
133 m_session.registerDatabaseHandler( m_databaseHandler, lfn );
134 }
135 return;
136 break;
137 default:
138 throw std::runtime_error( "Unknown database name type (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
139 };
140
142 if( !m_databaseHandler ) {
143 if( dbRegistered ) {
144 // creation failed, remove entry from the in-memory catalog
145 m_catalog.deleteFID( m_the_fid );
146 }
147 throw std::runtime_error( "Could not connect to the file (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
148 }
149 m_openMode = m_transactionType == Io::WRITE ? Io::WRITE : Io::APPEND;
150 } // Connection established
151
152 } // Database handler retrieved
153}
#define ATH_MSG_DEBUG(x,...)
void connectForWrite()
Connects explicitly to the database for write/update operations.
void registerPFN(Gaudi::IFileCatalog &fc, const std::string &pfn, const std::string &ftype, std::string &fid)
Register PFN, assign new FID if not given. Throws if the PFN is already registered.

◆ containerHandle()

Container * Database::containerHandle ( const std::string & name)

Returns a pointer to a container object. The user acquires ownership of that object.

Definition at line 275 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

275 {
276 Container* container = 0;
277 if ( m_databaseHandler ) {
278 container = m_databaseHandler->container( name );
279 }
280 return container;
281}
const SG::AuxVectorData * container() const
Return the container holding this element.

◆ containers()

std::vector< std::string > Database::containers ( )

Returns the names of the containers in this database.

Definition at line 267 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

267 {
268 std::vector< std::string > containers;
269 if ( m_databaseHandler ) {
270 containers = m_databaseHandler->containers();
271 }
272 return containers;
273}
std::vector< std::string > containers()
Returns the names of the containers in this database.

◆ disconnect()

void Database::disconnect ( )

Disconnects from the database.

Definition at line 165 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

165 {
166 if ( m_databaseHandler ) {
167 m_session.disconnect( m_databaseHandler );
168 m_openMode = Io::INVALID;
169 }
170}

◆ fid()

const std::string & Database::fid ( )

Returns the file identifier of this database.

Definition at line 176 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

176 {
177 if ( m_databaseHandler ) return m_databaseHandler->fid();
178 else {
179 if ( m_nameType == Specification::FID ) return m_name;
180 else if ( !m_the_fid.empty() ) return m_the_fid;
181 else {
183 std::string technology;
184 FileCatalogUtils::lookupFileByPFN( m_catalog, m_name.substr(0, m_name.find('?')), m_the_fid, technology );
185 ATH_MSG_DEBUG("lookupPFN: " << m_name << " returned FID: '" << m_the_fid << "' tech=" << technology);
186 if ( ! m_the_fid.empty() ) {
187 if( technology.empty() ) {
189 ATH_MSG_DEBUG("Retrying 'connect' using assumed PFN " << m_name << " as LFN (no tech found in PFC)" );
190 return m_the_fid;
191 }
193 m_technology = DbType::getType( technology ).majorType();
194 m_alreadyConnected = true;
195 }
196 else {
197 if( m_transactionType != Io::WRITE && m_transactionType != Io::APPEND ) { // Fetch the FID from the db itself !
198 if( !m_technologySet ) {
199 ATH_MSG_DEBUG("Opening database '" << m_name << "' with no technology set");
201 m_technologySet = true;
202 }
203 m_the_fid = m_session.fidForPfn( m_technology, m_name );
204 if( ! m_the_fid.empty() ) {
205 // sanity check - verify that the FID is not registered in PFC under a different name
206 std::string pfn, tech;
208 if( !pfn.empty() ) {
209 ATH_MSG_WARNING("Opening file '" << m_name << "' which is already registered in the Catalog as '" << pfn
210 <<"' (GUID " << m_the_fid << ") - this is not supported and may even lead to a crash!" );
211 }
213 m_alreadyConnected = true;
214 }
215 }
216 }
217 } /* not PFN */
218 else if ( m_nameType == Specification::LFN ) {
219 m_the_fid = m_catalog.lookupLFN( m_name );
220 }
221 if ( ! m_the_fid.empty() ) {
224 }
225 return m_the_fid;
226 }
227 return emptyString;
228 }
229}
#define ATH_MSG_WARNING(x,...)
static const std::string & emptyString
static DbType getType(const std::string &name)
Access known storage type object by name.
int majorType() const
Access to major type.
Definition DbType.h:52
int type() const
Access to full type.
Definition DbType.h:50
void lookupFileByPFN(const Gaudi::IFileCatalog &fc, const std::string &pfn, std::string &fid, std::string &tech)
Get FID and filetype for a given PFN.
void getFirstPFN(const Gaudi::IFileCatalog &fc, const std::string &fid, std::string &pfn, std::string &tech)
Get the first PFN + filetype for the given FID.
static const DbType ROOT_StorageType
Definition DbType.h:72

◆ fileDescriptor()

FileDescriptor * Database::fileDescriptor ( )

Definition at line 310 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

310 {
311 return m_databaseHandler? &m_databaseHandler->fileDescriptor() : nullptr;
312}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40{
42 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
std::string m_nm
Message source name.
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
std::atomic< MSG::Level > m_lvl
Current logging level.
IMessageSvc * getMessageSvc(bool quiet=false)
int outputLevel(const IMessageSvc *ims, const std::string &source)

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

168{
169 MsgStream* ms = m_msg_tls.get();
170 if (!ms) {
171 if (!m_initialized.test_and_set()) initMessaging();
172 ms = new MsgStream(m_imsg,m_nm);
173 m_msg_tls.reset( ms );
174 }
175
176 ms->setLevel (m_lvl);
177 return *ms;
178}
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels).
void initMessaging() const
Initialize our message level and MessageSvc.

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

183{ return msg() << lvl; }
MsgStream & msg() const
The standard message stream.

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152{
153 // If user did not set explicit message level we have to initialize
154 // the messaging and retrieve the default via the MessageSvc.
155 if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
156
157 if (m_lvl <= lvl) {
158 msg() << lvl;
159 return true;
160 } else {
161 return false;
162 }
163}

◆ openMode()

Io::IoFlag Database::openMode ( ) const

Returns the opening mode. It can be used to check whether the database is connected.

Definition at line 172 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

172 {
173 return m_openMode;
174}

◆ pfn()

const std::string & Database::pfn ( )

Returns the physical file name of this database.

Definition at line 231 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

231 {
232 if( m_databaseHandler ) return m_databaseHandler->pfn();
233 if( m_nameType == Specification::PFN ) return m_name;
234 if( ! m_the_pfn.empty() ) return m_the_pfn;
235
237 m_the_fid = m_catalog.lookupLFN( m_name );
238 if ( ! m_the_fid.empty() ) {
241 // go from FID=>PFN in the next step
242 }
243 }
245 std::string technology;
247 if( !m_the_pfn.empty() ) {
249 m_technology = DbType::getType( technology ).majorType();
250 m_alreadyConnected = true;
251 }
252 return m_the_pfn;
253 }
254 return emptyString;
255}

◆ readObject()

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

Reads an object given a token.

Definition at line 85 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

85 {
86 if( !m_databaseHandler) {
87 throw std::runtime_error( "Could not open a database for read object. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
88 }
89 return m_databaseHandler->readObject( token, object );
90}

◆ setAttributeOfType()

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

Definition at line 322 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

325 {
326 if ( ! m_databaseHandler ) return false;
327 else return m_databaseHandler->setAttribute( attributeName, data, typeInfo, option );
328}

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29{
30 m_lvl = lvl;
31}

◆ setTechnology()

bool Database::setTechnology ( long technology)

Sets the technology identifier for this database.

This can only be called for newly created databases before the connect method is called. Otherwise false is returned.

Definition at line 257 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

257 {
258 if ( m_alreadyConnected ) return false;
259 else {
260 DbType dbType( technology );
261 m_technology = dbType.majorType();
262 m_technologySet = true;
263 return true;
264 }
265}

◆ writeObject()

Token * Database::writeObject ( const std::string & containerName,
long minorTechnology,
const void * object,
const RootType & type )

Writes an object and returns a token.

Definition at line 155 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

158 {
159 if( !m_databaseHandler) {
160 throw std::runtime_error( "Could not open a database for write object. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
161 }
162 return m_databaseHandler->writeObject( containerName, minorTechnology, object, type );
163}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

◆ m_alreadyConnected

bool Database::m_alreadyConnected
private

Flag indicating whether a connection has been already made once.

Definition at line 116 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_catalog

Gaudi::IFileCatalog& Database::m_catalog
private

Reference to the file catalog.

Definition at line 100 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_databaseHandler

DatabaseHandler* Database::m_databaseHandler
private

The underlying database handler.

Definition at line 112 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

◆ m_name

std::string Database::m_name
private

The database name.

Definition at line 104 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_nameType

Specification::NameType Database::m_nameType
private

The database name spacification.

Definition at line 106 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_openMode

Io::IoFlag Database::m_openMode
private

Current open mode.

Definition at line 114 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_session

SessionTool& Database::m_session
private

Reference to the session.

Definition at line 98 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_technology

long Database::m_technology
private

The technology identifier of the database.

Definition at line 108 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_technologySet

bool Database::m_technologySet
private

Checks if the technology identifier has been set.

Definition at line 110 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_the_fid

std::string Database::m_the_fid
private

Other names used.

Definition at line 118 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_the_pfn

std::string Database::m_the_pfn
private

Definition at line 119 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_transactionType

Io::IoFlag Database::m_transactionType
private

Transaction type (read/update).

Definition at line 102 of file Database/AthenaPOOL/PoolSvc/src/Database.h.


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