| # Gaudi Framework, version v21r8 |

Home |  | Generated: 17 Mar 2010

# AIDATupleSvc Class Reference

AIDATupleSvc class definition. More...

`#include <AIDATupleSvc/AIDATupleSvc.h>`

Inheritance diagram for AIDATupleSvc:

[legend]
Collaboration diagram for AIDATupleSvc:

[legend]

List of all members.

## 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 AIDA::ITuple * | book (const std::string &fullPath, const std::string &title, const std::string &columns)
| Create AIDATuple in the data store.
virtual AIDA::ITuple * | book (const std::string &parentPath, const std::string &objPath, const std::string &title, const std::string &columns)
| Create AIDATuple in the data store.
virtual AIDA::ITuple * | book (const std::string &parentPath, int tupleID, const std::string &title, const std::string &columns)
| Create AIDATuple in the data store.
virtual AIDA::ITuple * | book (DataObject *pParent, const std::string &objPath, const std::string &title, const std::string &columns)
| Create AIDATuple in the data store.
virtual AIDA::ITuple * | book (DataObject *pParent, int tupleID, const std::string &title, const std::string &columns)
| Create AIDATuple in the data store.
virtual StatusCode | registerObject (const std::string &dirPath, const std::string &objPath, AIDA::ITuple *tObj)
| Register a tuple in the data store.
virtual StatusCode | registerObject (DataObject *pParent, const std::string &objPath, AIDA::ITuple *tObj)
| Register a tuple in the data store.
virtual StatusCode | unregisterObject (AIDA::ITuple *tObj)
| Unregister a tuple in the data store.
virtual StatusCode | unregisterObject (AIDA::ITuple *tObj, const std::string &objPath)
| Unregister a tuple in the data store.
virtual StatusCode | retrieveObject (const std::string &fullPath, AIDA::ITuple *&tObj)
| Retrieve a tuple from the data store.
virtual StatusCode | retrieveObject (const std::string &parentPath, const std::string &objPath, AIDA::ITuple *&tObj)
| Retrieve a tuple from the data store.
virtual StatusCode | retrieveObject (DataObject *pParent, const std::string &objPath, AIDA::ITuple *&tObj)
| Retrieve a tuple from the data store.
virtual StatusCode | findObject (const std::string &fullPath, AIDA::ITuple *&tObj)
| Locate a tuple in the data store.
virtual StatusCode | findObject (IRegistry *pDirectory, const std::string &path, AIDA::ITuple *&tObj)
| Locate a tuple in the data store.
virtual StatusCode | findObject (const std::string &parentPath, const std::string &objPath, AIDA::ITuple *&tObj)
| Locate a tuple in the data store.
virtual StatusCode | findObject (DataObject *parentObj, const std::string &objPath, AIDA::ITuple *&tObj)
| Locate a tuple in the data store.
virtual void | setCriteria (AIDA::ITuple *&tObj, const std::string &criteria)
| Set a selection criteria for reading, as a filter.
virtual StatusCode | myTest ()
| Dummy method to test the service.
## Protected Types
typedef std::vector< std::string > | DBaseEntries
| Typedefs for connections.
typedef std::map< std::string, pi_aida::Proxy_Store * > | Connections
## Protected Member Functions
| AIDATupleSvc (const std::string &name, ISvcLocator *svc)
| Standard constructor.
virtual | ~AIDATupleSvc ()
| Standard destructor.
void | parsePath (const std::string &fullPath, std::string &dirPath, std::string &objPath, std::string &storePath, std::string &storeObj)
| Split full path into its components.
virtual DataObject * | createPath (const std::string &newPath)
| Create all directories recursively in a given full path.
virtual DataObject * | createDirectory (const std::string &parentDir, const std::string &subDir)
| Create a sub-directory in a given directory.
StatusCode | connect (const std::string &ident, int mode)
| Add file to I/O list.
StatusCode | closeAIDAStores ()
| Disconnect all the stores in the I/O list.
## Protected Attributes
DBaseEntries | m_output
| Output streams.
DBaseEntries | m_input
| Input streams.
Connections | m_connections
| Container of connection points.
## Friends
class | SvcFactory< AIDATupleSvc >
| Allow SvcFactory to instantiate the service.

## Detailed Description

AIDATupleSvc class definition.

Author:
  Manuel Domenech Saavedra

Date:
  2005-05-23

Definition at line 28 of file AIDATupleSvc.h.

## Member Typedef Documentation

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

Typedefs for connections.

Definition at line 36 of file AIDATupleSvc.h.

