Gaudi Framework, version v21r9
Home   Generated: 3 May 2010

PoolDbCnvSvc Class Reference

Description:. More...

#include <PoolDb/PoolDbCnvSvc.h>

Inheritance diagram for PoolDbCnvSvc:

Inheritance graph
[legend]
Collaboration diagram for PoolDbCnvSvc:

Collaboration graph
[legend]

List of all members.

Public Types

typedef std::pair< void
*, const ROOT::Reflex::Type > 		ObjH
typedef std::map< std::string,
DbH > 		DbMap
typedef std::map< std::string,
std::string > 		DbFidMap

Public Member Functions

 PoolDbCnvSvc (const std::string &name, ISvcLocator *svc)
 Standard constructor.
virtual ~PoolDbCnvSvc ()
 Standard destructor.
virtual StatusCode updateServiceState (IOpaqueAddress *pAddress)
 Update state of the service.
StatusCode error (const std::string &msg, bool rethrow=true)
 Standard way to print errors.
StatusCode setDataProvider (IDataProviderSvc *pDataSvc)
 Connect to data provider service.
virtual StatusCode initialize ()
 ConversionSvc overload: initialize Db service.
virtual StatusCode finalize ()
 ConversionSvc overload: Finalize Db service.
virtual IConverter * createConverter (long typ, const CLID &wanted, const ICnvFactory *fac)
 ConversionSvc overload: Create new Converter using factory.
virtual void loadConverter (DataObject *)
 ConversionSvc overload: Load the class (dictionary) for the converter.
virtual IPoolCacheSvc * cacheSvc () const
 Access to cache service.
virtual StatusCode accessStorageType (const std::string &type_string, long &gaudi_type)
 Create access to the POOL persistency mechanism using the Gaudi String identifier.
virtual StatusCode connectOutput (const std::string &outputFile, const std::string &openMode)
 Connect the output file to the service with open mode.
StatusCode connectDatabase (int typ, const std::string &outputFile, pool::DbAccessMode openMode, PoolDbDataConnection **con)
 Connect the output file to the service with open mode.
StatusCode connectContainer (pool::DbDatabase &dbH, const std::string &cntName, pool::DbAccessMode openMode, const pool::DbTypeInfo *shape, pool::DbContainer &cntH)
 Connect to a database container.
virtual StatusCode connectContainer (int typ, const std::string &dbName, const std::string &cntName, pool::DbAccessMode openMode, const pool::DbTypeInfo *shape, pool::DbContainer &cntH)
 Connect to a database container.
virtual StatusCode connectOutput (const std::string &outputFile)
 Connect the output file to the service.
virtual StatusCode commitOutput (const std::string &outputFile, bool do_commit)
 Commit pending output.
virtual StatusCode connect (const std::string &dbName, const std::string &cntName, pool::DbContainer &cntH)
 Connect to a database container in read mode.
virtual StatusCode disconnect (const std::string &dbName)
 Disconnect from an existing data stream.
virtual StatusCode createAddress (long svc_type, const CLID &clid, const std::string *par, const unsigned long *ip, IOpaqueAddress *&refpAddress)
 IAddressCreator implementation: Address creation.
virtual StatusCode createAddress (pool::Token *pToken, PoolDbAddress **ppAddress)
 IPoolDbMgr implementation: Address creation.
virtual pool::DbSelect * createSelect (const std::string &criteria, const std::string &dbName, const std::string &cntName)
 Request an iterator over a container from the service.
virtual pool::DbSelect * createSelect (const std::string &criteria, pool::DbDatabase &dbH, const std::string &cntName)
 Request an iterator over a container from the service.
virtual StatusCode markWrite (pool::DataCallBack *call, const std::string &cntName, PoolDbAddress **ppAddr=0)
 Marks a reference to be written.
virtual StatusCode markUpdate (pool::DataCallBack *call, PoolDbAddress *pAddr)
 Mark an object for update.
virtual StatusCode read (pool::DataCallBack *call, PoolDbAddress *pAddr)
 Read existing object.
virtual StatusCode read (pool::DataCallBack *call, pool::Token &tok)
 Read existing object. Open transaction in read mode if not active.

Protected Attributes

std::string m_cacheSvcName
 Name of the POOL cache service instance to connect to.
