| # Gaudi Framework, version v20r4
Generated: 8 Jan 2009

# NTupleSvc Class Reference

`#include <NTupleSvc.h>`

Inheritance diagram for NTupleSvc:

[legend]
Collaboration diagram for NTupleSvc:

[legend]

List of all members.

## Detailed Description

NTuple service.

See the Interface definition files for more detailed documentation of the implementing class. Base class: Gaudi/DataSvc/DataSvc.h Generic N tuple service interface: Gaudi/Interfaces/INTupleSvc.h Generic IAddressCreator interface: Gaudi/Interfaces/IAddressCreator.h Generic IConversionSvc interface: Gaudi/Interfaces/IConversionSvc.h

Author:
  M.Frank

Definition at line 27 of file NTupleSvc.h.

## Public Member Functions
virtual StatusCode | initialize ()
| DataSvc overrides: Initialize the service.
virtual StatusCode | reinitialize ()
| DataSvc overrides: reinitialize service.
virtual StatusCode | finalize ()
| DataSvc overrides: stop the service.
virtual StatusCode | queryInterface (const InterfaceID &riid, void **ppvInterface)
| DataSvc overrides: Query interface.
virtual IConversionSvc * | getDataLoader (IRegistry *pReg)
| DataSvc overrides: Retrieve data loader.
virtual NTuple::Directory * | createDirectory (DataObject *pParent, const std::string &title)
| Create Ntuple directory and register it with the data store.
virtual NTuple::Directory * | createDirectory (DataObject *pParent, long id)
| Create Ntuple directory and register it with the data store.
virtual NTuple::Directory * | createDirectory (const std::string &dirPath, long id)
| Create Ntuple directory and register it with the data store.
virtual NTuple::Directory * | createDirectory (const std::string &dirPath, const std::string &title)
| Create Ntuple directory and register it with the data store.
virtual NTuple::Directory * | createDirectory (const std::string &fullPath)
| Create Ntuple directory and register it with the data store.
virtual StatusCode | create (const CLID &typ, const std::string &title, NTuple::Tuple *&refpTuple)
| Create requested N tuple (Hide constructor).
virtual NTuple::Tuple * | book (const std::string &fullPath, const CLID &type, const std::string &title)
| Book Ntuple and register it with the data store.
virtual NTuple::Tuple * | book (const std::string &dirPath, const std::string &relPath, const CLID &type, const std::string &title)
| Book Ntuple and register it with the data store.
virtual NTuple::Tuple * | book (const std::string &dirPath, long id, const CLID &type, const std::string &title)
| Book Ntuple and register it with the data store.
virtual NTuple::Tuple * | book (DataObject *pParent, const std::string &relPath, const CLID &type, const std::string &title)
| Book Ntuple and register it with the data store.
virtual NTuple::Tuple * | book (DataObject *pParent, long id, const CLID &type, const std::string &title)
| Book Ntuple and register it with the data store.
virtual NTuple::Tuple * | access (const std::string &fullPath, const std::string &filename)
| Access N tuple on disk.
virtual StatusCode | save (const std::string &fullPath)
| Save N tuple to disk. Must be called in order to close the ntuple file properly.
virtual StatusCode | save (NTuple::Tuple *tuple)
| Save N tuple to disk. Must be called in order to close the ntuple file properly.
virtual StatusCode | save (DataObject *pParent, const std::string &relPath)
| Save N tuple to disk. Must be called in order to close the ntuple file properly.
virtual StatusCode | writeRecord (NTuple::Tuple *tuple)
| Write single record to N tuple.
virtual StatusCode | writeRecord (const std::string &fullPath)
| Write single record to N tuple.
virtual StatusCode | writeRecord (DataObject *pParent, const std::string &relPath)
| Write single record to N tuple.
virtual StatusCode | readRecord (NTuple::Tuple *tuple)
| Read single record from N tuple.
virtual StatusCode | readRecord (const std::string &fullPath)
| Read single record from N tuple.
virtual StatusCode | readRecord (DataObject *pParent, const std::string &relPath)
| Read single record from N tuple.
virtual bool | isConnected (const std::string &identifier) const
| Check if a datasource is connected.
virtual StatusCode | connect (const std::string &ident)
| Add file to list I/O list.
virtual StatusCode | connect (const std::string &ident, std::string &logname)
| Add file to list I/O list.
virtual StatusCode | disconnect (const std::string &nam)
| Close open connection.
virtual StatusCode | disconnectAll ()
| Close all open connections.
| NTupleSvc (const std::string &name, ISvcLocator *svc)
| Standard Constructor.
virtual | ~NTupleSvc ()
| Standard Destructor.
## Protected Types
typedef std::vector< std::string > | DBaseEntries
typedef std::map< std::string, Connection > | Connections
typedef std::pair< std::string, std::string > | Prop
## Protected Member Functions
StatusCode | createService (const std::string &nam, const std::string &typ, const std::vector< Prop > &props, IConversionSvc *&pSvc)
| Create conversion service.
void | releaseConnection (Connection &c)
| Finalize single service.
StatusCode | attachTuple (const std::string &filename, const std::string &logname, const char typ, const long t)
| Attach output/input file.
StatusCode | updateDirectories ()
| Update directory data.
## Protected Attributes
DBaseEntries | m_output
| Output streams.
DBaseEntries | m_input
| Input streams.
Connections | m_connections
| Container of connection points.
## Friends
class | SvcFactory< NTupleSvc >
## Classes
struct | Connection