typedef std::map<std::string, pi_aida::Proxy_Store*> AIDATupleSvc::Connections`[protected]`

Definition at line 37 of file AIDATupleSvc.h.

## Constructor & Destructor Documentation

AIDATupleSvc::AIDATupleSvc | ( | const std::string & | name,
|  | ISvcLocator * | svc |
| ) |  |  | `[protected]`

Standard constructor.

Definition at line 554 of file AIDATupleSvc.cpp.

    00555   : DataSvc( name, svc )
    00556 {
    00557   // Properties can be declared here
    00558   m_rootName = "/NTUPLES";
    00559   m_rootCLID = CLID_DataObject;
    00560   declareProperty("Input",  m_input);
    00561   declareProperty("Output", m_output);
    00562 }

AIDATupleSvc::~AIDATupleSvc | ( |  | ) | `[protected, virtual]`

Standard destructor.

Definition at line 565 of file AIDATupleSvc.cpp.

    00566 {
    00567   clearStore().ignore();
    00568 }

## Member Function Documentation

void AIDATupleSvc::parsePath | ( | const std::string & | fullPath,
|  | std::string & | dirPath,
|  | std::string & | objPath,
|  | std::string & | storePath,
|  | std::string & | storeObj |
| ) |  |  | `[protected]`

Split full path into its components.

Parameters:

  | fullPath | [IN]: Full path of the store
  | dirPath | [OUT]: Path in the transient store to the tuple's parent dir
  | objPath | [OUT]: Name of the tuple in the transient store starting with '/'
  | storePath | [OUT]: Path in the transient store of the tuple store
  | storeObj | [OUT]: Full name of the tuple inside the tuple store, including parent dirs.File is a flat structure.

Definition at line 460 of file AIDATupleSvc.cpp.

    00465 {
    00466   std::string tmpPath = fullPath;
    00467   if ( tmpPath[0] != SEPARATOR ) {
    00468     // Insert the top level name of the store (/NTUPLES)
    00469     tmpPath.insert(tmpPath.begin(), SEPARATOR);
    00470     tmpPath.insert(tmpPath.begin(), m_rootName.begin(), m_rootName.end());
    00471   }
    00472   // Remove trailing "/" from tmpPath if it exists
    00473   if (tmpPath.rfind(SEPARATOR) == tmpPath.length()-1) {
    00474     tmpPath.erase(tmpPath.rfind(SEPARATOR),1);
    00475   }
    00476   int sep   = tmpPath.rfind(SEPARATOR);
    00477   dirPath   = tmpPath.substr(0, sep);
    00478   objPath   = tmpPath.substr(sep, tmpPath.length()-sep );
    00479   sep       = tmpPath.find(SEPARATOR, m_rootName.length()+1);
    00480   storePath = tmpPath.substr(0, sep);
    00481   storeObj  = tmpPath.substr(sep+1, tmpPath.length()-sep );
    00482 }

DataObject * AIDATupleSvc::createPath | ( | const std::string & | newPath | ) | `[protected, virtual]`

Create all directories recursively in a given full path.

Parameters:

  | newPath | [IN]: Path until the tuple in the transient store returns pointer to DataObject corresponding to the top level directory of the path

Implements IAIDATupleSvc.

Definition at line 485 of file AIDATupleSvc.cpp.

    00486 {
    00487   std::string tmpPath = newPath;
    00488   if ( tmpPath[0] != SEPARATOR )    {
    00489     tmpPath.insert(tmpPath.begin(), SEPARATOR);
    00490     tmpPath.insert(tmpPath.begin(), m_rootName.begin(), m_rootName.end());
    00491   }
    00492   // Remove trailing "/" from newPath if it exists
    00493   if (tmpPath.rfind(SEPARATOR) == tmpPath.length()-1) {
    00494     tmpPath.erase(tmpPath.rfind(SEPARATOR),1);
    00495   }
    00496
    00497   DataObject* pObject = 0;
    00498   StatusCode sc = DataSvc::findObject( tmpPath, pObject );
    00499   if( sc.isSuccess() ) {
    00500     return pObject;
    00501   }
    00502
    00503   int sep = tmpPath.rfind(SEPARATOR);
    00504   std::string rest( tmpPath, sep+1, tmpPath.length()-sep );
    00505   std::string subPath( tmpPath, 0, sep );
    00506   if( 0 != sep ) {
    00507     createPath( subPath );
    00508   }
    00509   else {
    00510     MsgStream log( msgSvc(), name() );
    00511     log << MSG::ERROR << "Unable to create the tuple path" << endmsg;
    00512     return 0;
    00513   }
    00514
    00515   pObject = createDirectory( subPath, rest );
    00516   return pObject;
    00517 }