std::string m_implementation
 Name of the OODataBase implementation.
std::string m_serverConnect
 Connection string to server.
std::string m_recordName
 ROOT name of optional records triggering incident.
bool m_safeTransactions
 Flag to indicate safe transactions if requested.
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_containerOpts
 Buffer for container options.
IDataManagerSvc * m_dataMgr
 Services needed for proper operation: Data Manager.
IPoolCacheSvc * m_cacheSvc
 Reference to POOL cache service.
PoolDbDataConnection * m_current
 On writing: reference to active output stream.
pool::DbDefaultDataHandler m_handler
 POOL Datahandler.
pool::DbDomain m_domH
 POOL technology domain handle.
std::string m_shareFiles
 Share files ? If set to YES, files will not be closed on finalize.
bool m_checkFIDs
 Flag to enforce FID checking and verification.
Gaudi::IFileCatalog * m_catalog
 Reference to the file catalog.
Gaudi::IIODataManager * m_ioMgr
 Reference to the I/O data manager.
IIncidentSvc * m_incidentSvc
 Reference to incident service.
bool m_incidentEnabled
 Flag to enable incidents on FILE_OPEN.

Classes

struct  DbH

Detailed Description

Description:.

PoolDbCnvSvc class implementation definition.

Author:
Markus Frank
Version:
1.0

Definition at line 46 of file PoolDbCnvSvc.h.

Member Typedef Documentation

typedef std::pair< void*, const ROOT::Reflex::Type > PoolDbCnvSvc::ObjH

Definition at line 60 of file PoolDbCnvSvc.h.

typedef std::map<std::string, DbH> PoolDbCnvSvc::DbMap

Definition at line 61 of file PoolDbCnvSvc.h.

typedef std::map<std::string, std::string> PoolDbCnvSvc::DbFidMap

Definition at line 62 of file PoolDbCnvSvc.h.

Constructor & Destructor Documentation

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

Standard constructor.

PoolDbCnvSvc::~PoolDbCnvSvc (  )  [virtual]

Standard destructor.

Definition at line 111 of file PoolDbCnvSvc.cpp.

00111                               {
00112   s_count->decrement();
00113 }

Member Function Documentation

StatusCode PoolDbCnvSvc::updateServiceState ( IOpaqueAddress *  pAddress  )  [virtual]

Update state of the service.

Reimplemented from ConversionSvc.

Definition at line 202 of file PoolDbCnvSvc.cpp.

00202                                                                         {
00203   return S_OK;
00204 }

StatusCode PoolDbCnvSvc::error ( const std::string &  msg,
bool  rethrow = true 
)

Standard way to print errors.

after the printout an exception is thrown.

Parameters:
msg [IN] Message string to be printed.
rethrow [IN] Flag to indicate if an exception should be thrown
Returns:
Status code returning failure.

StatusCode PoolDbCnvSvc::setDataProvider ( IDataProviderSvc *  pDataSvc  )  [virtual]

Connect to data provider service.

Re-connects to data manager service.

Parameters:
pDataSvc New data provider object.
Returns:
Status code indicating success or failure.

Reimplemented from ConversionSvc.

Definition at line 264 of file PoolDbCnvSvc.cpp.

00264                                                                     {
00265   IDataManagerSvc* tmp = m_dataMgr;
00266   if (pDataSvc)  {
00267     StatusCode status =
00268       pDataSvc->queryInterface(IDataManagerSvc::interfaceID(), pp_cast<void>(&m_dataMgr));
00269     if ( !status.isSuccess() )    {
00270       return error("Cannot connect to \"IDataManagerSvc\" interface.");
00271     }
00272   }
00273   if ( tmp ) tmp->release();
00274   return ConversionSvc::setDataProvider(pDataSvc);
00275 }

StatusCode PoolDbCnvSvc::initialize (  )  [virtual]

ConversionSvc overload: initialize Db service.

Initialize the Db data persistency service.

Reimplemented from ConversionSvc.

Definition at line 116 of file PoolDbCnvSvc.cpp.

