PoolDbCacheSvc Class Reference

#include <PoolDb/PoolDbCacheSvc.h>

Inheritance diagram for PoolDbCacheSvc:

[legend]

Collaboration diagram for PoolDbCacheSvc:

[legend]

List of all members.

Detailed Description

Description:.

The PoolCacheMgr service interface allows to access special functionality provided by the POOL persistency interface.

Author:: Markus Frank

Version:: 1.0

Definition at line 32 of file PoolDbCacheSvc.h.


Public Member Functions
	PoolDbCacheSvc (const std::string &name, ISvcLocator *svc)
	Standard constructor.
virtual	~PoolDbCacheSvc ()
	Standard destructor.
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Service overload: Query interface.
virtual StatusCode	initialize ()
	Service overload: initialize service.
virtual StatusCode	finalize ()
	Service overload: Finalize service.
virtual pool::DbSession &	session ()
	Access the (single) POOL database session.
virtual StatusCode	loadDictionary (const std::string &name)
	Load dictionary library.
virtual pool::DbOptionCallback *	callbackHandler () const
	Access to POOL callback handler.
virtual pool::DbStatus	setMyOptions (pool::IDbOptionProxy *pObj, pool::DbOptionCallback::OptionType typ, const std::string &name)
	Default callback (does nothing).
virtual pool::DbStatus	setCallbackOptions (pool::IDbOptionProxy *pObj, const std::vector< std::string > &v, const std::string &name)
	Set callback specific options.
Protected Member Functions
StatusCode	loadLibraries ()
	Load all required libraries.
Protected Attributes
pool::DbSession	m_session
	The POOL database session.
pool::DbOptionCallback *	m_callbackHandler
	Reference to POOL callback handler.
std::vector< std::string >	m_dlls
	Driver DLL to be loaded at initialization.
std::vector< std::string >	m_domainOpts
	Buffer for domain options.
std::vector< std::string >	m_databaseOpts
	Buffer for database options.
std::vector< std::string >	m_databaseOpenOpts
	Buffer for database options to be set after "open".
std::vector< std::string >	m_containerOpts
	Buffer for container options.
std::vector< std::string >	m_containerOpenOpts
	Buffer for container options to be set after "open".
std::vector< System::ImageHandle >	m_sharedHdls
	Shared Gaudi libraries.

Constructor & Destructor Documentation

PoolDbCacheSvc::PoolDbCacheSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Standard constructor.

Definition at line 58 of file PoolDbCacheSvc.cpp.

00059   : Service(nam, svc), m_callbackHandler(0)
00060 {
00061   s_count->increment();
00062   m_callbackHandler = this;
00063   declareProperty("Dlls",               m_dlls);
00064   declareProperty("DomainOpts",         m_domainOpts);
00065   declareProperty("DatabaseOpts",       m_databaseOpts);
00066   declareProperty("DatabaseOnOpenOpts", m_databaseOpenOpts);
00067   declareProperty("ContainerOpts",      m_containerOpts);
00068   declareProperty("ContainerOnOpenOpts",m_containerOpenOpts);
00069 }

PoolDbCacheSvc::~PoolDbCacheSvc ( ) [virtual]

Standard destructor.

Definition at line 72 of file PoolDbCacheSvc.cpp.

00073 {
00074   s_count->decrement();
00075 }

Member Function Documentation

StatusCode PoolDbCacheSvc::loadLibraries ( ) [protected]

Load all required libraries.

Definition at line 213 of file PoolDbCacheSvc.cpp.

00213                                           {
00214   StatusCode status = StatusCode::SUCCESS;
00215   if ( !m_dlls.empty() )  {
00216     std::vector<std::string>::const_iterator i;
00217     for(i=m_dlls.begin(); i != m_dlls.end(); ++i)  {
00218       StatusCode iret = loadDictionary(*i);
00219       if ( !iret.isSuccess() )  {
00220         status = iret;
00221       }
00222     }
00223   }
00224   return status;
00225 }

StatusCode PoolDbCacheSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)			`[virtual]`

Service overload: Query interface.

Reimplemented from Service.

Definition at line 78 of file PoolDbCacheSvc.cpp.

00079 {
00080   if ( IPoolCacheSvc::interfaceID().versionMatch(riid) )  {
00081     *ppvInterface = (IPoolCacheSvc*)this;
00082     addRef();
00083     return StatusCode::SUCCESS;
00084   }
00085   // Interface is not directly availible: try out a base class
00086   return Service::queryInterface(riid, ppvInterface);
00087 }

StatusCode PoolDbCacheSvc::initialize ( ) [virtual]