## Member Typedef Documentation

typedef std::vector< std::string > NTupleSvc::DBaseEntries`[protected]`

Definition at line 39 of file NTupleSvc.h.

typedef std::map<std::string, Connection> NTupleSvc::Connections`[protected]`

Definition at line 40 of file NTupleSvc.h.

typedef std::pair<std::string,std::string> NTupleSvc::Prop`[protected]`

Definition at line 41 of file NTupleSvc.h.

## Constructor & Destructor Documentation

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

Standard Constructor.

Selector factory instantiation.

Standard Constructor

Definition at line 54 of file NTupleSvc.cpp.

    00055  : DataSvc(name, svc)
    00056 {
    00057   declareProperty("Input",  m_input);
    00058   declareProperty("Output", m_output);
    00059   m_rootName = "/NTUPLES";
    00060   m_rootCLID = CLID_DataObject;
    00061 }

NTupleSvc::~NTupleSvc | ( |  | ) | `[virtual]`

Standard Destructor.

Definition at line 64 of file NTupleSvc.cpp.

    00064                         {
    00065 }

## Member Function Documentation

StatusCode NTupleSvc::initialize | ( |  | ) | `[virtual]`

DataSvc overrides: Initialize the service.

Initialize the service.

Reimplemented from DataSvc.

Reimplemented in TagCollectionSvc.

Definition at line 68 of file NTupleSvc.cpp.

    00068                                      {
    00069   StatusCode status = DataSvc::initialize();
    00070   if ( status.isSuccess() )   {
    00071     status = setProperties();
    00072     if ( status.isSuccess() )   {
    00073       StatusCode iret(StatusCode::SUCCESS,true);
    00074       DataObject* root = new NTuple::Directory();
    00075       status = setRoot(m_rootName, root);
    00076       for ( DBaseEntries::iterator i = m_output.begin(); i != m_output.end(); ++i )    {
    00077         iret = connect(*i);
    00078         if ( !iret.isSuccess() )    {
    00079           status = iret;
    00080         }
    00081       }
    00082       for ( DBaseEntries::iterator j = m_input.begin(); j != m_input.end(); ++j )    {
    00083         iret = connect(*j);
    00084         if ( !iret.isSuccess() )    {
    00085           status = iret;
    00086         }
    00087       }
    00088     }
    00089   }
    00090   return status;
    00091 }

StatusCode NTupleSvc::reinitialize | ( |  | ) | `[virtual]`

DataSvc overrides: reinitialize service.

Initialize the service.

Reimplemented from DataSvc.

Definition at line 94 of file NTupleSvc.cpp.

    00094                                    {
    00095   return StatusCode::SUCCESS;
    00096 }

StatusCode NTupleSvc::finalize | ( | void |  | ) | `[virtual]`

DataSvc overrides: stop the service.

stop the service.

Reimplemented from DataSvc.

Reimplemented in TagCollectionSvc.

Definition at line 209 of file NTupleSvc.cpp.

    00209                                     {
    00210   StatusCode status = updateDirectories();
    00211   status = clearStore();
    00212   status = DataSvc::finalize();
    00213   status = disconnectAll();
    00214   return status;
    00215 }

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

DataSvc overrides: Query interface.

Query interface.

Reimplemented from DataSvc.

Definition at line 218 of file NTupleSvc.cpp.

    00218                                                                                   {
    00219   if ( IID_INTupleSvc == riid )
    00220     *ppvInterface = (INTupleSvc*)this;
    00221   else if ( IID_IDataSourceMgr == riid )
    00222     *ppvInterface = (IDataSourceMgr*)this;
    00223   else  // Interface is not directly availible: try out a base class
    00224     return DataSvc::queryInterface(riid, ppvInterface);
    00225   addRef();
    00226   return StatusCode::SUCCESS;
    00227 }

IConversionSvc * NTupleSvc::getDataLoader | ( | IRegistry * | pReg | ) | `[virtual]`

DataSvc overrides: Retrieve data loader.

DataSvc override: Retrieve data loader.

Reimplemented from DataSvc.

Definition at line 105 of file NTupleSvc.cpp.

    00105                                                                 {
    00106   if ( 0 != pRegistry )    {
    00107     std::string full = pRegistry->identifier();
    00108     size_t len = m_rootName.length();
    00109     size_t idx = full.find(SEPARATOR,len+1);
    00110     std::string path = (idx==std::string::npos) ? full : full.substr(0, idx);
    00111     Connections::iterator i = m_connections.find(path);
    00112     if ( i != m_connections.end() )   {
    00113       return (*i).second.service;
    00114     }
    00115   }
    00116   return 0;
    00117 }