00116                                      {
00117   StatusCode status = ConversionSvc::initialize();
00118   MsgStream log(msgSvc(), name());
00119   if ( !status.isSuccess() ) {
00120     log << MSG::ERROR << "Failed to initialize ConversionSvc base class."
00121         << endmsg;
00122     return status;
00123   }
00124   status = accessStorageType(m_implementation, m_type);
00125   if ( !status.isSuccess() )  {
00126     log << MSG::ERROR << "Failed to connect to POOL implementation:"
00127         << m_implementation << endmsg;
00128     return status;
00129   }
00130   status = service(m_cacheSvcName, m_cacheSvc);
00131   if ( !status.isSuccess() )  {
00132     log << MSG::ERROR << "Failed to connect to POOL cache service:"
00133         << m_cacheSvcName << endmsg;
00134     return status;
00135   }
00136   status = service("IODataManager", m_ioMgr);
00137   if( !status.isSuccess() ) {
00138     log << MSG::ERROR
00139         << "Unable to localize interface from service:IODataManager" << endmsg;
00140     return status;
00141   }
00142   status = service("FileCatalog", m_catalog);
00143   if( !status.isSuccess() ) {
00144     log << MSG::ERROR
00145         << "Unable to localize interface from service:FileCatalog" << endmsg;
00146     return status;
00147   }
00148   status = service("IncidentSvc", m_incidentSvc);
00149   if( !status.isSuccess() ) {
00150     log << MSG::ERROR
00151         << "Unable to localize interface from service:IncidentSvc" << endmsg;
00152     return status;
00153   }
00154   DbOptionCallback cb(m_cacheSvc->callbackHandler());
00155   if ( m_domH.open(m_cacheSvc->session(),m_type,pool::UPDATE).isSuccess() )  {
00156     SmartIF<IProperty> prp(m_ioMgr);
00157     IntegerProperty ageLimit;
00158     ageLimit.assign(prp->getProperty("AgeLimit"));
00159     log << MSG::DEBUG << "POOL agelimit is set to " << ageLimit.value() << endmsg;
00160     m_domH.setAgeLimit(ageLimit.value());
00161     return S_OK;
00162   }
00163   return S_OK;
00164 }

StatusCode PoolDbCnvSvc::finalize ( void   )  [virtual]

ConversionSvc overload: Finalize Db service.

Finalize the Db data persistency service.

Reimplemented from ConversionSvc.

Definition at line 167 of file PoolDbCnvSvc.cpp.

00167                                      {
00168   MsgStream log(msgSvc(),name());
00169   DbOptionCallback cb(m_cacheSvc->callbackHandler());
00170   if ( m_ioMgr )  {
00171     if ( ::toupper(m_shareFiles[0]) != 'Y' )  {
00172       IIODataManager::Connections cons = m_ioMgr->connections(this);
00173       for(IIODataManager::Connections::iterator i=cons.begin(); i != cons.end(); ++i)  {
00174         if ( m_ioMgr->disconnect(*i).isSuccess() )  {
00175           log << MSG::INFO << "Disconnected data IO:" << (*i)->fid();
00176           log << "[" << (*i)->pfn() << "]";
00177           log << endmsg;
00178           delete (*i);
00179         }
00180       }
00181     }
00182     else  {
00183       log << MSG::INFO << "File sharing enabled. Do not retire files." << endmsg;
00184     }
00185     m_ioMgr->release();
00186     m_ioMgr = 0;
00187   }
00188   m_domH.close();
00189   m_domH = 0;
00190   if ( m_dataMgr ) m_dataMgr->clearStore().ignore();
00191   pool::releasePtr(m_incidentSvc);
00192   pool::releasePtr(m_dataMgr);
00193   pool::releasePtr(m_catalog);
00194   pool::releasePtr(m_cacheSvc);
00195   StatusCode status = ConversionSvc::finalize();
00196   log << MSG::DEBUG << "POOL conversion service finalized " << name() << " ";
00197   log << (const char*)(status.isSuccess() ? "successfully" : "with errors") << endmsg;
00198   return status;
00199 }

IConverter * PoolDbCnvSvc::createConverter ( long  typ,
const CLID &  wanted,
const ICnvFactory *  fac 
) [virtual]

ConversionSvc overload: Create new Converter using factory.

Create new Converter using factory.

Reimplemented from ConversionSvc.

Definition at line 208 of file PoolDbCnvSvc.cpp.