DataObject * AIDATupleSvc::createDirectory | ( | const std::string & | parentDir,
|  | const std::string & | subDir |
| ) |  |  | `[protected, virtual]`

Create a sub-directory in a given directory.

Parameters:

  | parentDir | [IN]: Path to the parent directory, already existing
  | subDir | [IN]: Name of the subdirectory returns pointer to DataObject corresponding to the new subdirectory

Implements IAIDATupleSvc.

Definition at line 520 of file AIDATupleSvc.cpp.

    00522 {
    00523
    00524   StatusCode   status    = StatusCode::FAILURE;
    00525   DataObject*  directory = new DataObject();
    00526
    00527   if ( 0 != directory )  {
    00528     DataObject* pnode;
    00529     status = DataSvc::findObject( parentDir, pnode );
    00530     if( status.isSuccess() ) {
    00531       status = DataSvc::registerObject( pnode, subDir, directory );
    00532       if ( !status.isSuccess() )   {
    00533         MsgStream log( msgSvc(), name() );
    00534         log << MSG::ERROR << "Unable to create the directory: "
    00535                           << parentDir << "/" << subDir << endmsg;
    00536         delete directory;
    00537         return 0;
    00538       }
    00539     }
    00540     else {
    00541       MsgStream log( msgSvc(), name() );
    00542       log << MSG::ERROR << "Unable to create the directory: "
    00543                         << parentDir << "/" << subDir << endmsg;
    00544       delete directory;
    00545       return 0;
    00546     }
    00547   }
    00548   return directory;
    00549 }

StatusCode AIDATupleSvc::connect | ( | const std::string & | ident,
|  | int | mode |
| ) |  |  | `[protected]`

Add file to I/O list.

Parameters:

  | ident | [IN]: String with all the options from the job options file
  | mode | [IN]: Flag indicating INPUT or OUTPUT stream returns StatusCode indicating the success of the operation