Service overload: initialize service.

Reimplemented from Service.

Definition at line 90 of file PoolDbCacheSvc.cpp.

00090                                        {
00091   StatusCode status = Service::initialize();
00092   MsgStream log(messageService(), name());
00093   if ( !status.isSuccess() ) {
00094     log << MSG::ERROR << "Failed to initialize Service base class."
00095         << endmsg;
00096     return status;
00097   }
00098   coral::MessageStream::installMsgReporter(new PoolDbMsgReporter(messageService(),m_outputLevel.value()));
00099   coral::MessageStream::setMsgVerbosity(static_cast<coral::MsgLevel>(m_outputLevel.value()));
00100 
00101   log << MSG::INFO << "POOL output threshold:" << m_outputLevel
00102       << endmsg;
00103   status = loadLibraries();
00104   if ( !status.isSuccess() ) {
00105     log << MSG::ERROR << "Failed to load POOL libraries."
00106         << endmsg;
00107     return status;
00108   }
00109   session().open(0);
00110   // All dictionaries should be loaded. Let's patch the streamers
00111   // for ContainedObject, DataObject and SmartRefbase
00112   if ( !GaudiPoolDb::patchStreamers(log) )  {
00113     log << MSG::ERROR << "Failed to install customized IO!" << endmsg;
00114     return StatusCode::FAILURE;
00115   }
00116   return status;
00117 }

StatusCode PoolDbCacheSvc::finalize ( void ) [virtual]

Service overload: Finalize service.

Shared Gaudi libraries

Reimplemented from Service.

Definition at line 120 of file PoolDbCacheSvc.cpp.

00120                                       {
00121   MsgStream log(messageService(), name());
00122   session().close();
00124   std::vector<System::ImageHandle>::iterator i;
00125   for(i=m_sharedHdls.begin(); i != m_sharedHdls.end(); ++i)  {
00126     if ( *i ) {
00127       // System::unloadDynamicLib(*i);
00128     }
00129   }
00130   m_sharedHdls.clear();
00131   coral::MessageStream::installMsgReporter(0);
00132   return Service::finalize();
00133 }

virtual pool::DbSession& PoolDbCacheSvc::session ( ) [inline, virtual]

Access the (single) POOL database session.

Returns:: Reference to POOL session handle

Implements IPoolCacheSvc.

Definition at line 89 of file PoolDbCacheSvc.h.

00089                                       {
00090     return m_session;
00091   }

StatusCode PoolDbCacheSvc::loadDictionary ( const std::string & name ) [virtual]

Load dictionary library.

Parameters:

name

[IN] dictionary name/file path

Returns:: Status code indicating success or failure

Implements IPoolCacheSvc.

Definition at line 228 of file PoolDbCacheSvc.cpp.

00228                                                               {
00229   System::ImageHandle hdl = 0;
00230   StatusCode status = System::loadDynamicLib(nam, &hdl);
00231   if ( !status.isSuccess() )  {
00232     MsgStream log(messageService(), name());
00233     log << MSG::ERROR << System::getLastErrorString() << endmsg
00234         << "Failed to load POOL implementation library:"
00235         << nam << endmsg;
00236     return status;
00237   }
00238   m_sharedHdls.push_back(hdl);
00239   return status;
00240 }

virtual pool::DbOptionCallback* PoolDbCacheSvc::callbackHandler ( ) const [inline, virtual]

Access to POOL callback handler.

Returns:: Reference to POOL callback handler

Implements IPoolCacheSvc.

Definition at line 103 of file PoolDbCacheSvc.h.

00103                                                          {
00104     return m_callbackHandler;
00105   }

pool::DbStatus PoolDbCacheSvc::setMyOptions	(	pool::IDbOptionProxy *	pObj,
		pool::DbOptionCallback::OptionType	typ,
		const std::string &	name
	)			`[virtual]`

Default callback (does nothing).

Parameters:

	pObj	[IN] Reference to object receiving options
	typ	[IN] Object type to receive options
	name	[IN] Object's name.

Returns:: Status code indicating success or failure.

Reimplemented from pool::DbOptionCallback.

Definition at line 191 of file PoolDbCacheSvc.cpp.