00209 {
00210   IConverter* pConverter;
00211   ConverterID cnvid(POOL_StorageType, wanted);
00212   pConverter = PluginService::CreateWithId<IConverter*>(cnvid, typ, wanted, serviceLocator().get());
00213   if ( 0 == pConverter )  {
00214     const CLID gen_clids[] = {
00215     /* ObjectList               */ CLID_Any + CLID_ObjectList,
00216     /* ObjectVector             */ CLID_Any + CLID_ObjectVector,
00217     /* Keyed Map                */ CLID_Any + CLID_ObjectVector+0x00030000,
00218     /* Keyed Hashmap            */ CLID_Any + CLID_ObjectVector+0x00040000,
00219     /* Keyed redirection array  */ CLID_Any + CLID_ObjectVector+0x00050000,
00220     /* Standard, non-container  */ CLID_Any
00221     };
00222     for ( unsigned int i = 0; i < sizeof(gen_clids)/sizeof(gen_clids[0]); i++ ) {
00223       if ( (wanted>>16) == (gen_clids[i]>>16) )  {
00224         ConverterID cnvid1(POOL_StorageType, gen_clids[i]);
00225         pConverter = PluginService::CreateWithId<IConverter*>(cnvid1, typ, wanted, serviceLocator().get());
00226         if ( 0 != pConverter ) {
00227           return pConverter;
00228         }
00229       }
00230     }
00231     // Check if a converter using object update is needed
00232     if ( (wanted>>24) != 0 )  {
00233       ConverterID cnvid1(POOL_StorageType, CLID_Any | 1<<31);
00234       pConverter = PluginService::CreateWithId<IConverter*>(cnvid1, typ, wanted, serviceLocator().get());
00235       if ( 0 != pConverter ) {
00236         return pConverter;
00237       }
00238     }
00239     // If we do not have found any suitable container after searching
00240     // for standard containers, we will use the "ANY" converter
00241     // ... and pray for everything will go well.
00242     ConverterID cnvid1(POOL_StorageType, CLID_Any);
00243     pConverter = PluginService::CreateWithId<IConverter*>(cnvid1, typ, wanted, serviceLocator().get());
00244     if ( 0 != pConverter ) {
00245       MsgStream log(msgSvc(), name());
00246       log << MSG::INFO << "Using \"Any\" converter "
00247           << "for objects of type "
00248           << std::showbase << std::hex << wanted << endmsg;
00249     }
00250   }
00251   return pConverter;
00252 }

void PoolDbCnvSvc::loadConverter ( DataObject *  pObject  )  [virtual]

ConversionSvc overload: Load the class (dictionary) for the converter.

Reimplemented from ConversionSvc.

Definition at line 254 of file PoolDbCnvSvc.cpp.

00254                                                     {
00255   if (pObject) {
00256     MsgStream log(msgSvc(), name());
00257     std::string cname = System::typeinfoName(typeid(*pObject));
00258     log << MSG::DEBUG << "Trying to 'Autoload' dictionary for class " << cname << endmsg;
00259     gInterpreter->EnableAutoLoading();
00260     gInterpreter->AutoLoad(cname.c_str());
00261   }
00262 }

virtual IPoolCacheSvc* PoolDbCnvSvc::cacheSvc (  )  const [inline, virtual]

Access to cache service.

Implements IPoolDbMgr.

Definition at line 162 of file PoolDbCnvSvc.h.

00162 {  return m_cacheSvc; }

virtual StatusCode PoolDbCnvSvc::accessStorageType ( const std::string &  type_string,
long &  gaudi_type 
) [virtual]

Create access to the POOL persistency mechanism using the Gaudi String identifier.

Also all appropriate DLLS will be loaded on the fly.

Parameters:
type_string Gaudi storage string identifier
gaudi_type Gaudi storage identifier
Returns:
Status code indicating failure or success.

Implements IPoolDbMgr.

virtual StatusCode PoolDbCnvSvc::connectOutput ( const std::string &  outputFile,
const std::string &  openMode 
) [virtual]

Connect the output file to the service with open mode.

Parameters:
outputFile String containing output file
openMode String containing opening mode of the output file
Returns:
Status code indicating success or failure.

Reimplemented from ConversionSvc.

StatusCode PoolDbCnvSvc::connectDatabase ( int  typ,
const std::string &  outputFile,
pool::DbAccessMode  openMode,
PoolDbDataConnection **  con 
)