Definition at line 341 of file AIDATupleSvc.cpp.

    00343 {
    00344   MsgStream log ( msgSvc(), name() );
    00345   DataObject* p0 = 0;
    00346   StatusCode status = DataSvc::findObject(m_rootName, p0);
    00347   if (status.isSuccess() ) {
    00348     Tokenizer tok(true);
    00349     long loc = ident.find(" ");
    00350     int open_mode = 0; // Default is AUTO mode
    00351     std::string file, typ = "", tmp_typ = "", opt = "";
    00352     std::string logname = ident.substr(0,loc);
    00353     tok.analyse(ident.substr(loc+1,ident.length()), " ", "", "", "=", "'", "'");
    00354     for ( Tokenizer::Items::iterator i = tok.items().begin(); i != tok.items().end(); i++) {
    00355       const std::string& tag = (*i).tag();
    00356       switch( ::toupper(tag[0]) ) {
    00357       case 'F':   // FILE='<file name>'
    00358       case 'D':   // DATAFILE='<file name>'
    00359         file = (*i).value();
    00360         break;
    00361       case 'O':   // OPT='<AUTO, OVERWRITE, CREATE, READONLY, UPDATE>'
    00362         switch( ::toupper((*i).value()[0]) ) {
    00363         case 'A': // AUTO
    00364           if( mode == 0 )
    00365             open_mode = 3; // READONLY
    00366           else
    00367             open_mode = 1; // CREATE
    00368           break;
    00369         case 'O': // OVERWRITE
    00370           if( mode == 0 )
    00371             throw GaudiException("Input file " + file + " with improper option (OVERWRITE)", "AIDATupleSvc", StatusCode::FAILURE);
    00372           else
    00373             open_mode = 1;
    00374           break;
    00375         case 'C': // CREATE
    00376           if( mode == 0 )
    00377             throw GaudiException("Input file " + file + " with improper option (CREATE)", "AIDATupleSvc", StatusCode::FAILURE);
    00378           else
    00379             open_mode = 2;
    00380           break;
    00381         case 'R': // READONLY
    00382           if( mode == 1 )
    00383             throw GaudiException("Output file " + file + " with improper option (READONLY)", "AIDATupleSvc", StatusCode::FAILURE);
    00384           else
    00385             open_mode = 3;
    00386           break;
    00387         case 'U': // UPDATE
    00388           if( mode == 0 )
    00389             throw GaudiException("Input file " + file + " with improper option (UPDATE)", "AIDATupleSvc", StatusCode::FAILURE);
    00390           else
    00391             open_mode = 4;
    00392           break;
    00393         }
    00394         break;
    00395       case 'T':   // TYP='<HBOOK,ROOT,XML,POOL>'
    00396         typ = (*i).value();
    00397         break;
    00398       default:
    00399         opt += (*i).tag() + "=" + (*i).value() + ",";
    00400         break;
    00401       }
    00402     }
    00403
    00404     // Check if persistency type has been specified at job options
    00405     if (typ == "") {
    00406       log << MSG::WARNING << "File type not specified at job options."
    00407           << " Setting 'HistogramPersistency' type as default"
    00408           << endmsg;
    00409       // Get the value of the Stat persistancy mechanism from the AppMgr
    00410       IProperty*   appPropMgr = 0;
    00411       status = serviceLocator()->queryInterface(IProperty::interfaceID(),(void **)&appPropMgr );
    00412       if( !status.isSuccess() ) {
    00413         // Report an error and return the FAILURE status code
    00414         log << MSG::ERROR << "Could not get PropMgr" << endmsg;
    00415         return status;
    00416       }
    00417       StringProperty sp("HistogramPersistency","");
    00418       status = appPropMgr->getProperty( &sp );
    00419       if ( !status.isSuccess() ) {
    00420         log << MSG::ERROR << "Could not get NTuple Persistency format"
    00421             << " from ApplicationMgr properties" << endmsg;
    00422         return status;
    00423       }
    00424       tmp_typ = sp.value();
    00425       if (tmp_typ == "ROOT" || tmp_typ == "XML" || tmp_typ == "HBOOK" || tmp_typ == "POOL")
    00426         typ = tmp_typ;
    00427       else {
    00428         log << MSG::ERROR << "Unknown persistency format at 'HistogramPersistency' option"
    00429             << endmsg;
    00430         return StatusCode::FAILURE;
    00431       }
    00432     }
    00433
    00434     // Create a new pi_aida::Proxy_Store
    00435     pi_aida::Proxy_Store* storePtr = new pi_aida::Proxy_Store( file, typ, open_mode, opt );
    00436     m_connections.insert(Connections::value_type(m_rootName+'/'+logname, storePtr));
    00437
    00438     return StatusCode::SUCCESS;
    00439   }
    00440   log << MSG::ERROR << "Cannot add " << ident << " invalid filename!" << endmsg;
    00441   return StatusCode::FAILURE;
    00442
    00443 }

StatusCode AIDATupleSvc::closeAIDAStores | ( |  | ) | `[protected]`

Disconnect all the stores in the I/O list.

Definition at line 446 of file AIDATupleSvc.cpp.

    00447 {
    00448    for( Connections::iterator k = m_connections.begin(); k != m_connections.end(); k++ ) {
    00449      if ( (*k).second->isOpen()) {
    00450        (*k).second->close();
    00451        (*k).second = 0;
    00452      }
    00453    }
    00454
    00455    m_connections.erase(m_connections.begin(), m_connections.end());
    00456   return StatusCode::SUCCESS;
    00457 }

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

DataSvc overrides: Initialize the service.

Reimplemented from DataSvc.

Definition at line 571 of file AIDATupleSvc.cpp.

    00572 {
    00573   MsgStream log( msgSvc(), name() );
    00574   StatusCode status = DataSvc::initialize();
    00575
    00576   if( status.isSuccess() ){
    00577     DataObject* rootObj = new DataObject();
    00578     status = setRoot( m_rootName, rootObj );
    00579     if( !status.isSuccess() ) {
    00580       log << MSG::ERROR << "Unable to set NTuple data store root." << endmsg;
    00581       delete rootObj;
    00582       return status;
    00583     }
    00584
    00585     //Connect inputs (MODE = 0)
    00586     for( DBaseEntries::iterator i = m_input.begin(); i != m_input.end(); i++ ) {
    00587       status = connect(*i, 0);
    00588       if( !status.isSuccess() )
    00589         return status;
    00590     }
    00591     //Connect outputs (MODE = 1)
    00592     for( DBaseEntries::iterator j = m_output.begin(); j != m_output.end(); j++ ) {
    00593       status = connect(*j, 1);
    00594       if( !status.isSuccess() )
    00595         return status;
    00596     }
    00597   }
    00598   return status;
    00599 }

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

DataSvc overrides: reinitialize service.

Reimplemented from DataSvc.