NTuple::Directory * NTupleSvc::createDirectory | ( | DataObject * | pParent,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Create Ntuple directory and register it with the data store.

Implements INTupleSvc.

Definition at line 468 of file NTupleSvc.cpp.

    00469                                                                            {
    00470   if ( 0 != pParent )   {
    00471     IRegistry* pDir = pParent->registry();
    00472     if ( 0 != pDir )    {
    00473       std::string full = pDir->identifier();
    00474       full += (relPath[0]=='/') ? "" : "/";
    00475       full += relPath;
    00476       return createDirectory(full);
    00477     }
    00478   }
    00479   return 0;
    00480 }

NTuple::Directory * NTupleSvc::createDirectory | ( | DataObject * | pParent,
|  | long | id |
| ) |  |  | `[virtual]`

Create Ntuple directory and register it with the data store.

Implements INTupleSvc.

Definition at line 483 of file NTupleSvc.cpp.

    00483                                                                             {
    00484   char txt[32];
    00485   return createDirectory( pParent, ::_itoa(id, txt,10) );
    00486 }

NTuple::Directory * NTupleSvc::createDirectory | ( | const std::string & | dirPath,
|  | long | id |
| ) |  |  | `[virtual]`

Create Ntuple directory and register it with the data store.

Implements INTupleSvc.

Definition at line 489 of file NTupleSvc.cpp.

    00489                                                                                  {
    00490   char txt[32];
    00491   return createDirectory( dirPath, ::_itoa(id, txt,10) );
    00492 }

NTuple::Directory * NTupleSvc::createDirectory | ( | const std::string & | dirPath,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Create Ntuple directory and register it with the data store.

Implements INTupleSvc.

Definition at line 495 of file NTupleSvc.cpp.

    00495                                                                                                    {
    00496   std::string full = dirPath;
    00497   full += (relPath[0]=='/') ? "" : "/";
    00498   full += relPath;
    00499   return createDirectory(full);
    00500 }

NTuple::Directory * NTupleSvc::createDirectory | ( | const std::string & | fullPath | ) | `[virtual]`

Create Ntuple directory and register it with the data store.

Implements INTupleSvc.

Definition at line 526 of file NTupleSvc.cpp.

    00526                                                                         {
    00527   NTuple::Directory* p = 0;
    00528   StatusCode status = findObject(fullPath, *pp_cast<DataObject>(&p));
    00529   if ( !status.isSuccess() )   {
    00530     int sep2 = fullPath.rfind(SEPARATOR);
    00531     if ( sep2 > 0 )   {
    00532       std::string relPath = fullPath.substr(0, sep2);
    00533       p = createDirectory(relPath);
    00534       if ( 0 != p )    {
    00535         p = new NTuple::Directory();
    00536         // Finally register the created N tuple with the store
    00537         status = registerObject(fullPath, p);
    00538         if ( status.isSuccess() )    {
    00539           // ...starting from the file entries
    00540           IConversionSvc* svc = getDataLoader(p->registry());
    00541           if ( 0 != svc )   {
    00542             IOpaqueAddress* pAddr = 0;
    00543             status = svc->createRep (p, pAddr);
    00544             if ( status.isSuccess() )   {
    00545               p->registry()->setAddress(pAddr);
    00546               status = svc->fillRepRefs (pAddr, p);
    00547               if ( status.isSuccess() )   {
    00548                 return p;
    00549               }
    00550             }
    00551           }
    00552           unregisterObject(p);
    00553         }
    00554         p->release();
    00555         p = 0;
    00556       }
    00557     }
    00558   }
    00559   try {
    00560     p = dynamic_cast<NTuple::Directory*>(p);
    00561     return p;
    00562   }
    00563   catch (...) {
    00564   }
    00565   return 0;
    00566 }

StatusCode NTupleSvc::create | ( | const CLID & | typ,
|  | const std::string & | title,
|  | NTuple::Tuple *& | refpTuple |
| ) |  |  | `[virtual]`

Create requested N tuple (Hide constructor).

Eventually allow loading through factory?

Implements INTupleSvc.

Definition at line 370 of file NTupleSvc.cpp.

    00370                                                                                                  {
    00371   NTuple::TupleImp* pTuple = 0;
    00372   StatusCode status = StatusCode::FAILURE;
    00373   if ( typ == CLID_ColumnWiseTuple )    {
    00374     pTuple = new NTuple::ColumnWiseTuple( title );
    00375   }
    00376   else if ( typ == CLID_RowWiseTuple )    {
    00377     pTuple = new NTuple::RowWiseTuple( title );
    00378   }
    00379   else    {
    00381   }
    00382   if ( 0 != pTuple )      {
    00383     pTuple->setTupleService(this);
    00384     status = StatusCode::SUCCESS;
    00385   }
    00386   refpTuple = pTuple;
    00387   return status;
    00388 }

NTuple::Tuple * NTupleSvc::book | ( | const std::string & | fullPath,
|  | const CLID & | type,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Book Ntuple and register it with the data store.

Implements INTupleSvc.

Definition at line 391 of file NTupleSvc.cpp.

    00391                                                                                                   {
    00392   DataObject* pObj = 0;
    00393   std::string path = fullPath;
    00394   MsgStream log(msgSvc(), name());
    00395   if ( path[0] != SEPARATOR )   {
    00396     path = m_rootName;
    00397     path += SEPARATOR;
    00398     path += fullPath;
    00399   }
    00400   StatusCode status = retrieveObject(path, pObj);
    00401   if ( !status.isSuccess() )    {
    00402     int sep = path.rfind(SEPARATOR);
    00403     if ( sep > 0 )    {
    00404       std::string p_path (path, 0, sep);
    00405       std::string o_path (path, sep, path.length());
    00406       DataObject* dir = createDirectory(p_path);
    00407       if ( 0 != dir )   {
    00408         NTuple::Tuple* tup = book( dir, o_path, type, title);
    00409         if ( 0 == tup )   {
    00410           log << MSG::ERROR << "Cannot book N-tuple " << path << " (Unknown reason)" << endmsg;
    00411         }
    00412         return tup;
    00413       }
    00414       log << MSG::ERROR << "Cannot book N-tuple " << path << " (Invalid parent directory)" << endmsg;
    00415       return 0;
    00416     }
    00417     log << MSG::ERROR << "Cannot book N-tuple " << path << " (Invalid path)" << endmsg;
    00418     return 0;
    00419   }
    00420   log << MSG::ERROR << "Cannot book N-tuple " << path << " (Exists already)" << endmsg;
    00421   return 0;
    00422 }

NTuple::Tuple * NTupleSvc::book | ( | const std::string & | dirPath,
|  | const std::string & | relPath,
|  | const CLID & | type,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Book Ntuple and register it with the data store.

Implements INTupleSvc.

Definition at line 425 of file NTupleSvc.cpp.

    00425                                                                                                                            {
    00426   std::string full = dirPath;
    00427   if (relPath[0] != SEPARATOR) full += SEPARATOR;
    00428   full += relPath;
    00429   return book(full, type, title);
    00430 }

NTuple::Tuple * NTupleSvc::book | ( | const std::string & | dirPath,
|  | long | id,
|  | const CLID & | type,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Book Ntuple and register it with the data store.

Implements INTupleSvc.

Definition at line 433 of file NTupleSvc.cpp.

    00433                                                                                                           {
    00434   char txt[32];
    00435   return book( dirPath, _itoa(id, txt, 10), type, title);
    00436 }

NTuple::Tuple * NTupleSvc::book | ( | DataObject * | pParent,
|  | const std::string & | relPath,
|  | const CLID & | type,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Book Ntuple and register it with the data store.

Implements INTupleSvc.

Definition at line 439 of file NTupleSvc.cpp.

    00439                                                                                                                       {
    00440   NTuple::Tuple* pObj = 0;
    00441   // Check if object is already present
    00442   StatusCode status = findObject(pParent, relPath, *pp_cast<DataObject>(&pObj));
    00443   // No ? Then create it!
    00444   if ( !status.isSuccess() )    {
    00445     status = create( type, title, pObj);
    00446     if ( status.isSuccess() )   {
    00447       // Finally register the created N tuple with the store
    00448       status = registerObject(pParent, relPath, pObj);
    00449       if ( status.isSuccess() )    {
    00450         return pObj;
    00451       }
    00452       pObj->release();
    00453     }
    00454   }
    00455   return 0;
    00456 }

NTuple::Tuple * NTupleSvc::book | ( | DataObject * | pParent,
|  | long | id,
|  | const CLID & | type,
|  | const std::string & | title |
| ) |  |  | `[virtual]`

Book Ntuple and register it with the data store.

Implements INTupleSvc.

Definition at line 459 of file NTupleSvc.cpp.

    00462                                                          {
    00463   char txt[32];
    00464   return book( pParent, ::_itoa(id, txt,10), type, title);
    00465 }

NTuple::Tuple * NTupleSvc::access | ( | const std::string & | fullPath,
|  | const std::string & | filename |
| ) |  |  | `[virtual]`

Access N tuple on disk.

Implements INTupleSvc.

Definition at line 569 of file NTupleSvc.cpp.

    00569                                                                   {
    00570   MsgStream log ( msgSvc(), name() );
    00571   return 0;
    00572 }

StatusCode NTupleSvc::save | ( | const std::string & | fullPath | ) | `[virtual]`

Save N tuple to disk. Must be called in order to close the ntuple file properly.

Implements INTupleSvc.

Definition at line 575 of file NTupleSvc.cpp.

    00575                                                      {
    00576   MsgStream log ( msgSvc(), name() );
    00577   NTuple::Tuple* pObj = 0;
    00578   StatusCode status = findObject(fullPath, *pp_cast<DataObject>(&pObj));  // Check if object is  present
    00579   if ( status.isSuccess() )   {
    00580     return save ( pObj );
    00581   }
    00582   return INVALID_OBJ_PATH;
    00583 }

StatusCode NTupleSvc::save | ( | NTuple::Tuple * | tuple | ) | `[virtual]`

Save N tuple to disk. Must be called in order to close the ntuple file properly.

Implements INTupleSvc.

Definition at line 586 of file NTupleSvc.cpp.

    00586                                                 {
    00587   NTuple::TupleImp* tuple = (NTuple::TupleImp*)n_tuple;
    00588   if ( 0 != tuple )   {
    00589     try   {
    00590       IConversionSvc* pSvc = tuple->conversionService();
    00591       IRegistry*      pReg = tuple->registry();
    00592       if ( 0 != pSvc && 0 != pReg )    {
    00593         IOpaqueAddress* pAddr = pReg->address();
    00594         StatusCode status = pSvc->updateRep(pAddr, n_tuple);
    00595         if ( status.isSuccess() )   {
    00596           status = pSvc->updateRepRefs(pAddr, n_tuple);
    00597         }
    00598         return status;
    00599       }
    00600       return IDataProviderSvc::NO_DATA_LOADER;
    00601     }
    00602     catch(...)    {
    00603     }
    00604   }
    00605   return INVALID_OBJECT;
    00606 }

StatusCode NTupleSvc::save | ( | DataObject * | pParent,
|  | const std::string & | relPath |
| ) |  |  | `[virtual]`

Save N tuple to disk. Must be called in order to close the ntuple file properly.

Implements INTupleSvc.

Definition at line 609 of file NTupleSvc.cpp.

    00609                                                                          {
    00610   NTuple::Tuple* pObj = 0;
    00611   StatusCode status = findObject(pParent, relPath, *pp_cast<DataObject>(&pObj));  // Check if object is  present
    00612   if ( status.isSuccess() )   {
    00613     return save ( pObj );
    00614   }
    00615   return INVALID_OBJ_PATH;
    00616 }

StatusCode NTupleSvc::writeRecord | ( | NTuple::Tuple * | tuple | ) | `[virtual]`

Write single record to N tuple.

Implements INTupleSvc.

Definition at line 619 of file NTupleSvc.cpp.

    00619                                                           {
    00620   NTuple::TupleImp* tuple = (NTuple::TupleImp*)n_tuple;
    00621   if ( 0 != tuple )   {
    00622     try   {
    00623       IConversionSvc* pSvc = tuple->conversionService();
    00624       if ( 0 == pSvc )    {
    00625         pSvc = getDataLoader(n_tuple->registry());
    00626         tuple->setConversionService(pSvc);
    00627       }
    00628       if ( 0 != pSvc )    {
    00629         IRegistry* pReg = n_tuple->registry();
    00630         IOpaqueAddress* pAddr = pReg->address();
    00631         StatusCode status = pSvc->createRep(n_tuple, pAddr);
    00632         if ( status.isSuccess() )   {
    00633           pReg->setAddress(pAddr);
    00634           status = pSvc->fillRepRefs(pAddr, n_tuple);
    00635         }
    00636         return status;
    00637       }
    00638       return IDataProviderSvc::NO_DATA_LOADER;
    00639     }
    00640     catch(...)    {
    00641     }
    00642   }
    00643   return INVALID_OBJECT;
    00644 }

StatusCode NTupleSvc::writeRecord | ( | const std::string & | fullPath | ) | `[virtual]`

Write single record to N tuple.

Implements INTupleSvc.

Definition at line 647 of file NTupleSvc.cpp.

    00647                                                               {
    00648   NTuple::Tuple* pObj = 0;
    00649   StatusCode status = findObject(fullPath, *pp_cast<DataObject>(&pObj));  // Check if object is  present
    00650   if ( status.isSuccess() )   {
    00651     return writeRecord ( pObj );
    00652   }
    00653   return INVALID_OBJ_PATH;
    00654 }

StatusCode NTupleSvc::writeRecord | ( | DataObject * | pParent,
|  | const std::string & | relPath |
| ) |  |  | `[virtual]`

Write single record to N tuple.

Implements INTupleSvc.

Definition at line 657 of file NTupleSvc.cpp.

    00657                                                                                   {
    00658   NTuple::Tuple* pObj = 0;
    00659   StatusCode status = findObject(pParent, relPath, *pp_cast<DataObject>(&pObj));  // Check if object is  present
    00660   if ( status.isSuccess() )   {
    00661     return writeRecord ( pObj );
    00662   }
    00663   return INVALID_OBJ_PATH;
    00664 }

StatusCode NTupleSvc::readRecord | ( | NTuple::Tuple * | tuple | ) | `[virtual]`

Read single record from N tuple.

Implements INTupleSvc.

Definition at line 667 of file NTupleSvc.cpp.

    00667                                                         {
    00668   StatusCode status = INVALID_OBJECT;
    00669   NTuple::TupleImp* tuple = (NTuple::TupleImp*)n_tuple;
    00670   if ( 0 != tuple )   {
    00671     try   {
    00672       IConversionSvc* pSvc = tuple->conversionService();
    00673       if ( 0 == pSvc )    {
    00674         pSvc = getDataLoader(n_tuple->registry());
    00675         tuple->setConversionService(pSvc);
    00676       }
    00677       if ( 0 != pSvc )    {
    00678         IRegistry*      pReg  = n_tuple->registry();
    00679         IOpaqueAddress* pAddr = pReg->address();
    00680         status = pSvc->updateObj(pAddr, n_tuple);
    00681         if ( status.isSuccess() )   {
    00682           status = pSvc->updateObjRefs(pAddr, n_tuple);
    00683         }
    00684         return status;
    00685       }
    00686       status = IDataProviderSvc::NO_DATA_LOADER;
    00687     }
    00688     catch(...)    {
    00689       status = INVALID_OBJECT;
    00690     }
    00691   }
    00692   return status;
    00693 }

StatusCode NTupleSvc::readRecord | ( | const std::string & | fullPath | ) | `[virtual]`

Read single record from N tuple.

Implements INTupleSvc.

Definition at line 696 of file NTupleSvc.cpp.

    00696                                                            {
    00697   NTuple::Tuple* pObj = 0;
    00698   StatusCode status = findObject(fullPath, *pp_cast<DataObject>(&pObj));  // Check if object is  present
    00699   if ( status.isSuccess() )   {
    00700     return readRecord ( pObj );
    00701   }
    00702   return INVALID_OBJ_PATH;
    00703 }

StatusCode NTupleSvc::readRecord | ( | DataObject * | pParent,
|  | const std::string & | relPath |
| ) |  |  | `[virtual]`

Read single record from N tuple.

Implements INTupleSvc.

Definition at line 706 of file NTupleSvc.cpp.

    00706                                                                                {
    00707   NTuple::Tuple* pObj = 0;
    00708   StatusCode status = findObject(pParent, relPath, *pp_cast<DataObject>(&pObj));  // Check if object is  present
    00709   if ( status.isSuccess() )   {
    00710     return readRecord ( pObj );
    00711   }
    00712   return INVALID_OBJ_PATH;
    00713 }

bool NTupleSvc::isConnected | ( | const std::string & | identifier | ) | const`[virtual]`

Check if a datasource is connected.

Implements IDataSourceMgr.

Definition at line 99 of file NTupleSvc.cpp.

    00099                                                                 {
    00100   Connections::const_iterator i = m_connections.find(identifier);
    00101   return !(i==m_connections.end());
    00102 }

StatusCode NTupleSvc::connect | ( | const std::string & | ident | ) | `[virtual]`

Add file to list I/O list.

Implements IDataSourceMgr.

Definition at line 229 of file NTupleSvc.cpp.

    00229                                                        {
    00230   std::string logName;
    00231   return connect(ident, logName);
    00232 }

StatusCode NTupleSvc::connect | ( | const std::string & | ident,
|  | std::string & | logname |
| ) |  |  | `[virtual]`

Add file to list I/O list.

Implements IDataSourceMgr.

Reimplemented in TagCollectionSvc.

Definition at line 234 of file NTupleSvc.cpp.

    00234                                                                            {
    00235   MsgStream log ( msgSvc(), name() );
    00236   DataObject* pO = 0;
    00237   StatusCode status = findObject(m_rootName, pO);
    00238   if ( status.isSuccess() )   {
    00239     char typ=0;
    00240     Tokenizer tok(true);
    00241     std::vector<Prop> props;
    00242     long loc = ident.find(" ");
    00243     std::string filename, auth, svc = "", db_typ = "";
    00244     logname = ident.substr(0,loc);
    00245     tok.analyse(ident.substr(loc+1,ident.length()), " ", "", "", "=", "'", "'");
    00246     for ( Tokenizer::Items::iterator i = tok.items().begin(); i != tok.items().end(); ++i)    {
    00247       const std::string& tag = (*i).tag();
    00248       switch( ::toupper(tag[0]) )   {
    00249       case 'A':
    00250         break;
    00251       case 'F':   // FILE='<file name>'
    00252       case 'D':   // DATAFILE='<file name>'
    00253         filename = (*i).value();
    00254         break;
    00255       case 'O':   // OPT='<NEW<CREATE,WRITE>, UPDATE, READ>'
    00256         switch( ::toupper((*i).value()[0]) )   {
    00257         case 'C':
    00258         case 'N':
    00259         case 'W':
    00260           typ = 'N';
    00261           break;
    00262         case 'U':
    00263           typ = 'U';
    00264           break;
    00265         case 'O':
    00266         case 'R':
    00267           typ = 'O';
    00268           break;
    00269         default:
    00270           typ = 0;
    00271           break;
    00272         }
    00273         break;
    00274       case 'T':   // TYP='<HBOOK,ROOT,OBJY,...>'
    00275         db_typ = (*i).value();
    00276         break;
    00277       default:
    00278         props.push_back( Prop((*i).tag(), (*i).value()));
    00279         break;
    00280       }
    00281     }
    00282     if ( 0 != typ )    {
    00283       IConversionSvc* pSvc = 0;
    00284       status = createService(name()+'.'+logname, db_typ, props, pSvc);
    00285       if ( status.isSuccess() )   {
    00286         status = attachTuple(filename, logname, typ, pSvc->repSvcType());
    00287         if ( status.isSuccess() )    {
    00288           m_connections.insert(Connections::value_type(m_rootName+'/'+logname,Connection(pSvc)));
    00289           return StatusCode::SUCCESS;
    00290         }
    00291       }
    00292     }
    00293   }
    00294   log << MSG::ERROR << "Cannot add " << ident << " invalid filename!" << endmsg;
    00295   return StatusCode::FAILURE;
    00296 }

StatusCode NTupleSvc::disconnect | ( | const std::string & | nam | ) | `[virtual]`

Close open connection.

Implements IDataSourceMgr.

Definition at line 189 of file NTupleSvc.cpp.

    00189                                                           {
    00190   Connections::iterator i = m_connections.find(nam);
    00191   if ( i != m_connections.end() )    {
    00192     releaseConnection((*i).second);
    00193     m_connections.erase(i);
    00194     return StatusCode::SUCCESS;
    00195   }
    00196   return StatusCode::FAILURE;
    00197 }

StatusCode NTupleSvc::disconnectAll | ( |  | ) | `[virtual]`

Close all open connections.

Implements IDataSourceMgr.

Definition at line 200 of file NTupleSvc.cpp.

    00200                                          {
    00201   for(Connections::iterator i = m_connections.begin(); i != m_connections.end(); ++i) {
    00202     releaseConnection((*i).second);
    00203   }
    00204   m_connections.erase(m_connections.begin(), m_connections.end());
    00205   return StatusCode::SUCCESS;
    00206 }

StatusCode NTupleSvc::createService | ( | const std::string & | nam,
|  | const std::string & | typ,
|  | const std::vector< Prop > & | props,
|  | IConversionSvc *& | pSvc |
| ) |  |  | `[protected]`

Create conversion service.

CGL: set the storage type

Definition at line 298 of file NTupleSvc.cpp.

    00302 {
    00303   MsgStream log ( msgSvc(), name() );
    00305   // Get the value of the Stat persistancy mechanism from the AppMgr
    00306   IProperty*   appPropMgr = 0;
    00307   StatusCode sts = serviceLocator()->queryInterface(IID_IProperty, pp_cast<void>(&appPropMgr) );
    00308   if( !sts.isSuccess() ) {
    00309    // Report an error and return the FAILURE status code
    00310    log << MSG::ERROR << "Could not get PropMgr" << endmsg;
    00311    return sts;
    00312   }
    00313
    00314   StringProperty sp("HistogramPersistency","");
    00315   sts = appPropMgr->getProperty( &sp );
    00316   if ( !sts.isSuccess() ) {
    00317    log << MSG::ERROR << "Could not get NTuple Persistency format"
    00318        << " from ApplicationMgr properties" << endmsg;
    00319    return sts;
    00320   }
    00321
    00322   long storage_typ = TEST_StorageType;
    00323   if ( sp.value() == "HBOOK" ) {
    00324     storage_typ = HBOOK_StorageType;
    00325   }
    00326   else if ( sp.value() == "ROOT" ) {
    00327     storage_typ = ROOT_StorageType;
    00328   }
    00329   else {
    00330     appPropMgr->release();
    00331     log << MSG::ERROR << "Unknown NTuple Persistency format: " << sp.value() << endmsg;
    00332     return StatusCode::FAILURE;
    00333   }
    00334   // Clean up
    00335   appPropMgr->release();
    00336
    00337   if ( typ.length() > 0 && typ != sp.value() )    {
    00338     log << MSG::WARNING << "NTuple persistency type is "
    00339         << sp.value() << "." << endmsg
    00340         << "Type given by job option "
    00341         << "NTupleSvc.Input/Output ignored!" << endmsg;
    00342   }
    00343
    00344   //      log << MSG::DEBUG << "storage type: " << m_storageType << endmsg;
    00345
    00346   // FIXME: (MCl) why NTupleSvc has to directly create a ConversionSvc?
    00347   IService* pService = 0;
    00348   IInterface* iface = new ConversionSvc(name()+"Conversions", serviceLocator(), storage_typ);
    00349   StatusCode status = iface->queryInterface(IID_IService, pp_cast<void>(&pService));
    00350   if ( status.isSuccess() )   {
    00351     status = iface->queryInterface(IID_IConversionSvc, pp_cast<void>(&pSvc));
    00352     if ( !status.isSuccess() )   {
    00353       pService->release();
    00354       return status;
    00355     }
    00356   }
    00357   status = pService->sysInitialize();
    00358   if ( !status.isSuccess() )    {
    00359     return status;
    00360   }
    00361   pService->release();
    00362   status = pSvc->setDataProvider(this);
    00363   if ( !status.isSuccess() )    {
    00364     return status;
    00365   }
    00366   return status;
    00367 }

void NTupleSvc::releaseConnection | ( | Connection & | c | ) | `[protected]`

Finalize single service.

Definition at line 179 of file NTupleSvc.cpp.

    00179                                                 {
    00180   SmartIF<IService> isvc(IID_IService, c.service );
    00181   if ( isvc.isValid( ) )   {
    00182     isvc->finalize().ignore();
    00183   }
    00184   c.service->release();
    00185   c.service = 0;
    00186 }

StatusCode NTupleSvc::attachTuple | ( | const std::string & | filename,
|  | const std::string & | logname,
|  | const char | typ,
|  | const long | t |
| ) |  |  | `[protected]`

Attach output/input file.

Definition at line 502 of file NTupleSvc.cpp.

    00502                                                                                                                      {
    00503   MsgStream log(msgSvc(), name());
    00504   DataObject* p;
    00505   // First get the root object
    00506   StatusCode status = retrieveObject(m_rootName, p);
    00507   if ( status.isSuccess() )   {
    00508     // Now add the registry entry to the store
    00509     std::string entryname = m_rootName;
    00510     entryname += '/';
    00511     entryname += logname;
    00512     GenericAddress* pA =
    00513        new GenericAddress(t, CLID_NTupleFile, filename, entryname, 0, typ);
    00514     status = registerAddress(p, logname, pA);
    00515     if ( status.isSuccess() )    {
    00516       log << MSG::INFO << "Added stream file:" << filename << " as " << logname << endmsg;
    00517       return status;
    00518     }
    00519     pA->release();
    00520   }
    00521   log << MSG::ERROR << "Cannot add file:" << filename << " as " << logname << endmsg;
    00522   return status;
    00523 }

StatusCode NTupleSvc::updateDirectories | ( |  | ) | `[protected]`

Update directory data.

Definition at line 119 of file NTupleSvc.cpp.

    00119                                           {
    00120   typedef std::vector<IRegistry*> Leaves;
    00121   long need_update = 0;
    00122   DataObject* pO = 0;
    00123   StatusCode iret = findObject(m_rootName, pO);
    00124   MsgStream log ( msgSvc(), name() );
    00125   //  log << MSG::DEBUG << "in finalize()" << endmsg;
    00126   if ( iret.isSuccess() )   {
    00127     Leaves leaves;
    00128     iret = objectLeaves(pO, leaves);
    00129     if ( iret.isSuccess() )    {
    00130       // Only traverse the tree below the files
    00131       for ( Leaves::iterator d = leaves.begin(); d != leaves.end(); d++ )    {
    00132         if ( (*d)->object() )   {
    00133           IOpaqueAddress* pA = (*d)->address();
    00134           if ( pA )   {
    00135             unsigned long typ = pA->ipar()[1];
    00136             if ( typ == 'R' || typ == 'N' || typ == 'U' )   {
    00137               // ...starting from the file entries: first save the directories/ntuples
    00138               IConversionSvc* svc = getDataLoader(*d);
    00139               if ( 0 != svc )   {
    00140                 StatusCode status;
    00141                 DataSelectionAgent agent;
    00142                 IDataSelector*     sel = agent.selectedObjects();
    00143                 traverseSubTree ( (*d)->object(), &agent ).ignore();
    00144                 for(int i = sel->size()-1; i >= 0; i-- )    {
    00145                   DataObject* o = (*sel)[i];
    00146                   IRegistry*  r = o->registry();
    00147                   status = svc->updateRep(r->address(), o);
    00148                   if ( !status.isSuccess() )    {
    00149                     iret = status;
    00150                   }
    00151                 }
    00152                 for(int j = sel->size()-1; j >= 0; j-- )    {
    00153                   DataObject* o = (*sel)[j];
    00154                   IRegistry*  r = o->registry();
    00155                   status = svc->updateRepRefs(r->address(), o);
    00156                   if ( !status.isSuccess() )    {
    00157                     iret = status;
    00158                   }
    00159                 }
    00160                 if ( iret.isSuccess() ) need_update += sel->size();
    00161               }
    00162             }
    00163           }
    00164         }
    00165       }
    00166     }
    00167   }
    00168   if ( !iret.isSuccess() )    {
    00169     log << MSG::ERROR << "ERROR while saving NTuples" << endmsg;
    00170     return iret;
    00171   }
    00172   else if ( need_update > 0 )    {
    00173     log << MSG::INFO << "NTuples saved successfully" << endmsg;
    00174   }
    00175   return iret;
    00176 }

## Friends And Related Function Documentation

friend class SvcFactory< NTupleSvc >`[friend]`

Definition at line 38 of file NTupleSvc.h.

## Member Data Documentation

DBaseEntries NTupleSvc::m_output`[protected]`

Output streams.

Definition at line 130 of file NTupleSvc.h.

DBaseEntries NTupleSvc::m_input`[protected]`

Input streams.

Definition at line 132 of file NTupleSvc.h.

Connections NTupleSvc::m_connections`[protected]`

Container of connection points.

Definition at line 134 of file NTupleSvc.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/GaudiSvc/src/NTupleSvc/NTupleSvc.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/GaudiSvc/src/NTupleSvc/NTupleSvc.cpp