Connect the output file to the service with open mode.

Parameters:
outputFile String containing output file
openMode Opening mode of the output file
con Data connection reference
Returns:
Status code indicating success or failure.

StatusCode PoolDbCnvSvc::connectContainer ( pool::DbDatabase &  dbH,
const std::string &  cntName,
pool::DbAccessMode  openMode,
const pool::DbTypeInfo *  shape,
pool::DbContainer &  cntH 
)

Connect to a database container.

Parameters:
dbH Handle to hosting database
cntName String containing the name of the container object
openMode Open mode (READ,WRITE,UPDATE,...)
shape Default shape of objects in the container
cntH Reference to the POOL container object
Returns:
Status code indicating success or failure.

virtual StatusCode PoolDbCnvSvc::connectContainer ( int  typ,
const std::string &  dbName,
const std::string &  cntName,
pool::DbAccessMode  openMode,
const pool::DbTypeInfo *  shape,
pool::DbContainer &  cntH 
) [virtual]

Connect to a database container.

Parameters:
typ Database technology type
dbName String containing name of the database
cntName String containing the name of the container object
openMode Open mode (READ,WRITE,UPDATE,...)
shape Default shape of objects in the container
cntH Reference to the POOL container object
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

virtual StatusCode PoolDbCnvSvc::connectOutput ( const std::string &  outputFile  )  [virtual]

Connect the output file to the service.

Parameters:
outputFile String containing output file
Returns:
Status code indicating success or failure.

Reimplemented from ConversionSvc.

virtual StatusCode PoolDbCnvSvc::commitOutput ( const std::string &  outputFile,
bool  do_commit 
) [virtual]

Commit pending output.

Parameters:
outputFile String containing output file
do_commit if true commit the output and flush eventually pending items to the database if false, discard pending buffers. Note: The possibility to commit or rollback depends on the database technology used!
Returns:
Status code indicating success or failure.

Reimplemented from ConversionSvc.

virtual StatusCode PoolDbCnvSvc::connect ( const std::string &  dbName,
const std::string &  cntName,
pool::DbContainer &  cntH 
) [virtual]

Connect to a database container in read mode.

Parameters:
dbName String containing name of the database
cntName String containing the name of the container object
cntH Reference to the POOL container object
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

virtual StatusCode PoolDbCnvSvc::disconnect ( const std::string &  dbName  )  [virtual]

Disconnect from an existing data stream.

Parameters:
dbName String containing name of the database
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

StatusCode PoolDbCnvSvc::createAddress ( long  svc_type,
const CLID &  clid,
const std::string *  par,
const unsigned long *  ip,
IOpaqueAddress *&  refpAddress 
) [virtual]

IAddressCreator implementation: Address creation.

Create an address using the link information together with the triple (database name/container name/object name).

Parameters:
refLink Reference to abstract link information
dbName Database name
containerName Object container name
refpAddress Opaque address information to retrieve object
Returns:
StatusCode indicating SUCCESS or failure

Reimplemented from ConversionSvc.

Definition at line 527 of file PoolDbCnvSvc.cpp.

00532 {
00533   PoolDbAddress* pA = 0;
00534   pool::Guid guid = pool::Guid::null();
00535   std::auto_ptr<pool::Token> tok(new pool::Token());
00536   guid.Data1 = clid;
00537   tok->setDb(par[0]);
00538   tok->setCont(par[1]);
00539   tok->setTechnology(typ);
00540   tok->setClassID(guid);
00541   tok->oid().first = ip[0];
00542   tok->oid().second = ip[1];
00543   if ( createAddress(tok.get(), &pA).isSuccess() )  {
00544     refpAddress = pA;
00545     tok->release();
00546     tok.release();
00547     return S_OK;
00548   }
00549   return error("createAddress> Failed to create opaque address.");
00550 }

StatusCode PoolDbCnvSvc::createAddress ( pool::Token *  pToken,
PoolDbAddress **  ppAddress 
) [virtual]

IPoolDbMgr implementation: Address creation.

Create an address using an existing POOL token object.

Parameters:
pToken Reference to valid POOL token object.
ppAddress Opaque address information to retrieve object
Returns:
StatusCode indicating SUCCESS or failure

Implements IPoolDbMgr.

Definition at line 553 of file PoolDbCnvSvc.cpp.

00553                                                                             {
00554   if ( pTok )  {
00555     *ppAdd = new PoolDbAddress(pTok);
00556     return S_OK;
00557   }
00558   return error("createAddress> Failed to create opaque address from POOL token.");
00559 }

virtual pool::DbSelect* PoolDbCnvSvc::createSelect ( const std::string &  criteria,
const std::string &  dbName,
const std::string &  cntName 
) [virtual]

Request an iterator over a container from the service.

Parameters:
criteria Selection criteria to restrict iteration
dbName String containing name of the database
cntName String containing the name of the container object
Returns:
Reference to the selection object

Implements IPoolDbMgr.

virtual pool::DbSelect* PoolDbCnvSvc::createSelect ( const std::string &  criteria,
pool::DbDatabase &  dbH,
const std::string &  cntName 
) [virtual]

Request an iterator over a container from the service.

Parameters:
criteria Selection criteria to restrict iteration
dbH Handle to POOL database
cntName String containing the name of the container object
Returns:
Reference to the selection object

virtual StatusCode PoolDbCnvSvc::markWrite ( pool::DataCallBack *  call,
const std::string &  cntName,
PoolDbAddress **  ppAddr = 0 
) [virtual]

Marks a reference to be written.

Parameters:
call Pointer to callback object
cntName Container name the object should be written to.
refpAddr Persistent object location to be used for link setup.
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

StatusCode PoolDbCnvSvc::markUpdate ( pool::DataCallBack *  call,
PoolDbAddress *  pAddr 
) [virtual]

Mark an object for update.

Parameters:
call Pointer to callback object
pAddr Persistent object location to be used for link setup.
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

Definition at line 608 of file PoolDbCnvSvc.cpp.

00608                                                                               {
00609   if ( pA && call )  {
00610     pool::Token* tok = pA->token();
00611     DbContainer cntH(POOL_StorageType);
00612     const DbTypeInfo* info = (const DbTypeInfo*)call->shape();
00613     StatusCode sc = connectContainer(FID,tok->dbID(),tok->contID(),pool::UPDATE,info,cntH);
00614     if ( sc.isSuccess() )  {
00615       call->setHandler(&m_handler);
00616       if ( cntH.update(call, tok->oid()).isSuccess() )  {
00617         return S_OK;
00618       }
00619       return error("markUpdate> Failed to update object:"+tok->toString());
00620     }
00621     MsgStream log(msgSvc(), name());
00622     log << MSG::ERROR << "markUpdate> The container "
00623         << tok->dbID() << "::" << tok->contID()
00624         << " cannot be accessed." << endmsg
00625         << "Was this object really read from the container "
00626         << "the object token claims?"
00627         << endmsg;
00628     return S_FAIL;
00629   }
00630   return error("createRep> Invalid object address for update.");
00631 }

StatusCode PoolDbCnvSvc::read ( pool::DataCallBack *  call,
PoolDbAddress *  pAddr 
) [virtual]

Read existing object.

Read existing object. Open transaction in read mode if not active.

Open transaction in read mode if not active.

Parameters:
call Pointer to callback object
pAddr Pointer to valid object address.
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

Definition at line 634 of file PoolDbCnvSvc.cpp.

00634                                                                         {
00635   StatusCode sc = read(call, *pA->token());
00636   if ( sc.isSuccess() || sc == BAD_DATA_CONNECTION )  {
00637     return sc;
00638   }
00639   std::string err="read> Cannot read object:"+pA->registry()->identifier()+" ";
00640   return error(err, false);
00641 }

StatusCode PoolDbCnvSvc::read ( pool::DataCallBack *  call,
pool::Token &  tok 
) [virtual]

Read existing object. Open transaction in read mode if not active.

Parameters:
call Pointer to callback object
tok Reference to pool token describing the object
Returns:
Status code indicating success or failure.

Implements IPoolDbMgr.

Definition at line 644 of file PoolDbCnvSvc.cpp.

00644                                                                      {
00645   try  {
00646     DbContainer cntH(tok.technology());
00647     const DbTypeInfo* info = (const DbTypeInfo*)call->shape();
00648     StatusCode sc = connectContainer(FID,tok.dbID(),tok.contID(),pool::READ,info,cntH);
00649     if ( sc.isSuccess() )  {
00650       typedef pool::DbObjectHandle<pool::DbObject> ObjH;
00651       call->setHandler(&m_handler);
00652       return ObjH::openEx(cntH, tok, call, pool::READ).isSuccess() ? S_OK : S_FAIL;
00653     }
00654     else if ( sc == BAD_DATA_CONNECTION )  {
00655       return sc;
00656     }
00657   }
00658   catch (std::exception& e)  {
00659     std::string err="read> Cannot read object:"+tok.toString()+" ";
00660     return error(err+e.what(), false);
00661   }
00662   catch (...)   {
00663     std::string err = "read> Cannot read object:"+tok.toString();
00664     return error(err+" [Unknown fatal exception]", false);
00665   }
00666   return error("read> Cannot read object:"+tok.toString(), false);
00667 }

Member Data Documentation

std::string PoolDbCnvSvc::m_cacheSvcName [protected]

Name of the POOL cache service instance to connect to.

Definition at line 66 of file PoolDbCnvSvc.h.

std::string PoolDbCnvSvc::m_implementation [protected]

Name of the OODataBase implementation.

Definition at line 69 of file PoolDbCnvSvc.h.

std::string PoolDbCnvSvc::m_serverConnect [protected]

Connection string to server.

Definition at line 72 of file PoolDbCnvSvc.h.

std::string PoolDbCnvSvc::m_recordName [protected]

ROOT name of optional records triggering incident.

Definition at line 75 of file PoolDbCnvSvc.h.

bool PoolDbCnvSvc::m_safeTransactions [protected]

Flag to indicate safe transactions if requested.

Definition at line 78 of file PoolDbCnvSvc.h.

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

Buffer for domain options.

Definition at line 81 of file PoolDbCnvSvc.h.

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

Buffer for database options.

Definition at line 84 of file PoolDbCnvSvc.h.

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

Buffer for container options.

Definition at line 87 of file PoolDbCnvSvc.h.

IDataManagerSvc* PoolDbCnvSvc::m_dataMgr [protected]

Services needed for proper operation: Data Manager.

Definition at line 90 of file PoolDbCnvSvc.h.

IPoolCacheSvc* PoolDbCnvSvc::m_cacheSvc [protected]

Reference to POOL cache service.

Definition at line 93 of file PoolDbCnvSvc.h.

PoolDbDataConnection* PoolDbCnvSvc::m_current [protected]

On writing: reference to active output stream.

Definition at line 96 of file PoolDbCnvSvc.h.

pool::DbDefaultDataHandler PoolDbCnvSvc::m_handler [protected]

POOL Datahandler.

Definition at line 99 of file PoolDbCnvSvc.h.

pool::DbDomain PoolDbCnvSvc::m_domH [protected]

POOL technology domain handle.

Definition at line 102 of file PoolDbCnvSvc.h.

std::string PoolDbCnvSvc::m_shareFiles [protected]

Share files ? If set to YES, files will not be closed on finalize.

Definition at line 105 of file PoolDbCnvSvc.h.

bool PoolDbCnvSvc::m_checkFIDs [protected]

Flag to enforce FID checking and verification.

Definition at line 108 of file PoolDbCnvSvc.h.

Gaudi::IFileCatalog* PoolDbCnvSvc::m_catalog [protected]

Reference to the file catalog.

Definition at line 111 of file PoolDbCnvSvc.h.

Gaudi::IIODataManager* PoolDbCnvSvc::m_ioMgr [protected]

Reference to the I/O data manager.

Definition at line 114 of file PoolDbCnvSvc.h.

IIncidentSvc* PoolDbCnvSvc::m_incidentSvc [protected]

Reference to incident service.

Definition at line 117 of file PoolDbCnvSvc.h.

bool PoolDbCnvSvc::m_incidentEnabled [protected]

Flag to enable incidents on FILE_OPEN.

Definition at line 120 of file PoolDbCnvSvc.h.

The documentation for this class was generated from the following files:
Generated at Mon May 3 12:25:56 2010 for Gaudi Framework, version v21r9 by Doxygen version 1.5.6 written by Dimitri van Heesch, © 1997-2004