Definition at line 602 of file AIDATupleSvc.cpp.

    00603 {
    00604   return StatusCode::SUCCESS;
    00605 }

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

DataSvc overrides: stop the service.

Reimplemented from DataSvc.

Definition at line 608 of file AIDATupleSvc.cpp.

    00609 {
    00610   MsgStream log( msgSvc(), name() );
    00611   StatusCode status = DataSvc::finalize();
    00612   if( status.isSuccess() ) {
    00613     status = closeAIDAStores();
    00614     if( status.isSuccess() )
    00615       return status;
    00616   }
    00617   log << MSG::ERROR << "Error finalizing AIDATupleSvc." << endmsg;
    00618   return status;
    00619 }

AIDA::ITuple * AIDATupleSvc::book | ( | const std::string & | fullPath,
|  | const std::string & | title,
|  | const std::string & | columns |
| ) |  |  | `[virtual]`

Create AIDATuple in the data store.

Parameters:

  | fullPath | [IN]: Full path of the tuple
  | title | [IN]: Title of the tuple
  | columns | [IN]: Description of the column names and types returns a new tuple registered in the transient store

Implements IAIDATupleSvc.

Definition at line 101 of file AIDATupleSvc.cpp.

    00104 {
    00105   std::string dirPath, objPath, storePath, storeObj;
    00106   parsePath( fullPath, dirPath, objPath, storePath, storeObj);
    00107
    00108   Connections::iterator i = m_connections.find(storePath);
    00109   if( i != m_connections.end() ) {
    00110     pi_aida::Tuple* tmp = new pi_aida::Tuple( *(*i).second, storeObj, title, columns );
    00111     AIDA::ITuple* tuple = tmp;
    00112
    00113     if( registerObject(dirPath, objPath, tuple).isSuccess() )
    00114       return tuple;
    00115     else {
    00116       delete tuple;
    00117       throw GaudiException("Cannot book tuple " + title,"AIDATupleSvc", StatusCode::FAILURE);
    00118     }
    00119   }
    00120   else
    00121     throw GaudiException("Cannot find store " + storePath, "AIDATupleSvc", StatusCode::FAILURE);
    00122 }

AIDA::ITuple * AIDATupleSvc::book | ( | const std::string & | parentPath,
|  | const std::string & | objPath,
|  | const std::string & | title,
|  | const std::string & | columns |
| ) |  |  | `[virtual]`

Create AIDATuple in the data store.

Parameters:

  | parentPath | [IN]: Full path to the parent dir of the tuple
  | objPath | [IN]: Name of the tuple
  | title | [IN]: Title of the tuple
  | columns | [IN]: Description of the column names and types returns a new tuple registered in the transient store

Definition at line 125 of file AIDATupleSvc.cpp.

    00129 {
    00130   std::string fullPath = parentPath+"/"+objPath;
    00131   return book( fullPath, title, columns );
    00132 }

AIDA::ITuple * AIDATupleSvc::book | ( | const std::string & | parentPath,
|  | int | tupleID,
|  | const std::string & | title,
|  | const std::string & | columns |
| ) |  |  | `[virtual]`

Create AIDATuple in the data store.

Parameters:

  | parentPath | [IN]: Full path to the parent dir of the tuple
  | tupleID | [IN]: ID of the tuple
  | title | [IN]: Title of the tuple
  | columns | [IN]: Description of the column names and types returns a new tuple registered in the transient store

Definition at line 135 of file AIDATupleSvc.cpp.

    00139 {
    00140   char objPath[32];
    00141   ::_itoa(tupleID, objPath, 10);
    00142   std::string fullPath = parentPath+"/"+objPath;
    00143   return book( fullPath, title, columns );
    00144 }

AIDA::ITuple * AIDATupleSvc::book | ( | DataObject * | pParent,
|  | const std::string & | objPath,
|  | const std::string & | title,
|  | const std::string & | columns |
| ) |  |  | `[virtual]`

Create AIDATuple in the data store.

Parameters:

  | pParent | [IN]: Pointer to the parent directory of the tuple
  | objPath | [IN]: Name of the tuple
  | title | [IN]: Title of the tuple
  | columns | [IN]: Description of the column names and types returns a new tuple registered in the transient store

Definition at line 147 of file AIDATupleSvc.cpp.

    00151 {
    00152   IRegistry* tmp = pParent->registry();
    00153   std::string fullPath, parentPath;
    00154   parentPath = tmp->identifier();
    00155   fullPath = fullPath = parentPath+"/"+objPath;
    00156   return book( fullPath, title, columns );
    00157 }

AIDA::ITuple * AIDATupleSvc::book | ( | DataObject * | pParent,
|  | int | tupleID,
|  | const std::string & | title,
|  | const std::string & | columns |
| ) |  |  | `[virtual]`

Create AIDATuple in the data store.

Parameters:

  | pParent | [IN]: Pointer to the parent directory of the tuple
  | tupleID | [IN]: ID of the tuple
  | title | [IN]: Title of the tuple
  | columns | [IN]: Description of the column names and types returns a new tuple registered in the transient store

Definition at line 160 of file AIDATupleSvc.cpp.

    00164 {
    00165   char txt[32];
    00166   return book( pParent, ::_itoa(tupleID, txt, 10), title, columns );
    00167 }

StatusCode AIDATupleSvc::registerObject | ( | const std::string & | dirPath,
|  | const std::string & | objPath,
|  | AIDA::ITuple * | tObj |
| ) |  |  | `[virtual]`

Register a tuple in the data store.

Parameters:

  | dirPath | [IN]: Path to the directory where the tuple must be registered
  | objPath | [IN]: Name of the tuple
  | tObj | [IN]: Pointer to the tuple to be registered returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 173 of file AIDATupleSvc.cpp.

    00176 {
    00177   DataObject* pParent = 0;
    00178   pParent = createPath( dirPath );
    00179   return registerObject( pParent, objPath, tObj );
    00180
    00181 }

StatusCode AIDATupleSvc::registerObject | ( | DataObject * | pParent,
|  | const std::string & | objPath,
|  | AIDA::ITuple * | tObj |
| ) |  |  | `[virtual]`

Register a tuple in the data store.

Parameters:

  | pParent | [IN]: Pointer to the parent directory of the tuple
  | objPath | [IN]: Name of the tuple
  | tObj | [IN]: Pointer to the tuple to be registered returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 183 of file AIDATupleSvc.cpp.

    00186 {
    00187   // Set the tuple id
    00188   if ( objPath[0] == SEPARATOR ) {
    00189     if ( !tObj->annotation().addItem( "id", objPath.substr(1) ) )
    00190       tObj->annotation().setValue( "id", objPath.substr(1) );
    00191   }
    00192   else {
    00193     if ( !tObj->annotation().addItem( "id", objPath ) )
    00194       tObj->annotation().setValue( "id", objPath );
    00195   }
    00196
    00197   // Register the tuple in the tuple data store
    00198   StatusCode status = DataSvc::registerObject( pParent,
    00199                                                objPath,
    00200                                                dynamic_cast<DataObject*>(tObj) );
    00201   return status;
    00202 }

StatusCode AIDATupleSvc::unregisterObject | ( | AIDA::ITuple * | tObj | ) | `[virtual]`

Unregister a tuple in the data store.

Parameters:

  | tObj | [IN]: Pointer to tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 208 of file AIDATupleSvc.cpp.

    00209 {
    00210   StatusCode status = DataSvc::unregisterObject( dynamic_cast<DataObject*>(tObj) );
    00211   return status;
    00212 }

StatusCode AIDATupleSvc::unregisterObject | ( | AIDA::ITuple * | tObj,
|  | const std::string & | objPath |
| ) |  |  | `[virtual]`

Unregister a tuple in the data store.

Parameters:

  | tObj | [IN]: Pointer to tuple
  | objPath | [IN]: Name of the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 215 of file AIDATupleSvc.cpp.

    00217 {
    00218   StatusCode status = DataSvc::unregisterObject( dynamic_cast<DataObject*>(tObj),
    00219                                                  objPath );
    00220   return status;
    00221 }

StatusCode AIDATupleSvc::retrieveObject | ( | const std::string & | fullPath,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Retrieve a tuple from the data store.

Parameters:

  | fullPath | [IN]: Full path of the tuple
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 227 of file AIDATupleSvc.cpp.

    00229 {
    00230   MsgStream log ( msgSvc(), name() );
    00231   StatusCode status;
    00232   status = findObject(fullPath, tObj);
    00233
    00234   // Tuple already in the transient store
    00235   if( status.isSuccess() )
    00236     return status;
    00237
    00238   std::string dirPath, objPath, storePath, storeObj;
    00239   parsePath( fullPath, dirPath, objPath, storePath, storeObj);
    00240
    00241   // Load tuple from persistency
    00242   Connections::iterator i = m_connections.find(storePath);
    00243   if( i != m_connections.end() ) {
    00244     pi_aida::Tuple* tmp = new pi_aida::Tuple(((*i).second)->retrieveTuple(storeObj));
    00245
    00246     tObj = dynamic_cast<AIDA::ITuple*>(tmp);
    00247     return StatusCode::SUCCESS;
    00248   }
    00249   log << MSG::ERROR << "Could not retrieve tuple " << fullPath << endmsg;
    00250   return StatusCode::FAILURE;
    00251 }

StatusCode AIDATupleSvc::retrieveObject | ( | const std::string & | parentPath,
|  | const std::string & | objPath,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Retrieve a tuple from the data store.

Parameters:

  | parentPath | [IN]: Full path to the parent dir of the tuple
  | objPath | [IN]: Name of the tuple
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 254 of file AIDATupleSvc.cpp.

    00257 {
    00258   std::string fullPath = parentPath+'/'+objPath;
    00259   return retrieveObject( fullPath, tObj );
    00260 }

StatusCode AIDATupleSvc::retrieveObject | ( | DataObject * | pParent,
|  | const std::string & | objPath,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Retrieve a tuple from the data store.

Parameters:

  | pParent | [IN]: Pointer to the parent directory of the tuple
  | objPath | [IN]: Name of the tuple
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 263 of file AIDATupleSvc.cpp.

    00266 {
    00267   IRegistry* tmpReg = pParent->registry();
    00268   std::string parentPath = tmpReg->identifier();
    00269   std::string fullPath = parentPath+'/'+objPath;
    00270
    00271   return retrieveObject( fullPath, tObj );
    00272 }

StatusCode AIDATupleSvc::findObject | ( | const std::string & | fullPath,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Locate a tuple in the data store.

Parameters:

  | fullPath | [IN]: Full path of the tuple
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 278 of file AIDATupleSvc.cpp.

    00280 {
    00281   DataObject*  pObject  = 0;
    00282   StatusCode sc = DataSvc::findObject( fullPath, pObject );
    00283   tObj = dynamic_cast<AIDA::ITuple*>(pObject);
    00284   return sc;
    00285 }

StatusCode AIDATupleSvc::findObject | ( | IRegistry * | pDirectory,
|  | const std::string & | path,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Locate a tuple in the data store.

Parameters:

  | pDirectory | [IN]: Pointer to a directory
  | path | [IN]: Relative path to the tuple from the pDirectory
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 288 of file AIDATupleSvc.cpp.

    00291 {
    00292   DataObject*  pObject  = 0;
    00293   StatusCode sc = DataSvc::findObject( pRegistry, path, pObject );
    00294   tObj = dynamic_cast<AIDA::ITuple*>(pObject);
    00295   return sc;
    00296 }

StatusCode AIDATupleSvc::findObject | ( | const std::string & | parentPath,
|  | const std::string & | objPath,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Locate a tuple in the data store.

Parameters:

  | parentPath | [IN]: Full path of the tuple
  | objPath | [IN]: Name of the tuple
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 299 of file AIDATupleSvc.cpp.

    00302 {
    00303   DataObject*  pObject  = 0;
    00304   StatusCode sc = DataSvc::findObject( parentPath, objPath, pObject );
    00305   tObj = dynamic_cast<AIDA::ITuple*>(pObject);
    00306   return sc;
    00307 }

StatusCode AIDATupleSvc::findObject | ( | DataObject * | parentObj,
|  | const std::string & | objPath,
|  | AIDA::ITuple *& | tObj |
| ) |  |  | `[virtual]`

Locate a tuple in the data store.

Parameters:

  | parentObj | [IN]: Pointer to the parent directory
  | objPath | [IN]: Name of the tuple
  | tObj | [OUT]: Pointer to the tuple returns StatusCode indicating the success of the operation

Implements IAIDATupleSvc.

Definition at line 310 of file AIDATupleSvc.cpp.

    00313 {
    00314   DataObject*  pObject  = 0;
    00315   StatusCode sc = DataSvc::findObject( parentObj, objPath, pObject );
    00316   tObj = dynamic_cast<AIDA::ITuple*>(pObject);
    00317   return sc;
    00318 }

void AIDATupleSvc::setCriteria | ( | AIDA::ITuple *& | tObj,
|  | const std::string & | criteria |
| ) |  |  | `[virtual]`

Set a selection criteria for reading, as a filter.

Parameters:

  | tObj | [IN]: Pointer to the tuple
  | criteria | [IN]: Selection criteria

Implements IAIDATupleSvc.

Definition at line 321 of file AIDATupleSvc.cpp.

    00323 {
    00324   pi_aida::Tuple* t = dynamic_cast<pi_aida::Tuple*>(tObj);
    00325   t->setCriteria(criteria);
    00326 }

StatusCode AIDATupleSvc::myTest | ( |  | ) | `[virtual]`

Dummy method to test the service.

AIDATupleSvc class implementation.

Author:
  Manuel Domenech Saavedra

Date:
  2005-05-23

Implements IAIDATupleSvc.

Definition at line 37 of file AIDATupleSvc.cpp.

    00038 {
    00039   MsgStream log ( msgSvc(), name() );
    00040   log << MSG::INFO << "Welcome to myTest!" << endmsg;
    00041
    00042   // Defining the description of the tuple columns
    00043   std::string description =  "float px; float py; float pz; float mass";
    00044
    00045   pi_aida::Proxy_Store* store = new pi_aida::Proxy_Store("ntuple.root","POOL",0,"CAT=xmlcatalog_file:anotherCatalog.xml,SUB=POOL_ROOTTREE");
    00046   pi_aida::Tuple tuple(*store, "1", "tuple1", description);
    00047   //AIDATuple tuple( store, "1", "example tuple", description );
    00048
    00049   DRand48Engine randomEngine;
    00050   RandGauss rBeamEnergy( randomEngine, 90, 5 );
    00051   RandGauss rTracksSpread( randomEngine, 0, 2 );
    00052   RandGauss rMomentum( randomEngine, 0, 3 );
    00053   RandGauss rMass( randomEngine, 1, 0.1 );
    00054
    00055   std::cout << "Tuple created ... starting to fill " << std::endl;
    00056
    00057   int i_px = tuple.findColumn( "px" );
    00058   int i_py = tuple.findColumn( "py" );
    00059   int i_pz = tuple.findColumn( "pz" );
    00060   int i_mass = tuple.findColumn( "mass" );
    00061
    00062   for ( unsigned int i = 0; i < 1000; i++ ) {
    00063
    00064       tuple.fill( i_px,  rMomentum.fire() );
    00065       tuple.fill( i_py,  rMomentum.fire() );
    00066       tuple.fill( i_pz,  rMomentum.fire() );
    00067       tuple.fill( i_mass, rMass.fire() );
    00068       tuple.addRow();
    00069   }
    00070   std::cout << "Filled the tuple with " << tuple.rows() << " rows" << std::endl;
    00071   store->close();
    00072   delete store;
    00073
    00074   pi_aida::Proxy_Store* store1 = new pi_aida::Proxy_Store("ntuple.root","POOL",3,"CAT=xmlcatalog_file:anotherCatalog.xml,SUB=POOL_ROOTTREE");
    00075   pi_aida::Tuple tuple1 = store1->retrieveTuple("1");
    00076
    00077   //AIDATuple tuple1 = store1->retrieveTuple("1");
    00078   //AIDATuple tuple = static_cast<AIDATuple>(tmp);
    00079
    00080   std::cout << "FOUND TUPLE WITH  " << tuple1.rows() << " ROWS" << std::endl;
    00081
    00082   tuple1.start();
    00083   int i = 0;
    00084   while( tuple1.next() ) {
    00085     i++;
    00086     std::cout << "ROW " << i << std::endl;
    00087     std::cout << "px: " << tuple1.getFloat(i_px) << std::endl;
    00088     std::cout << "py: " << tuple1.getFloat(i_py) << std::endl;
    00089     std::cout << "pz: " << tuple1.getFloat(i_pz) << std::endl;
    00090     std::cout << "mass: " << tuple1.getFloat(i_mass) << std::endl;
    00091   }
    00092   store1->close();
    00093   delete store1;
    00094   return StatusCode::SUCCESS;
    00095 }

## Friends And Related Function Documentation

friend class SvcFactory< AIDATupleSvc >`[friend]`

Allow SvcFactory to instantiate the service.

Definition at line 32 of file AIDATupleSvc.h.

## Member Data Documentation

DBaseEntries AIDATupleSvc::m_output`[protected]`

Output streams.

Definition at line 40 of file AIDATupleSvc.h.

DBaseEntries AIDATupleSvc::m_input`[protected]`

Input streams.

Definition at line 43 of file AIDATupleSvc.h.

Connections AIDATupleSvc::m_connections`[protected]`

Container of connection points.

Definition at line 46 of file AIDATupleSvc.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r8/GaudiSvc/src/AIDATupleSvc/AIDATupleSvc.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r8/GaudiSvc/src/AIDATupleSvc/AIDATupleSvc.cpp