00194 {
00195   switch (typ)  {
00196     case pool::DbOptionCallback::_DOMAIN_OPT:
00197       return setCallbackOptions(pObj, m_domainOpts, name);
00198     case pool::DbOptionCallback::_DATABASE_OPT:
00199       return setCallbackOptions(pObj, m_databaseOpts, name);
00200     case pool::DbOptionCallback::_DATABASE_ONOPEN:
00201       return setCallbackOptions(pObj, m_databaseOpenOpts, name);
00202     case pool::DbOptionCallback::_CONTAINER_OPT:
00203       return setCallbackOptions(pObj, m_containerOpts, name);
00204     case pool::DbOptionCallback::_CONTAINER_ONOPEN:
00205       return setCallbackOptions(pObj, m_containerOpenOpts, name);
00206     default:
00207       break;
00208   }
00209   return pool::Error;
00210 }

pool::DbStatus PoolDbCacheSvc::setCallbackOptions	(	pool::IDbOptionProxy *	pObj,
		const std::vector< std::string > &	v,
		const std::string &	name
	)			`[virtual]`

Set callback specific options.

Set container specific options.

Parameters:

	pObj	[IN] Reference to object receiving options
	name	[IN] Object's name.

Returns:: Status code indicating success or failure.

Definition at line 137 of file PoolDbCacheSvc.cpp.

00140 {
00141   std::string opt_nam, opt_val, opt_typ;
00142   typedef std::vector<std::string> StringV;
00143   for (StringV::const_iterator i=v.begin(); i!=v.end(); ++i)  {
00144     const std::string& id = *i;
00145     if ( id.length() > obj.length() )   {
00146       if ( obj == id.substr(0, obj.length()) )  {
00147         std::string n = id.substr(obj.length()+1);
00148         size_t idx = n.find("=");
00149         size_t idx2 = n.find("TYP=");
00150         if ( idx != std::string::npos && idx2 != std::string::npos )  {
00151           opt_nam = n.substr(0, idx);
00152           opt_val = n.substr(idx+1, idx2-2-idx);
00153           opt_typ = n.substr(idx2+4,1);
00154           std::stringstream s(opt_val);
00155           pool::DbOption opt(opt_nam);
00156           float fval;
00157           int   ival;
00158           long long int lval;
00159           switch(::toupper(opt_typ[0])) {
00160             case 'I':
00161               s >> ival;
00162               opt._setValue(ival);
00163               pObj->setOption(opt);
00164               break;
00165             case 'L':
00166               s >> lval;
00167               opt._setValue(lval);
00168               pObj->setOption(opt);
00169               break;
00170             case 'F':
00171               s >> fval;
00172               opt._setValue(fval);
00173               pObj->setOption(opt);
00174               break;
00175             case 'S':
00176               opt._setValue(opt_val.c_str());
00177               pObj->setOption(opt);
00178               break;
00179             default:
00180               break;
00181           }
00182         }
00183       }
00184     }
00185   }
00186   return pool::Success;
00187 }

Member Data Documentation

pool::DbSession PoolDbCacheSvc::m_session [protected]

The POOL database session.

Definition at line 39 of file PoolDbCacheSvc.h.

pool::DbOptionCallback* PoolDbCacheSvc::m_callbackHandler [protected]

Reference to POOL callback handler.

Definition at line 42 of file PoolDbCacheSvc.h.

std::vector<std::string> PoolDbCacheSvc::m_dlls [protected]

Driver DLL to be loaded at initialization.

Definition at line 45 of file PoolDbCacheSvc.h.

std::vector<std::string> PoolDbCacheSvc::m_domainOpts [protected]

Buffer for domain options.

Definition at line 48 of file PoolDbCacheSvc.h.

std::vector<std::string> PoolDbCacheSvc::m_databaseOpts [protected]

Buffer for database options.

Definition at line 51 of file PoolDbCacheSvc.h.

std::vector<std::string> PoolDbCacheSvc::m_databaseOpenOpts [protected]

Buffer for database options to be set after "open".

Definition at line 54 of file PoolDbCacheSvc.h.

std::vector<std::string> PoolDbCacheSvc::m_containerOpts [protected]

Buffer for container options.

Definition at line 57 of file PoolDbCacheSvc.h.

std::vector<std::string> PoolDbCacheSvc::m_containerOpenOpts [protected]

Buffer for container options to be set after "open".

Definition at line 60 of file PoolDbCacheSvc.h.

std::vector<System::ImageHandle> PoolDbCacheSvc::m_sharedHdls [protected]

Shared Gaudi libraries.

Definition at line 63 of file PoolDbCacheSvc.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiPoolDb/GaudiPoolDb/PoolDbCacheSvc.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiPoolDb/src/PoolDbCacheSvc.cpp

	Gaudi Framework, version v20r3
	Generated: 24 Nov 2008

Gaudi Framework, version v20r3

PoolDbCacheSvc Class Reference

Detailed Description

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation