| # Gaudi Framework, version v21r6 |

Home |  | Generated: 11 Nov 2009

# GaudiCommon< PBASE > Class Template Reference

`#include <GaudiAlg/GaudiCommon.h>`

Collaboration diagram for GaudiCommon< PBASE >:

[legend]

List of all members.

## Detailed Description

### template<class PBASE>
class GaudiCommon< PBASE >

Implements the common functionality between GaudiTools and GaudiAlgorithms.

Author:
  Chris Jones Christopher.Rob.Jones@cern.ch

  Vanya BELYAEV Ivan.Belyaev@itep.ru

  Rob Lambert Rob.Lambert@cern.ch

Date:
  2009-08-04

Definition at line 60 of file GaudiCommon.h.

## Public Member Functions
template<class TYPE>
Gaudi::Utils::GetData< TYPE > ::return_type | get (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
| Templated access to the data in Gaudi Transient Store.
template<class TYPE>
bool | exist (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
| Check the existence of a data object or container in the Gaudi Transient Event Store.
template<class TYPE, class TYPE2>
TYPE * | getOrCreate (IDataProviderSvc *svc, const std::string &location, const bool useRootInTES=true) const
| Get the existing data object from Gaudi Event Transient store.
DataObject * | put (IDataProviderSvc *svc, DataObject *object, const std::string &location, const bool useRootInTES=true) const
| Register a data object or container into Gaudi Event Transient Store.
template<class TOOL>
TOOL * | tool (const std::string &type, const std::string &name, const IInterface *parent=0, bool create=true) const
| Useful method for the easy location of tools.
template<class TOOL>
TOOL * | tool (const std::string &type, const IInterface *parent=0, bool create=true) const
| A useful method for the easy location of tools.
template<class SERVICE>
SmartIF< SERVICE > | svc (const std::string &name, const bool create=true) const
| A useful method for the easy location of services.
IUpdateManagerSvc * | updMgrSvc () const
| Short-cut to locate the Update Manager Service.
IDataProviderSvc * | fastContainersSvc () const
| Short-cut to locate the Fast Containers Service.
StatusCode | Error (const std::string &msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
| Print the error message and return with the given StatusCode.
StatusCode | Warning (const std::string &msg, const StatusCode st=StatusCode::FAILURE, const size_t mx=10) const
| Print the warning message and return with the given StatusCode.
StatusCode | Info (const std::string &msg, const StatusCode st=StatusCode::SUCCESS, const size_t mx=10) const
| Print the info message and return with the given StatusCode.
StatusCode | Print (const std::string &msg, const StatusCode st=StatusCode::SUCCESS, const MSG::Level lev=MSG::INFO) const
| Print the message and return with the given StatusCode.
StatusCode | Assert (const bool ok, const std::string &message="", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
| Assertion - throw exception if the given condition is not fulfilled.
StatusCode | Assert (const bool ok, const char *message, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
| Assertion - throw exception if the given condition is not fulfilled.
StatusCode | Exception (const std::string &msg, const GaudiException &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
| Create and (re)-throw a given GaudiException.
StatusCode | Exception (const std::string &msg, const std::exception &exc, const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
| Create and (re)-throw a given exception.
StatusCode | Exception (const std::string &msg="no message", const StatusCode sc=StatusCode(StatusCode::FAILURE, true)) const
| Create and throw an exception with the given message.
MsgStream & | msgStream (const MSG::Level level) const
| Predefined configurable message stream for the efficient printouts.
MsgStream & | always () const
| shortcut for the method msgStream ( MSG::ALWAYS )
MsgStream & | fatal () const
| shortcut for the method msgStream ( MSG::FATAL )
MsgStream & | err () const
| shortcut for the method msgStream ( MSG::ERROR )
MsgStream & | error () const
| shortcut for the method msgStream ( MSG::ERROR )
MsgStream & | warning () const
| shortcut for the method msgStream ( MSG::WARNING )
MsgStream & | info () const
| shortcut for the method msgStream ( MSG::INFO )
MsgStream & | debug () const
| shortcut for the method msgStream ( MSG::DEBUG )
MsgStream & | verbose () const
| shortcut for the method msgStream ( MSG::VERBOSE )
MsgStream & | msg () const
| shortcut for the method msgStream ( MSG::INFO )
const Statistics & | counters () const
| accessor to all counters
StatEntity & | counter (const std::string &tag) const
| accessor to certain counter by name
MSG::Level | msgLevel () const
| The current message service output level.
bool | msgLevel (const MSG::Level level) const
| Test the output level.
void | resetMsgStream () const
| Reset (delete) the current message stream object.
bool | typePrint () const
| Insert the actual C++ type of the algorithm/tool in the messages ?
bool | propsPrint () const
| Print properties at initialization ?
bool | statPrint () const
| Print statistical counters at finalization ?
bool | errorsPrint () const
| Print error counters at finalization ?
long | printStat (const MSG::Level level=MSG::ALWAYS) const
| perform the actual printout of statistical counters
long | printErrors (const MSG::Level level=MSG::ALWAYS) const
| perform the actual printout of error counters
long | printProps (const MSG::Level level=MSG::ALWAYS) const
| perform the actual printout of properties
template<class CallerClass>
void | registerCondition (const std::string &condition, StatusCode(CallerClass::*mf)()=NULL)
| register the current instance to the UpdateManagerSvc as a consumer for a condition.
template<class CallerClass, class CondType>
void | registerCondition (const std::string &condition, CondType *&condPtrDest, StatusCode(CallerClass::*mf)()=NULL)
| register the current instance to the UpdateManagerSvc as a consumer for a condition.
template<class CallerClass>
void | registerCondition (char *condition, StatusCode(CallerClass::*mf)()=NULL)
| just to avoid conflicts with the version using a pointer to a template class.
template<class CallerClass, class TargetClass>
void | registerCondition (TargetClass *condition, StatusCode(CallerClass::*mf)()=NULL)
| register the current instance to the UpdateManagerSvc as a consumer for a condition.
StatusCode | runUpdate ()
| asks the UpdateManagerSvc to perform an update of the instance (if needed) without waiting the next BeginEvent incident.
template<class T>
TransientFastContainer< T > * | getFastContainer (const std::string &location, typename TransientFastContainer< T >::size_type initial=0)
| Return a new TransientFastContainer for objects of type T.
| GaudiCommon (const std::string &name, ISvcLocator *pSvcLocator)
| Algorithm constructor.
| GaudiCommon (const std::string &type, const std::string &name, const IInterface *parent)
| Tool constructor.
virtual StatusCode | initialize ()
| standard initialization method
virtual StatusCode | finalize ()
| standard finalization method
StatusCode | release (const IInterface *interface) const
| Manual forced (and 'safe') release of the active tool or service.
const AlgTools & | tools () const
| get the list of aquired tools
const Services & | services () const
| get the list of aquired services
const std::string & | context () const
| Returns the "context" string. Used to identify different processing states.
const std::string & | rootInTES () const
| Returns the "rootInTES" string.
double | globalTimeOffset () const
| Returns the "globalTimeOffset" double.
## Protected Types
typedef std::map< std::string, StatEntity > | Statistics
| the actual type of general counters
typedef std::map< std::string, unsigned int > | Counter
| the actual type error/warning counter
typedef std::vector< IAlgTool * > | AlgTools
| storage for active tools
typedef GaudiUtils::HashMap < std::string, SmartIF < IService > > | Services
| storage for active services
## Protected Member Functions
virtual | ~GaudiCommon ()
| Destructor.
StatusCode | releaseTool (const IAlgTool *tool) const
| manual forced (and 'safe') release of the tool
StatusCode | releaseSvc (const IInterface *svc) const
| manual forced (and 'safe') release of the service
## Protected Attributes
ICounterSummarySvc * | m_counterSummarySvc
| a pointer to the CounterSummarySvc
std::vector< std::string > | m_counterList
| list of counters to declare. Set by property CounterList. This can be a regular expression.
std::vector< std::string > | m_statEntityList
## Static Protected Attributes
static const bool | IgnoreRootInTES = false
| Simple definition to be used with the new useRootInTES argument get<TYPE> and put methods.
static const bool | UseRootInTES = true
| Simple definition to be used with the new useRootInTES argument get<TYPE> and put methods.
## Private Member Functions
void | msgLevelHandler (Property &theProp)
| Handle method for changes in the Messaging levels.
| GaudiCommon ()
| GaudiCommon (const GaudiCommon &)
GaudiCommon & | operator= (const GaudiCommon &)
void | printErrorHandler (Property &)
| handler for "ErrorPrint" property
void | printPropsHandler (Property &)
| handler for "PropertiesPrint" property
void | printStatHandler (Property &)
| handler for "StatPrint" property
void | addToToolList (IAlgTool *tool) const
| Add the given tool to the list of acquired tools.
void | addToServiceList (const SmartIF< IService > &svc) const
| Add the given service to the list of acquired services.
void | initGaudiCommonConstructor (const IInterface *parent=0)
| Constructor initializations.
const std::string | fullTESLocation (const std::string &location, const bool useRootInTES) const
| Returns the full correct event location given the rootInTes settings.
## Private Attributes
MSG::Level | m_msgLevel
| The message level.
MsgStream * | m_msgStream
| The predefined message stream.
AlgTools | m_tools
| List of active tools.
Services | m_services
| List of active services.
Counter | m_errors
| Counter of errors.
Counter | m_warnings
| counter of warnings
Counter | m_infos
| counter of infos
Counter | m_exceptions
| Counter of exceptions.
Statistics | m_counters
| General counters.
IUpdateManagerSvc * | m_updMgrSvc
| Pointer to the Update Manager Service instance.
IDataProviderSvc * | m_fastContainersSvc
| Pointer to the service providing transient fast containers.
bool | m_typePrint
| insert the actual C++ type of the algorithm in the messages?
bool | m_propsPrint
| print properties at initialization?
bool | m_statPrint
| print counters at finalization ?
bool | m_errorsPrint
| print warning and error counters at finalization ?
std::string | m_context
| The context string.
std::string | m_rootInTES
| The rootInTES string.
std::string | m_rootOnTES
| The rootOnTES string.
double | m_globalTimeOffset
| The globalTimeOffset value.
std::string | m_header
| the header row
std::string | m_format1
| format for regular statistical printout rows
std::string | m_format2
| format for "efficiency" statistical printout rows
bool | m_useEffFormat
| flag to use the special "efficiency" format

## Member Typedef Documentation

template<class PBASE>

typedef std::map<std::string,StatEntity> GaudiCommon< PBASE >::Statistics`[protected]`

the actual type of general counters

Definition at line 89 of file GaudiCommon.h.

template<class PBASE>

typedef std::map<std::string,unsigned int> GaudiCommon< PBASE >::Counter`[protected]`

the actual type error/warning counter

Definition at line 91 of file GaudiCommon.h.

template<class PBASE>

typedef std::vector<IAlgTool*> GaudiCommon< PBASE >::AlgTools`[protected]`

storage for active tools

Definition at line 93 of file GaudiCommon.h.

template<class PBASE>

typedef GaudiUtils::HashMap<std::string, SmartIF<IService> > GaudiCommon< PBASE >::Services`[protected]`

storage for active services

Definition at line 95 of file GaudiCommon.h.

## Constructor & Destructor Documentation

template<class PBASE>

GaudiCommon< PBASE >::GaudiCommon | ( | const std::string & | name,
|  | ISvcLocator * | pSvcLocator |
| ) |  |  |

Algorithm constructor.

template<class PBASE>

GaudiCommon< PBASE >::GaudiCommon | ( | const std::string & | type,
|  | const std::string & | name,
|  | const IInterface * | parent |
| ) |  |  |

Tool constructor.

template<class PBASE>

GaudiCommon< PBASE >::~GaudiCommon | ( |  | ) | `[inline, protected, virtual]`

Destructor.

Definition at line 67 of file GaudiCommon.icpp.

    00067 { resetMsgStream(); }

template<class PBASE>

GaudiCommon< PBASE >::GaudiCommon | ( |  | ) | `[private]`

template<class PBASE>

GaudiCommon< PBASE >::GaudiCommon | ( | const GaudiCommon< PBASE > & |  | ) | `[private]`

## Member Function Documentation

template<class PBASE>
template<class TYPE>

Gaudi::Utils::GetData< TYPE >::return_type GaudiCommon< PBASE >::get | ( | IDataProviderSvc * | svc,
|  | const std::string & | location,
|  | const bool | useRootInTES = `true` |
| ) |  |  | const`[inline]`

Templated access to the data in Gaudi Transient Store.

Quick and safe access to the data in Gaudi transient store. The method located the data at given address and perform the debug printout about located data

      // Will access MCHits from the given location
      MCHits* hits = get<MCHits>( evtSvc () , "MC/Hits" );

Attention:
  The method respects the setting of the job option RootInTES by prepending the value of this to the data location that is passed. The default setting for RootInTES is "" so has no effect. This behavior can be suppressed by passing the argument useRootInTES = false

See also:
  IDataProviderSvc

  SmartDataPtr

Exceptions:

  | GaudiException | for Invalid Data Provider Service
  | GaudiException | for invalid/unavailable data

Parameters:

  | svc | Pointer to data service (data provider)
  | location | data location/address in Gaudi Transient Store
  | useRootInTES | Flag to turn on(TRUE) off(FALSE) the use of the RootInTES location property

Returns:
  pointer to the data object

Reimplemented in GaudiAlgorithm, and GaudiTool.

Definition at line 55 of file GaudiCommonImp.h.

    00058 {
    00059   // check the environment
    00060   Assert( 0 != service ,    "get():: IDataProvider* points to NULL!"      ) ;
    00061   // get the helper object:
    00062   Gaudi::Utils::GetData<TYPE> helper ;
    00063   return helper ( *this , service ,
    00064                   fullTESLocation ( location , useRootInTES ) ) ;
    00065 }

template<class PBASE>
template<class TYPE>

bool GaudiCommon< PBASE >::exist | ( | IDataProviderSvc * | svc,
|  | const std::string & | location,
|  | const bool | useRootInTES = `true` |
| ) |  |  | const`[inline]`

Check the existence of a data object or container in the Gaudi Transient Event Store.

      bool a1 = exist<DataObject>( evtSvc() , "/Event/MyObject" ) ;
      bool a2 = exist<MyHits>    ( evtSvc() , "/Event/MyHits" ) ;

Attention:
  The method respects the setting of the job option RootInTES by prepending the value of this to the data location that is passed. The default setting for RootInTES is "" so has no effect. This behavior can be suppressed by passing the argument useRootInTES = false

Parameters:

  | svc | Pointer to data provider service
  | location | Address in Gaudi Transient Store
  | useRootInTES | Flag to turn on(TRUE) off(FALSE) the use of the RootInTES location property

Returns:
  Boolean indicating status of the request

Return values:

  | true | Data object or container exists and implements a proper interface
  | true | Failed to locate the data object or container

Reimplemented in GaudiAlgorithm, and GaudiTool.

Definition at line 71 of file GaudiCommonImp.h.

    00074 {
    00075   // check the environment
    00076   Assert( 0 != service , "exist():: IDataProvider* points to NULL!"      ) ;
    00077   // check the data object
    00078   const std::string & fullLoc = fullTESLocation( location, useRootInTES );
    00079   SmartDataPtr<TYPE> obj( service , fullLoc ) ;
    00080   return obj ? true : false ;
    00081 }

template<class PBASE>
template<class TYPE, class TYPE2>

TYPE * GaudiCommon< PBASE >::getOrCreate | ( | IDataProviderSvc * | svc,
|  | const std::string & | location,
|  | const bool | useRootInTES = `true` |
| ) |  |  | const`[inline]`

Get the existing data object from Gaudi Event Transient store.

Alternatively, create new object and register it in TES and return if object does not exist.

      MyHits* hits = getOrCreate<MyHits,MyHits>( evtSvc() , "/Event/MyHits" ) ;

Attention:
  The method respects the setting of the job option RootInTES by prepending the value of this to the data location that is passed. The default setting for RootInTES is "" so has no effect. This behavior can be suppressed by passing the argument useRootInTES = false

Exceptions:

  | GaudiException | for Invalid Data Provider Service
  | GaudiException | for invalid/unavailable data

Parameters:

  | svc | Pointer to data provider service
  | location | Location in Gaudi Transient Event Store
  | useRootInTES | Flag to turn on(TRUE) off(FALSE) the use of the RootInTES location property

Returns:
  A valid pointer to the data object

Reimplemented in GaudiAlgorithm, and GaudiTool.

Definition at line 89 of file GaudiCommonImp.h.

    00092 {
    00093   // check the environment
    00094   Assert( 0 != svc , "getOrCreate():: svc points to NULL!" ) ;
    00095   const std::string & fullLoc = fullTESLocation( location, useRootInTES );
    00096   SmartDataPtr<TYPE> obj ( svc , fullLoc ) ;
    00097   if ( !obj )
    00098   {
    00099     TYPE2* o = new TYPE2() ;
    00100     put ( svc , o , location ) ; // do not use fullLoc here as put recreates it
    00101     return o ;
    00102   }
    00103   TYPE* aux = obj ;
    00104   if( !aux )
    00105   { Exception ( "getOrCreate():: No valid data at '" + fullLoc + "'" ) ; }
    00106   // return located *VALID* data
    00107   return aux ;
    00108 }

template<class PBASE>

DataObject * GaudiCommon< PBASE >::put | ( | IDataProviderSvc * | svc,
|  | DataObject * | object,
|  | const std::string & | location,
|  | const bool | useRootInTES = `true` |
| ) |  |  | const`[inline]`

Register a data object or container into Gaudi Event Transient Store.

See also:
  IDataProviderSvc

Attention:
  The method respects the setting of the job option RootInTES by prepending the value of this to the data location that is passed. The default setting for RootInTES is "" so has no effect. This behavior can be suppressed by passing the argument useRootInTES = false

Parameters:

  | svc | Pointer to data provider service
  | object | Data object or container to be registered
  | location | Location in Gaudi Event Transient Store ("/Event" could be omitted )
  | useRootInTES | Flag to turn on(TRUE) off(FALSE) the use of the RootInTES location property

Exceptions:

  | GaudiException | for invalid event data service
  | GaudiException | for invalid object
  | GaudiException | for error result from event data service

Returns:
  StatusCode

Return values:

  | StatusCode::SUCCESS | Data was successfully placed in the TES.
  | StatusCode::FAILURE | Failed to store data in the TES.

Reimplemented in GaudiAlgorithm, and GaudiTool.

Definition at line 758 of file GaudiCommon.icpp.

    00762 {
    00763   // check arguments
    00764   Assert ( 0 != svc              , "put():: Invalid 'service'!"       ) ;
    00765   Assert ( 0 != object           , "put():: Invalid 'Object'!"        ) ;
    00766   Assert ( !location.empty()     , "put():: Invalid 'address' = '' "  ) ;
    00767   // final data location
    00768   const std::string & fullLocation = fullTESLocation( location, useRootInTES );
    00769   // register the object!
    00770   const StatusCode status = '/' == fullLocation[0] ?
    00771     svc -> registerObject(             fullLocation , object ) :
    00772     svc -> registerObject( "/Event/" + fullLocation , object ) ;
    00773   // check the result!
    00774   if ( status.isFailure() )
    00775   { Exception ( "put():: could not register '"            +
    00776                 System::typeinfoName( typeid( *object ) ) +
    00777                 "' at address '" + fullLocation + "'"  , status ) ; }
    00778   if ( msgLevel( MSG::DEBUG ) )
    00779   { Print( "The object of type '"                    +
    00780            System::typeinfoName( typeid( *object ) ) +
    00781            "' is registered in TS at address '"
    00782            + fullLocation + "'" , status , MSG::DEBUG ) ; }
    00783   return object;
    00784 }

template<class PBASE>
template<class TOOL>

TOOL * GaudiCommon< PBASE >::tool | ( | const std::string & | type,
|  | const std::string & | name,
|  | const IInterface * | parent = `0`,
|  | bool | create = `true` |
| ) |  |  | const`[inline]`

Useful method for the easy location of tools.

      IMyTool* myTool =
          tool<IMyTool>( "MyToolType", "MyToolName", this );

Attention:
  The tools located with this method will be released automatically

See also:
  IToolSvc

  IAlgTool

Exceptions:

  | GaudiException | for invalid Tool Service
  | GaudiException | for error from Tool Service
  | GaudiException | for invalid tool

Parameters:

  | type | Tool type
  | name | Tool name
  | parent | Tool parent
  | create | Flag for creation of nonexisting tools

Returns:
  A pointer to the tool

Definition at line 114 of file GaudiCommonImp.h.

    00118 {
    00119   TOOL* Tool = 0 ;
    00120   // for empty names delegate to another method
    00121   if ( name.empty() )
    00122   {
    00123     Tool = tool<TOOL>( type , parent , create ) ;
    00124   }
    00125   else
    00126   {
    00127     Assert( this->toolSvc() != 0, "tool():: IToolSvc* points to NULL!" ) ;
    00128     // get the tool from Tool Service
    00129     const StatusCode sc =
    00130       this->toolSvc()->retrieveTool ( type , name , Tool , parent , create ) ;
    00131     if ( sc.isFailure() )
    00132     { Exception("tool():: Could not retrieve Tool '" + type + "'/'" + name + "'", sc ) ; }
    00133     if ( 0 == Tool )
    00134     { Exception("tool():: Could not retrieve Tool '" + type + "'/'" + name + "'"     ) ; }
    00135     // add the tool into list of known tools to be properly released
    00136     addToToolList( Tool );
    00137   }
    00138   // return *VALID* located tool
    00139   return Tool ;
    00140 }

template<class PBASE>
template<class TOOL>

TOOL * GaudiCommon< PBASE >::tool | ( | const std::string & | type,
|  | const IInterface * | parent = `0`,
|  | bool | create = `true` |
| ) |  |  | const`[inline]`

A useful method for the easy location of tools.

      IMyTool* myTool = tool<IMyTool>( "PublicToolType" );

Attention:
  The tools located with this method will be released automatically

See also:
  IToolSvc

  IAlgTool

Exceptions:

  | GaudiException | for invalid Tool Service
  | GaudiException | for error from Tool Service
  | GaudiException | for invalid tool

Parameters:

  | type | Tool type, could be of "Type/Name" format
  | parent | Tool parent
  | create | Flag for creation of non-existing tools

Returns:
  A pointer to the tool

Definition at line 146 of file GaudiCommonImp.h.

    00149 {
    00150   // check the environment
    00151   Assert ( PBASE::toolSvc() != 0, "IToolSvc* points to NULL!" );
    00152   // retrieve the tool from Tool Service
    00153   TOOL* Tool = 0 ;
    00154   const StatusCode sc =
    00155     this->toolSvc() -> retrieveTool ( type, Tool, parent , create   );
    00156   if ( sc.isFailure() )
    00157   { Exception("tool():: Could not retrieve Tool '" + type + "'", sc ) ; }
    00158   if ( 0 == Tool )
    00159   { Exception("tool():: Could not retrieve Tool '" + type + "'"     ) ; }
    00160   // add the tool into the list of known tools to be properly released
    00161   addToToolList( Tool );
    00162   // return *VALID* located tool
    00163   return Tool ;
    00164 }

template<class PBASE>
template<class SERVICE>

SmartIF< SERVICE > GaudiCommon< PBASE >::svc | ( | const std::string & | name,
|  | const bool | create = `true` |
| ) |  |  | const`[inline]`

A useful method for the easy location of services.

      IMyService* mySvc = svc<IMyService>( "MyServiceType" );

Attention:
  The services located with this method will be released automatically

See also:
  IService

  ISevcLocator

  Service

Exceptions:

  | GaudiException | for error in Algorithms::service
  | GaudiException | for invalid service

Parameters:

  | name | service type name
  | create | Flag for creation of non-existing services

Returns:
  A pointer to the service

Definition at line 170 of file GaudiCommonImp.h.

    00172 {
    00173   Assert ( this->svcLoc() != 0, "ISvcLocator* points to NULL!" );
    00174   SmartIF<SERVICE> s;
    00175   // check if we already have this service
    00176   Services::iterator it = m_services.find(name);
    00177   if (it != m_services.end()) {
    00178     // Try to get the requested interface
    00179     s = it->second;
    00180     // check the results
    00181     if ( !s.isValid() ) {
    00182       Exception ("svc():: Could not retrieve Svc '" + name + "'", StatusCode::FAILURE);
    00183     }
    00184   } else {
    00185     SmartIF<IService>& baseSvc = this->svcLoc()->service(name, create);
    00186     // Try to get the requested interface
    00187     s = baseSvc;
    00188     // check the results
    00189     if ( !baseSvc.isValid() || !s.isValid() ) {
    00190       Exception ("svc():: Could not retrieve Svc '" + name + "'", StatusCode::FAILURE);
    00191     }
    00192     // add the tool into list of known tools, to be properly released
    00193     addToServiceList(baseSvc);
    00194   }
    00195   // return *VALID* located service
    00196   return s;
    00197 }

template<class PBASE>

IUpdateManagerSvc * GaudiCommon< PBASE >::updMgrSvc | ( |  | ) | const`[inline]`

Short-cut to locate the Update Manager Service.

Definition at line 203 of file GaudiCommonImp.h.

    00204 {
    00205   if ( !m_updMgrSvc )
    00206   { m_updMgrSvc = svc<IUpdateManagerSvc>("UpdateManagerSvc",true); }
    00207   return m_updMgrSvc ;
    00208 }

template<class PBASE>

IDataProviderSvc * GaudiCommon< PBASE >::fastContainersSvc | ( |  | ) | const`[inline]`

Short-cut to locate the Fast Containers Service.

Definition at line 214 of file GaudiCommonImp.h.

    00215 {
    00216   if ( !m_fastContainersSvc )
    00217   { m_fastContainersSvc = svc<IDataProviderSvc>("FastContainersSvc",true); }
    00218   return m_fastContainersSvc ;
    00219 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Error | ( | const std::string & | msg,
|  | const StatusCode | st = `StatusCode::FAILURE`,
|  | const size_t | mx = `10` |
| ) |  |  | const`[inline]`

Print the error message and return with the given StatusCode.

Also performs statistical analysis of the error messages and suppression after the defined number of error instances.

       if( a < 0 ) { return Error("a is negative!") ;}
       if( b < 0 ) { return Error("b is illegal!" , StatusCode(25) );
       if( c < 0 )
          { return Error("c is negative" , StatusCode(35) , 50 );

See also:
  MsgStream

  IMessageSvc

  StatusCode

Parameters:

  | msg | Error message
  | st | StatusCode to return
  | mx | Maximum number of printouts for this message

Returns:
  StatusCode

Reimplemented in ErrorTool.

Definition at line 472 of file GaudiCommon.icpp.

    00475 {
    00476   // increase local counter of errors
    00477   const size_t num = ++m_errors[msg] ;
    00478   // If suppressed, just return
    00479   if      ( num  > mx ) { return st ; }
    00480   else if ( num == mx ) // issue one-time suppression message
    00481   { return Print ( "The   ERROR message is suppressed : '" +
    00482                    msg + "'" , st , MSG::ERROR ) ; }
    00483   // return message
    00484   return Print ( msg , st , MSG::ERROR ) ;
    00485 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Warning | ( | const std::string & | msg,
|  | const StatusCode | st = `StatusCode::FAILURE`,
|  | const size_t | mx = `10` |
| ) |  |  | const`[inline]`

Print the warning message and return with the given StatusCode.

Also performs statistical analysis of the error messages and suppression after the defined number of error instances.

       if( a < 0 ) { return Warning("a is negative!") ;}
       if( b < 0 ) { return Warning("b is illegal!" , StatusCode(25) );
       if( c < 0 )
          { return Warning("c is negative" , StatusCode(35) , 50 );

See also:
  MsgStream

  IMessageSvc

  StatusCode

Parameters:

  | msg | Warning message
  | st | StatusCode to return
  | mx | Maximum number of printouts for this message

Returns:
  The given StatusCode

Reimplemented in ErrorTool.

Definition at line 493 of file GaudiCommon.icpp.

    00496 {
    00497   // increase local counter of warnings
    00498   const size_t num = ++m_warnings[msg] ;
    00499   // If suppressed, just return
    00500   if      ( num  > mx ) { return st ; }
    00501   else if ( num == mx ) // issue one-time suppression message
    00502   { return Print ( "The WARNING message is suppressed : '" +
    00503                    msg + "'" , st , MSG::WARNING ) ; }
    00504   // return message
    00505   return Print ( msg , st , MSG::WARNING ) ;
    00506 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Info | ( | const std::string & | msg,
|  | const StatusCode | st = `StatusCode::SUCCESS`,
|  | const size_t | mx = `10` |
| ) |  |  | const`[inline]`

Print the info message and return with the given StatusCode.

Also performs statistical analysis of the error messages and suppression after the defined number of instances.

See also:
  MsgStream

  IMessageSvc

  StatusCode

  GaudiCommon::Warning

Parameters:

  | msg | Info message
  | st | StatusCode to return
  | mx | Maximum number of printouts for this message

Returns:
  The given StatusCode

Definition at line 514 of file GaudiCommon.icpp.

    00517 {
    00518   // increase local counter of warnings
    00519   const size_t num = ++m_infos[msg] ;
    00520   // If suppressed, just return
    00521   if      ( num  > mx ) { return st ; }
    00522   else if ( num == mx ) // issue one-time suppression message
    00523   { return Print ( "The INFO message is suppressed : '" +
    00524                    msg + "'" , st , MSG::INFO ) ; }
    00525   // return message
    00526   return Print ( msg , st , MSG::INFO ) ;
    00527 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Print | ( | const std::string & | msg,
|  | const StatusCode | st = `StatusCode::SUCCESS`,
|  | const MSG::Level | lev = `MSG::INFO` |
| ) |  |  | const`[inline]`

Print the message and return with the given StatusCode.

See also:
  MsgStream

  IMessageSvc

  StatusCode

Parameters:

  | msg | Message to print
  | st | StatusCode to return
  | lev | Printout level for the given message

Returns:
  The given StatusCode

Reimplemented in ErrorTool.

Definition at line 534 of file GaudiCommon.icpp.

    00537 {
    00538   // perform printout ?
    00539   if ( !msgLevel( lvl ) ) { return st ; }   // RETURN
    00540
    00541   // use the predefined stream
    00542   MsgStream& str = msgStream( lvl ) ;
    00543   if ( typePrint() ) { str << System::typeinfoName(typeid(*this)) << ":: " ; }
    00544   // print the message
    00545   str  << msg ;
    00546   // test status code
    00547   if      ( st.isSuccess() ) { }
    00548   else if ( StatusCode::FAILURE != st.getCode() )
    00549   { str << " StatusCode=" << st.getCode() ; }
    00550   else
    00551   { str << " StatusCode=FAILURE" ; }
    00552   // perform print operation
    00553   str << endmsg ;
    00554   // return
    00555   return  st;
    00556 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Assert | ( | const bool | ok,
|  | const std::string & | message = `""`,
|  | const StatusCode | sc = `StatusCode(StatusCode::FAILURE, true)` |
| ) |  |  | const`[inline]`

Assertion - throw exception if the given condition is not fulfilled.

See also:
  GaudiException

Exceptions:

  | Exception | for invalid condition

Parameters:

  | ok | Condition which should be "true"
  | message | Message to be associated with the exception
  | sc | StatusCode to be returned (artificial)

Returns:
  StatusCode

Reimplemented in ErrorTool.

Definition at line 268 of file GaudiCommonImp.h.

    00271 {
    00272   return ( OK ? StatusCode(StatusCode::SUCCESS, true) : Exception( msg , sc ) ) ;
    00273 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Assert | ( | const bool | ok,
|  | const char * | message,
|  | const StatusCode | sc = `StatusCode(StatusCode::FAILURE, true)` |
| ) |  |  | const`[inline]`

Assertion - throw exception if the given condition is not fulfilled.

See also:
  GaudiException

Exceptions:

  | Exception | for invalid condition

Parameters:

  | ok | Condition which should be "true"
  | message | Message to be associated with the exception
  | sc | StatusCode to be returned (artificial)

Returns:
  StatusCode

Definition at line 287 of file GaudiCommonImp.h.

    00290 {
    00291   return OK ? StatusCode(StatusCode::SUCCESS, true) : Exception( msg , sc ) ;
    00292 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Exception | ( | const std::string & | msg,
|  | const GaudiException & | exc,
|  | const StatusCode | sc = `StatusCode(StatusCode::FAILURE, true)` |
| ) |  |  | const`[inline]`

Create and (re)-throw a given GaudiException.

See also:
  GaudiException

Exceptions:

  | CaudiException | always thrown!

Parameters:

  | msg | Exception message
  | exc | (previous) exception of type GaudiException
  | sc | StatusCode

Returns:
  StatusCode (fictive)

Reimplemented in ErrorTool.

Definition at line 563 of file GaudiCommon.icpp.

    00566 {
    00567   // increase local counter of exceptions
    00568   ++m_exceptions[ msg ];
    00569   Print ( "Exception (re)throw: " + msg , sc , MSG::FATAL );
    00570   throw   GaudiException( this->name() + ":: " + msg , this->name() , sc, exc);
    00571   return  sc ;
    00572 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Exception | ( | const std::string & | msg,
|  | const std::exception & | exc,
|  | const StatusCode | sc = `StatusCode(StatusCode::FAILURE, true)` |
| ) |  |  | const`[inline]`

Create and (re)-throw a given exception.

See also:
  GaudiException

Exceptions:

  | std::exception | always thrown!

Parameters:

  | msg | Exception message
  | exc | (previous) exception of type std::exception
  | sc | StatusCode

Returns:
  StatusCode (fictive)

Reimplemented in ErrorTool.

Definition at line 579 of file GaudiCommon.icpp.

    00582 {
    00583   // increase local counter of exceptions
    00584   ++m_exceptions[ msg ];
    00585   Print ( "Exception (re)throw: " + msg , sc , MSG::FATAL  );
    00586   throw GaudiException( this->name() + ":: " + msg+"("+exc.what()+")", "", sc );
    00587   return  sc ;
    00588 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::Exception | ( | const std::string & | msg = `"no message"`,
|  | const StatusCode | sc = `StatusCode(StatusCode::FAILURE, true)` |
| ) |  |  | const`[inline]`

Create and throw an exception with the given message.

See also:
  GaudiException

Exceptions:

  | GaudiException | always thrown!

Parameters:

  | msg | Exception message
  | sc | StatusCode

Returns:
  StatusCode (fictive)

Reimplemented in ErrorTool.

Definition at line 595 of file GaudiCommon.icpp.

    00597 {
    00598   // increase local counter of exceptions
    00599   ++m_exceptions[ msg ];
    00600   Print ( "Exception throw: " + msg , sc , MSG::FATAL );
    00601   throw GaudiException( this->name() + ":: " + msg , "",  sc );
    00602   return  sc ;
    00603 }

template<class PBASE>

MsgStream & GaudiCommon< PBASE >::msgStream | ( | const MSG::Level | level | ) | const`[inline]`

Predefined configurable message stream for the efficient printouts.

      if ( a < 0 ) { msgStream( MSG::ERROR ) << "a = " << endmsg ; }

Returns:
  Reference to the predefined stream

Definition at line 258 of file GaudiCommonImp.h.

    00259 {
    00260   if ( !m_msgStream )
    00261   { m_msgStream = new MsgStream ( PBASE::msgSvc() , this->name() ) ; }
    00262   return *m_msgStream << level ;
    00263 }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::always | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::ALWAYS )

Definition at line 489 of file GaudiCommon.h.

    00489 { return msgStream ( MSG::ALWAYS ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::fatal | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::FATAL )

Definition at line 491 of file GaudiCommon.h.

    00491 { return msgStream ( MSG::FATAL ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::err | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::ERROR )

Definition at line 493 of file GaudiCommon.h.

    00493 { return msgStream ( MSG::ERROR ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::error | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::ERROR )

Definition at line 495 of file GaudiCommon.h.

    00495 { return msgStream ( MSG::ERROR ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::warning | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::WARNING )

Definition at line 497 of file GaudiCommon.h.

    00497 { return msgStream ( MSG::WARNING ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::info | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::INFO )

Definition at line 499 of file GaudiCommon.h.

    00499 { return msgStream ( MSG::INFO ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::debug | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::DEBUG )

Definition at line 501 of file GaudiCommon.h.

    00501 { return msgStream ( MSG::DEBUG ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::verbose | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::VERBOSE )

Definition at line 503 of file GaudiCommon.h.

    00503 { return msgStream ( MSG::VERBOSE ) ; }

template<class PBASE>

MsgStream& GaudiCommon< PBASE >::msg | ( |  | ) | const`[inline]`

shortcut for the method msgStream ( MSG::INFO )

Definition at line 505 of file GaudiCommon.h.

    00505 { return msgStream ( MSG::INFO ) ; }

template<class PBASE>

const Statistics& GaudiCommon< PBASE >::counters | ( |  | ) | const`[inline]`

accessor to all counters

Definition at line 509 of file GaudiCommon.h.

    00509 { return m_counters ; }

template<class PBASE>

StatEntity& GaudiCommon< PBASE >::counter | ( | const std::string & | tag | ) | const`[inline]`

accessor to certain counter by name

      if ( OK ) { ++counter("OK") ; }

      // additive counter ('Flag')
      counter("#Tracks") += tracks->size() ;

      // multiplicative counter  ('Weight')
      counter("ProbTot") *= probability ;

See also:
  StatEntuty

Parameters:

  | tag | counter name

Returns:
  the counter itself

Definition at line 528 of file GaudiCommon.h.

    00528 { return m_counters[tag] ; }

template<class PBASE>

MSG::Level GaudiCommon< PBASE >::msgLevel | ( |  | ) | const`[inline]`

The current message service output level.

Returns:
  The current message level

Definition at line 534 of file GaudiCommon.h.

    00534 { return m_msgLevel ; }

template<class PBASE>

bool GaudiCommon< PBASE >::msgLevel | ( | const MSG::Level | level | ) | const`[inline]`

Test the output level.

Parameters:

  | level | The message level to test against

Returns:
  boolean Indicating if messages at given level will be printed

Return values:

  | true | Messages at level "level" will be printed
  | true | Messages at level "level" will NOT be printed

Definition at line 541 of file GaudiCommon.h.

    00541 { return msgLevel() <= level ; }

template<class PBASE>

void GaudiCommon< PBASE >::resetMsgStream | ( |  | ) | const`[inline]`

Reset (delete) the current message stream object.

Useful for example to force a new object following a change in the message level settings

Definition at line 278 of file GaudiCommonImp.h.

    00279 {
    00280   if ( 0 != m_msgStream ) { delete m_msgStream; m_msgStream = 0; }
    00281 }

template<class PBASE>

bool GaudiCommon< PBASE >::typePrint | ( |  | ) | const`[inline]`

Insert the actual C++ type of the algorithm/tool in the messages ?

Definition at line 548 of file GaudiCommon.h.

    00548 { return m_typePrint    ; }

template<class PBASE>

bool GaudiCommon< PBASE >::propsPrint | ( |  | ) | const`[inline]`

Print properties at initialization ?

Definition at line 550 of file GaudiCommon.h.

    00550 { return m_propsPrint   ; }

template<class PBASE>

bool GaudiCommon< PBASE >::statPrint | ( |  | ) | const`[inline]`

Print statistical counters at finalization ?

Definition at line 552 of file GaudiCommon.h.

    00552 { return m_statPrint    ; }

template<class PBASE>

bool GaudiCommon< PBASE >::errorsPrint | ( |  | ) | const`[inline]`

Print error counters at finalization ?

Definition at line 554 of file GaudiCommon.h.

    00554 { return m_errorsPrint  ; }

template<class PBASE>

void GaudiCommon< PBASE >::msgLevelHandler | ( | Property & | theProp | ) | `[inline, private]`

Handle method for changes in the Messaging levels.

Called whenever the property "OutputLevel" changes to perform all necessary actions locally.

Parameters:

  | theProp | Reference to the Property that has changed

Definition at line 724 of file GaudiCommon.icpp.

    00725 {
    00726   // Force a new MsgStream object, to pick up the new settings
    00727   resetMsgStream();
    00728
    00729   // adjust internal message level
    00730   m_msgLevel =
    00731     this->outputLevel() <  (int) MSG::NIL        ?  MSG::NIL    :
    00732     this->outputLevel() >= (int) MSG::NUM_LEVELS ?  MSG::ALWAYS :
    00733     MSG::Level( this->outputLevel() ) ;
    00734
    00735   // Keep MessageSvc up to date if needed
    00736   if ( this->msgSvc()->outputLevel(this->name()) != this->outputLevel() )
    00737   {
    00738     this->msgSvc()->setOutputLevel( this->name(), this->outputLevel() );
    00739   }
    00740
    00741   // printout message
    00742   if ( msgLevel(MSG::DEBUG) )
    00743   {
    00744     debug() << "Property update for "
    00745             << theProp.name() << " : new value = " << this->outputLevel() << endmsg;
    00746   }
    00747 }

template<class PBASE>

long GaudiCommon< PBASE >::printStat | ( | const MSG::Level | level = `MSG::ALWAYS` | ) | const`[inline]`

perform the actual printout of statistical counters

Parameters:

  | level | The message level to print at

Returns:
  number of active statistical counters

Definition at line 610 of file GaudiCommon.icpp.

    00611 {
    00612   // print statistics
    00613   if ( counters().empty() ) { return 0 ; }
    00614   MsgStream& msg = msgStream ( level ) ;
    00615   //
    00616   msg << "Number of counters : "  << counters().size() ;
    00617   //
    00618   if ( !counters().empty() ) { msg << std::endl << m_header ; }
    00619   //
    00620   for ( Statistics::const_iterator entry = counters().begin() ;
    00621         counters().end() != entry ; ++entry )
    00622   {
    00623     msg << std::endl
    00624         << Gaudi::Utils::formatAsTableRow
    00625       ( entry -> first  ,
    00626         entry -> second ,
    00627         m_useEffFormat  ,
    00628         m_format1       , m_format2 );
    00629   }
    00630   //
    00631   msg << endmsg ;
    00632   //
    00633   return counters().size() ;
    00634 }

template<class PBASE>

long GaudiCommon< PBASE >::printErrors | ( | const MSG::Level | level = `MSG::ALWAYS` | ) | const`[inline]`

perform the actual printout of error counters

Parameters:

  | level | The message level to print at

Returns:
  number of error counters

Definition at line 641 of file GaudiCommon.icpp.

    00642 {
    00643   // format for printout
    00644   boost::format ftm ( " %s = %|.8s| %|23t| Message = '%s'" );
    00645
    00646   { // print exceptions
    00647     for ( Counter::const_iterator excp = m_exceptions.begin() ;
    00648           excp  != m_exceptions.end() ; ++excp  )
    00649     {
    00650       msgStream(level)
    00651         << ( ftm % "#EXCEPTIONS" % excp->second % excp->first       )
    00652         << endmsg;
    00653     }
    00654   }
    00655   { // print errors
    00656     for ( Counter::const_iterator error = m_errors.begin() ;
    00657           error != m_errors.end() ; ++error )
    00658     {
    00659       msgStream(level)
    00660         << ( ftm % "#ERRORS    " % error->second % error->first     )
    00661         << endmsg;
    00662     }
    00663   }
    00664   { // print warnings
    00665     for ( Counter::const_iterator warning = m_warnings.begin() ;
    00666           warning != m_warnings.end() ; ++warning )
    00667     {
    00668       msgStream(level)
    00669         << ( ftm % "#WARNINGS  " % warning->second % warning->first )
    00670         << endmsg;
    00671     }
    00672   }
    00673   { // print warnings
    00674     for ( Counter::const_iterator info = m_infos.begin() ;
    00675     info != m_infos.end() ; ++info )
    00676     {
    00677       msgStream(level)
    00678         << ( ftm % "#INFOS     " % info->second % info->first )
    00679         << endmsg;
    00680     }
    00681   }
    00682
    00683   // return total number of errors+warnings+exceptions
    00684   return
    00685     m_exceptions .size () +
    00686     m_errors     .size () +
    00687     m_warnings   .size () +
    00688     m_infos      .size () ;
    00689 }

template<class PBASE>

long GaudiCommon< PBASE >::printProps | ( | const MSG::Level | level = `MSG::ALWAYS` | ) | const`[inline]`

perform the actual printout of properties

perform the printout of properties

Parameters:

  | level | The message level to print at

Returns:
  number of properties

  number of error counters

Definition at line 698 of file GaudiCommon.icpp.

    00699 {
    00700
    00701   // print ALL properties
    00702   MsgStream& msg = msgStream ( level );
    00703   typedef std::vector<Property*> Properties;
    00704   const Properties& properties = this->getProperties() ;
    00705   msg << "List of ALL properties of "
    00706       << System::typeinfoName( typeid( *this ) ) << "/" << this->name()
    00707       << "  #properties = " << properties.size() << endmsg ;
    00708   for ( Properties::const_reverse_iterator property
    00709           = properties.rbegin() ;
    00710         properties.rend() != property ; ++property )
    00711   {
    00712     msg << "Property ['Name': Value] = "
    00713         << ( **property)
    00714         << endmsg ;
    00715   }
    00716   return properties.size() ;
    00717 }

template<class PBASE>
template<class CallerClass>

void GaudiCommon< PBASE >::registerCondition | ( | const std::string & | condition,
|  | StatusCode(CallerClass::*)() | mf = `NULL` |
| ) |  |  | `[inline]`

register the current instance to the UpdateManagerSvc as a consumer for a condition.

Parameters:

  | condition | the path inside the Transient Detector Store to the condition object.
  | mf | optional pointer to the member function to call when the condition object is updated. If the pointer is omitted the user must explicitly provide the class name to the method.
        StatusCode MyAlg::initialize(){
           // ...
           registerCondition("/dd/Conditions/Readout/MyDet/MyCond",&MyAlg::i_CallBack);
           registerCondition<MyAlg>("/dd/Conditions/Readout/MyDet/MyOtherCond");
           // ...
           return StatusCode.SUCCESS;
        }

Definition at line 597 of file GaudiCommon.h.

    00597                                                                                                   {
    00598     updMgrSvc()->registerCondition(dynamic_cast<CallerClass*>(this),condition,mf);
    00599   }

template<class PBASE>
template<class CallerClass, class CondType>

void GaudiCommon< PBASE >::registerCondition | ( | const std::string & | condition,
|  | CondType *& | condPtrDest,
|  | StatusCode(CallerClass::*)() | mf = `NULL` |
| ) |  |  | `[inline]`

register the current instance to the UpdateManagerSvc as a consumer for a condition.

This version of the method allow the user to specify where to put a copy of the pointer to the condition object.

Parameters:

  | condition | the path inside the Transient Detector Store to the condition object.
  | condPtrDest | pointer to fill with the location of the condition object. Note: the pointer can be safely used only in the execute method or in the member function triggered by the update.
  | mf | optional pointer to the member function to call when the condition object is updated. If the pointer is omitted the user must explicitly provide the class name to the method.
        class MyAlg: public GaudiAlgorithm {
           // ...
        public:
           virtual StatusCode i_CallBack();
        private:
           Condition *m_MyCond;
           SpecialCondition *m_MyOtherCond;
           // ...
        };

        StatusCode MyAlg::initialize(){
           // ...
           registerCondition("/dd/Conditions/Readout/MyDet/MyCond",m_MyCond,&MyAlg::i_CallBack);
           registerCondition<MyAlg>("/dd/Conditions/Readout/MyDet/MyOtherCond",m_MyOtherCond);
           // ...
           return StatusCode.SUCCESS;
        }

Definition at line 631 of file GaudiCommon.h.

    00632                                                                       {
    00633     updMgrSvc()->registerCondition(dynamic_cast<CallerClass*>(this),condition,mf,condPtrDest);
    00634   }

template<class PBASE>
template<class CallerClass>

void GaudiCommon< PBASE >::registerCondition | ( | char * | condition,
|  | StatusCode(CallerClass::*)() | mf = `NULL` |
| ) |  |  | `[inline]`

just to avoid conflicts with the version using a pointer to a template class.

Definition at line 637 of file GaudiCommon.h.

    00637                                                                                        {
    00638     updMgrSvc()->registerCondition(dynamic_cast<CallerClass*>(this),std::string(condition),mf);
    00639   }

template<class PBASE>
template<class CallerClass, class TargetClass>

void GaudiCommon< PBASE >::registerCondition | ( | TargetClass * | condition,
|  | StatusCode(CallerClass::*)() | mf = `NULL` |
| ) |  |  | `[inline]`

register the current instance to the UpdateManagerSvc as a consumer for a condition.

Parameters:

  | condition | the path inside the Transient Detector Store to the condition object.
  | mf | optional pointer to the member function to call when the condition object is updated. If the pointer is omitted the user must explicitly provide the class name to the method.
        StatusCode MyAlg::initialize(){
           // ...
           registerCondition("/dd/Conditions/Readout/MyDet/MyCond",&MyAlg::i_CallBack);
           registerCondition<MyAlg>("/dd/Conditions/Readout/MyDet/MyOtherCond");
           // ...
           return StatusCode.SUCCESS;
        }

Definition at line 656 of file GaudiCommon.h.

    00656                                                                                               {
    00657     updMgrSvc()->registerCondition(dynamic_cast<CallerClass*>(this),condition,mf);
    00658   }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::runUpdate | ( |  | ) | `[inline]`

asks the UpdateManagerSvc to perform an update of the instance (if needed) without waiting the next BeginEvent incident.

It is useful if the instance can be instantiated after a BeginEvent incident, and used before the next one (for example with tools).

      StatusCode MyTool::initialize(){
        // ...
        return runUpdate();
      }

Definition at line 670 of file GaudiCommon.h.

    00670 { return updMgrSvc()->update(this); }

template<class PBASE>
template<class T>

TransientFastContainer< T > * GaudiCommon< PBASE >::getFastContainer | ( | const std::string & | location,
|  | typename TransientFastContainer< T >::size_type | initial = `0` |
| ) |  |  | `[inline]`

Return a new TransientFastContainer for objects of type T.

The container is created if it is not in the transient store. If a container with the same name but a different type

Definition at line 226 of file GaudiCommonImp.h.

    00228 {
    00229   typedef TransientFastContainer<T> container_type;
    00230
    00231   IDataProviderSvc* svc = fastContainersSvc();
    00232   Assert( 0 != svc , "getFastContainer(): cannot get FastContainersSvc" );
    00233
    00234   container_type *ptr = NULL;
    00235   SmartDataPtr<container_type> obj( svc, location );
    00236   if (!obj){
    00237     ptr = new container_type(initial);
    00238     StatusCode status = svc->registerObject(location,ptr);
    00239     if ( !status.isSuccess() ){
    00240       Exception("getFastContainer(): cannot register '" +
    00241                 System::typeinfoName( typeid( *ptr ) ) +
    00242                 "' at address '" + location + "'"  , status );
    00243     }
    00244   } else {
    00245     ptr = obj;
    00246     if ( !ptr ){
    00247       Exception("getFastContainer(): No valid container at '" + location + "'");
    00248     }
    00249   }
    00250
    00251   return ptr;
    00252 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::initialize | ( |  | ) | `[inline, virtual]`

standard initialization method

Returns:
  status code

Reimplemented in GaudiAlgorithm, GaudiHistoAlg, GaudiHistoTool, GaudiSequencer, GaudiTool, GaudiTupleAlg, GaudiTupleTool, Prescaler, SequencerTimerTool, EqSolver, FuncMinimum, GaudiHistos< GaudiAlgorithm >, GaudiHistos< GaudiTool >, GaudiTuples< GaudiHistoTool >, and GaudiTuples< GaudiHistoAlg >.

Definition at line 224 of file GaudiCommon.icpp.

    00225 {
    00226
    00227   // initialize base class
    00228   const StatusCode sc = PBASE::initialize();
    00229   if ( sc.isFailure() )
    00230   { return Error ( "Failed to initialise base class PBASE", sc ) ; }
    00231
    00232
    00233   // some debug printout
    00234   if ( msgLevel(MSG::DEBUG) )
    00235   {
    00236     debug() << "Initialize base class GaudiCommon<" << System::typeinfoName(typeid(PBASE)) << ">" << endmsg;
    00237     if ( !context().empty() )
    00238       debug() << "Created with context = '" << context() << "'" << endmsg;
    00239   }
    00240
    00241   // some temporary checks to see if people are using RootOnTES and warn if so
    00242   // TO BE REMOVED ASAP ...
    00243   if ( m_rootInTES.empty() && !m_rootOnTES.empty() )
    00244   {
    00245     m_rootInTES = m_rootOnTES;
    00246     Warning( "RootOnTES option is OBSOLETE -> Use RootInTES instead. RootInTES has been updated to "
    00247              + m_rootInTES, StatusCode::SUCCESS ).ignore();
    00248   }
    00249   else if ( !m_rootInTES.empty() && !m_rootOnTES.empty() )
    00250   {
    00251     Warning( "Options RootOnTES AND RootInTES are defined ! Use RootInTES. RootOnTES is ignored",
    00252              StatusCode::SUCCESS ).ignore();
    00253   }
    00254
    00255   // Check rootInTES ends with a /
    00256   if ( !m_rootInTES.empty() &&
    00257        m_rootInTES.substr(m_rootInTES.size()-1) != "/" ) m_rootInTES += "/";
    00258
    00259   //Set up the CounterSummarySvc May need to be changed
    00260   this->svcLoc()->service("CounterSummarySvc",m_counterSummarySvc,false).ignore() ;
    00261   if (msgLevel(MSG::DEBUG))
    00262   {
    00263     if (m_counterSummarySvc==NULL )
    00264         debug() <<  "could not locate CounterSummarySvc, no counter summary will be made" << endmsg;
    00265     else debug() <<  "found CounterSummarySvc OK" << endmsg;
    00266   }
    00267
    00268   // properties will be printed if asked for or in "MSG::DEBUG" mode
    00269   if      ( propsPrint()         ) { printProps(MSG::ALWAYS); }
    00270   else if ( msgLevel(MSG::DEBUG) ) { printProps(MSG::DEBUG);  }
    00271
    00272   return sc;
    00273 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::finalize | ( | void |  | ) | `[inline, virtual]`

standard finalization method

Returns:
  status code

Reimplemented in GaudiAlgorithm, GaudiHistoAlg, GaudiHistoTool, GaudiSequencer, GaudiTool, GaudiTupleAlg, GaudiTupleTool, Prescaler, SequencerTimerTool, EqSolver, FuncMinimum, GaudiHistos< GaudiAlgorithm >, GaudiHistos< GaudiTool >, GaudiTuples< GaudiHistoTool >, and GaudiTuples< GaudiHistoAlg >.

Definition at line 280 of file GaudiCommon.icpp.

    00281 {
    00282   StatusCode sc = StatusCode::SUCCESS;
    00283
    00284   // print the general information about statistical counters
    00285   if ( msgLevel(MSG::DEBUG) || (statPrint() && !counters().empty()) )
    00286   {
    00287     // print general statistical counters
    00288     printStat ( statPrint() ? MSG::ALWAYS : MSG::DEBUG ) ;
    00289   }
    00290   //add all counters to the CounterSummarySvc
    00291   if(m_counterSummarySvc && this->svcLoc()->existsService("CounterSummarySvc"))
    00292   {
    00293     if ( msgLevel(MSG::DEBUG) ) debug() << "adding counters to CounterSummarySvc" << endmsg;
    00294     for(Statistics::const_iterator i=this->counters().begin();
    00295         i!=this->counters().end();
    00296         i++)
    00297     {
    00298       if(Gaudi::Utils::RegEx::matchOr(i->first,m_statEntityList))
    00299         m_counterSummarySvc->addCounter(this->name(),i->first,i->second,
    00300                                         Gaudi::CounterSummary::SaveStatEntity);
    00301       else if(Gaudi::Utils::RegEx::matchOr(i->first,m_counterList))
    00302         m_counterSummarySvc->addCounter(this->name(),i->first,i->second);
    00303     }
    00304   }
    00305   // release all located tools and services
    00306   if ( msgLevel(MSG::DEBUG) )
    00307   {
    00308     debug() << "Tools to release :";
    00309     for ( AlgTools::const_iterator i = m_tools.begin();
    00310           i != m_tools.end(); ++i )
    00311     {
    00312       debug() << " " << (*i)->name();
    00313     }
    00314     debug() << endmsg;
    00315   }
    00316   while ( !m_tools.empty() ) { sc = sc && releaseTool( m_tools.back() ) ; }
    00317
    00318   // release all located services
    00319   if ( msgLevel(MSG::DEBUG) )
    00320   {
    00321     debug() << "Services to release :";
    00322     for ( Services::const_iterator i = m_services.begin();
    00323           i != m_services.end(); ++i )
    00324     {
    00325       debug() << " " << (*i).first;
    00326     }
    00327     debug() << endmsg;
    00328   }
    00329   while ( !m_services.empty() ) { sc = sc && releaseSvc( m_services.begin()->second ) ; }
    00330
    00331   //release the CounterSummarySvc manually
    00332   if(m_counterSummarySvc)
    00333   {
    00334     m_counterSummarySvc->release();
    00335     m_counterSummarySvc=NULL;
    00336   }
    00337
    00338   // format printout
    00339   if ( !m_errors.empty() || !m_warnings.empty() || !m_exceptions.empty() )
    00340   {
    00341     always() << "Exceptions/Errors/Warnings/Infos Statistics : "
    00342              << m_exceptions .size () << "/"
    00343              << m_errors     .size () << "/"
    00344              << m_warnings   .size () << "/"
    00345              << m_infos      .size () << endmsg ;
    00346     if ( errorsPrint() ) { printErrors () ; }
    00347   }
    00348
    00349   // delete the MsgStream
    00350   resetMsgStream();
    00351
    00352   // clear *ALL* counters explicitly
    00353   m_counters   .clear() ;
    00354   m_exceptions .clear() ;
    00355   m_infos      .clear() ;
    00356   m_warnings   .clear() ;
    00357   m_errors     .clear() ;
    00358   m_counterList.clear() ;
    00359   m_statEntityList.clear() ;
    00360
    00361   // finalize base class
    00362   return sc && PBASE::finalize();
    00363 }

template<class PBASE>

GaudiCommon& GaudiCommon< PBASE >::operator= | ( | const GaudiCommon< PBASE > & |  | ) | `[private]`

template<class PBASE>

StatusCode GaudiCommon< PBASE >::releaseTool | ( | const IAlgTool * | tool | ) | const`[inline, protected]`

manual forced (and 'safe') release of the tool

Definition at line 389 of file GaudiCommon.icpp.

    00390 {
    00391   if( 0 == algTool   )
    00392   { return Error ( "releaseTool(IAlgTool):: IAlgTool* points to NULL!" ) ; }
    00393   if( this->toolSvc() == 0 )
    00394   { return Error ( "releaseTool(IAlgTool):: IToolSvc* points to NULL!" ) ; }
    00395   // find a tool in the list of active tools
    00396   AlgTools::reverse_iterator it =
    00397     std::find( m_tools.rbegin() , m_tools.rend() , algTool ) ;
    00398   if(  m_tools.rend() == it )
    00399   { return Warning("releaseTool(IAlgTool):: IAlgTool* is not active"   ) ; }
    00400   // get the tool
    00401   IAlgTool* t = *it ;
    00402   // cache name
    00403   const std::string name = t->name();
    00404   if ( msgLevel(MSG::DEBUG) )
    00405   { debug() << "Releasing tool '" << name << "'" << endmsg; }
    00406   // remove the tool from the lists
    00407   m_tools.erase( --it.base() ) ;
    00408   // release tool
    00409   const StatusCode sc = this->toolSvc()->releaseTool( t ) ;
    00410   if ( sc.isFailure() )
    00411   { return Warning ( "releaseTool(IAlgTool):: error from IToolSvc whilst releasing "+name , sc ) ; }
    00412   // return final status code
    00413   return sc ;
    00414 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::releaseSvc | ( | const IInterface * | svc | ) | const`[inline, protected]`

manual forced (and 'safe') release of the service

Definition at line 421 of file GaudiCommon.icpp.

    00422 {
    00423   if( 0 == Svc ) {
    00424     return Error ( "releaseSvc(IInterface):: IInterface* points to NULL!" ) ;
    00425   }
    00426   SmartIF<IService> svc(const_cast<IInterface*>(Svc));
    00427   if (svc.isValid()) {
    00428     Services::iterator it = m_services.find(svc->name());
    00429     if (it == m_services.end()) {
    00430       return Warning( "releaseSvc(IInterface):: IInterface* is not active" );
    00431     }
    00432     if ( msgLevel(MSG::DEBUG) ) {
    00433       debug() << "Releasing service '" << it->first << "'" << endmsg;
    00434     }
    00435     m_services.erase(it);
    00436     return StatusCode::SUCCESS;
    00437   }
    00438   return Warning( "releaseSvc(IInterface):: IInterface* is not a service" );
    00439 }

template<class PBASE>

StatusCode GaudiCommon< PBASE >::release | ( | const IInterface * | interface | ) | const`[inline]`

Manual forced (and 'safe') release of the active tool or service.

      IMyTool* mytool = tool<IMyTool>( .... ) ;
      mytool->spendCPUtime() ;
      release ( mytool ) ;

      IMySvc* msvc = svc<IMySvc>( .... ) ;
      msvc->spendCPUtime() ;
      release ( msvc ) ;

Parameters:

  | interface | Interface pointer to the interface to be released

Returns:
  StatusCode

Return values:

  | StatusCode::SUCCESS | Tool or service was successfully released
  | StatusCode::FAILURE | Error releasing too or service

Definition at line 374 of file GaudiCommon.icpp.

    00375 {
    00376   if ( 0 == interface )
    00377   { return Error ( "release(IInterface):: IInterface* points to NULL!" ) ; }
    00378   // dispatch between tools and services
    00379   const IAlgTool* algTool = dynamic_cast<const IAlgTool*>( interface )  ;
    00380   // perform the actual release
    00381   return 0 != algTool ? releaseTool( algTool ) : releaseSvc( interface ) ;
    00382 }

template<class PBASE>

const AlgTools& GaudiCommon< PBASE >::tools | ( |  | ) | const`[inline]`

get the list of aquired tools

Definition at line 735 of file GaudiCommon.h.

    00735 { return m_tools    ; }    // get all tools

template<class PBASE>

const Services& GaudiCommon< PBASE >::services | ( |  | ) | const`[inline]`

get the list of aquired services

Definition at line 737 of file GaudiCommon.h.

    00737 { return m_services ; } // get all services

template<class PBASE>

void GaudiCommon< PBASE >::printErrorHandler | ( | Property & |  | ) | `[inline, private]`

handler for "ErrorPrint" property

Definition at line 791 of file GaudiCommon.icpp.

    00792 {
    00793   // no action if not yet initialized
    00794   if ( this -> FSMState() < Gaudi::StateMachine::INITIALIZED ) { return ; }
    00795   if ( this -> errorsPrint() ) { this -> printErrors () ; }
    00796 }

template<class PBASE>

void GaudiCommon< PBASE >::printPropsHandler | ( | Property & |  | ) | `[inline, private]`

handler for "PropertiesPrint" property

Definition at line 801 of file GaudiCommon.icpp.

    00802 {
    00803   // no action if not yet initialized
    00804   if ( this -> FSMState() < Gaudi::StateMachine::INITIALIZED ) { return ; }
    00805   if ( this -> propsPrint() ) { this -> printProps ( MSG::ALWAYS ) ; }
    00806 }

template<class PBASE>

void GaudiCommon< PBASE >::printStatHandler | ( | Property & |  | ) | `[inline, private]`

handler for "StatPrint" property

Definition at line 811 of file GaudiCommon.icpp.

    00812 {
    00813   // no action if not yet initialized
    00814   if ( this -> FSMState() < Gaudi::StateMachine::INITIALIZED ) { return ; }
    00815   if ( this -> statPrint() ) { this -> printStat ( MSG::ALWAYS ) ; }
    00816 }

template<class PBASE>

const std::string& GaudiCommon< PBASE >::context | ( |  | ) | const`[inline]`

Returns the "context" string. Used to identify different processing states.

Definition at line 751 of file GaudiCommon.h.

    00751 { return m_context; }

template<class PBASE>

const std::string& GaudiCommon< PBASE >::rootInTES | ( |  | ) | const`[inline]`

Returns the "rootInTES" string.

Used as the directory root in the TES for which all data access refers to (both saving and retrieving).

Definition at line 755 of file GaudiCommon.h.

    00755 { return m_rootInTES; }

template<class PBASE>

double GaudiCommon< PBASE >::globalTimeOffset | ( |  | ) | const`[inline]`

Returns the "globalTimeOffset" double.

Definition at line 757 of file GaudiCommon.h.

    00757 { return m_globalTimeOffset; }

template<class PBASE>

void GaudiCommon< PBASE >::addToToolList | ( | IAlgTool * | tool | ) | const`[inline, private]`

Add the given tool to the list of acquired tools.

Definition at line 446 of file GaudiCommon.icpp.

    00447 {
    00448   m_tools.push_back( tool ) ;
    00449 }

template<class PBASE>

void GaudiCommon< PBASE >::addToServiceList | ( | const SmartIF< IService > & | svc | ) | const`[inline, private]`

Add the given service to the list of acquired services.

Definition at line 456 of file GaudiCommon.icpp.

    00457 {
    00458   if (svc.isValid()) {
    00459     m_services[svc->name()] = svc;
    00460   }
    00461 }

template<class PBASE>

void GaudiCommon< PBASE >::initGaudiCommonConstructor | ( | const IInterface * | parent = `0` | ) | `[inline, private]`

Constructor initializations.

< flag to use the special "efficiency" format

Definition at line 75 of file GaudiCommon.icpp.

    00076 {
    00077   // initialise data members
    00078   m_msgLevel    = MSG::NIL;
    00079   m_msgStream   = 0;
    00080   m_updMgrSvc   = 0;
    00081   m_fastContainersSvc   = 0;
    00082   m_typePrint   = true;
    00083   m_propsPrint  = false;
    00084   m_statPrint   = true;
    00085   m_errorsPrint = true;
    00086   m_context     = "" ;
    00087   m_rootInTES   = "" ;
    00088   m_globalTimeOffset = 0.0 ;
    00089   //data members for the CounterSummarySvc
    00090   m_counterSummarySvc=NULL;
    00091   m_counterList=std::vector<std::string>(1,".*");
    00092   m_statEntityList=std::vector<std::string>(0);
    00093
    00094   // printout of counters:
    00095
    00096   // the header row for counters printout
    00097   m_header  = " |    Counter                                      |     #     |    sum     | mean/eff^* | rms/err^*  |     min     |     max     |" ;
    00098   // format for regular statistical printout rows
    00099   m_format1 = " | %|-48.48s|%|50t||%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |" ;
    00100   // format for "efficiency" statistical printout rows
    00101   m_format2 = " |*%|-48.48s|%|50t||%|10d| |%|11.5g| |(%|#9.6g| +- %|-#9.6g|)%%|   -------   |   -------   |" ;
    00102   // flag to use the special "efficiency" format
    00103   m_useEffFormat = true ;
    00104
    00105   // job options
    00106   // print error counters at finalization ?
    00107   this->declareProperty
    00108     ( "ErrorsPrint"     , m_errorsPrint     ,
    00109       "Print the statistics of errors/warnings/exceptions")
    00110     -> declareUpdateHandler
    00111     ( &GaudiCommon<PBASE>::printErrorHandler, this  ) ;
    00112   // print properties at initialization?
    00113   this->declareProperty
    00114     ( "PropertiesPrint" , m_propsPrint  ,
    00115       "Print the properties of the component ")
    00116     -> declareUpdateHandler
    00117     ( &GaudiCommon<PBASE>::printPropsHandler, this  ) ;
    00118   // print statistical counters at finalization ?
    00119   this->declareProperty
    00120     ( "StatPrint"       , m_statPrint   ,
    00121       "Print the table of counters"  )
    00122     -> declareUpdateHandler
    00123     ( &GaudiCommon<PBASE>::printStatHandler, this  ) ;
    00124   // insert  the actual C++ type of the algorithm or tool in the messages?
    00125   this->declareProperty
    00126     ( "TypePrint"       , m_typePrint   ,
    00127       "Add the actal C++ component type into the messages" ) ;
    00128   // context
    00129   this->declareProperty ( "Context"         , m_context     ) ;
    00130   // root in TES
    00131   this->declareProperty ( "RootInTES"       , m_rootInTES   ) ;
    00132   // root on TES ( temporary )
    00133   this->declareProperty ( "RootOnTES"       , m_rootOnTES   ) ;
    00134   // global time offset
    00135   this->declareProperty ( "GlobalTimeOffset", m_globalTimeOffset ) ;
    00136
    00137
    00138   // the header row for counters printout
    00139   this->declareProperty
    00140     ( "StatTableHeader"        , m_header                          ,
    00141       "The header row for the output Stat-table"                   ) ;
    00142   // format for regular statistical printout rows
    00143   this->declareProperty
    00144     ( "RegularRowFormat"       , m_format1                         ,
    00145       "The format for the regular row in the output Stat-table"    ) ;
    00146   // format for "efficiency" statistical printout rows
    00147   this->declareProperty
    00148     ( "EfficiencyRowFormat"    , m_format2                         ,
    00149       "The format for the regular row in the output Stat-table"    ) ;
    00150   // flag to use the special "efficiency" format
    00151   this->declareProperty
    00152     ( "UseEfficiencyRowFormat" , m_useEffFormat                    ,
    00153       "Use the special format for printout of efficiency counters" ) ;
    00154
    00155
    00156   //declare the list of simple counters to write.
    00157   this->declareProperty(
    00158         "CounterList",
    00159         m_counterList=std::vector<std::string>(1,".*"),
    00160         "RegEx list, of simple integer counters for CounterSummary.");
    00161   //declare the list of stat entities to write.
    00162   this->declareProperty(
    00163         "StatEntityList",
    00164         m_statEntityList=std::vector<std::string>(0),
    00165         "RegEx list, of StatEntity counters for CounterSummary.");
    00166
    00167   // add handler for message level changes
    00168   this->outputLevelProperty().declareUpdateHandler( &GaudiCommon<PBASE>::msgLevelHandler, this );
    00169
    00170   // setup context from parent if available
    00171   if ( parent )
    00172   {
    00173     if      ( const GaudiAlgorithm* gAlg = dynamic_cast<const GaudiAlgorithm*>(parent) )
    00174     {
    00175       m_context = gAlg->context();
    00176       m_rootInTES = gAlg->rootInTES();
    00177       m_globalTimeOffset = gAlg->globalTimeOffset();
    00178     }
    00179     else if ( const GaudiTool*     gTool = dynamic_cast<const GaudiTool*>     (parent) )
    00180     {
    00181       m_context = gTool->context();
    00182       m_rootInTES = gTool->rootInTES();
    00183       m_globalTimeOffset = gTool->globalTimeOffset();
    00184     }
    00185   }
    00186
    00187   // Get the job option service
    00188   IJobOptionsSvc* jos = svc<IJobOptionsSvc>( "JobOptionsSvc" );
    00189
    00190   // Get the "Context" option if in the file...
    00191   const std::vector<const Property*>* myList = jos->getProperties( this->name() );
    00192   if ( 0 != myList )
    00193   {
    00194     // Iterate over the list to set the options
    00195     for ( std::vector<const Property*>::const_iterator iter = myList->begin();
    00196           iter != myList->end();
    00197           ++iter )
    00198     {
    00199       const StringProperty* sp = dynamic_cast<const StringProperty*>(*iter);
    00200       if ( 0 != sp )
    00201       {
    00202         if ( "Context" == (*iter)->name() )
    00203         {
    00204           m_context = sp->value();
    00205         } else if ( "RootInTES" == (*iter)->name() ) {
    00206           m_rootInTES = sp->value();
    00207         } else if ( "GlobalTimeOffset" == (*iter)->name() ) {
    00208           m_globalTimeOffset = atof( sp->value().c_str() );
    00209         }
    00210       }
    00211     }
    00212   }
    00213
    00214   // release tool
    00215   release( jos ).ignore();
    00216
    00217 }

template<class PBASE>

const std::string GaudiCommon< PBASE >::fullTESLocation | ( | const std::string & | location,
|  | const bool | useRootInTES |
| ) |  |  | const`[inline, private]`

Returns the full correct event location given the rootInTes settings.

Definition at line 25 of file GaudiCommonImp.h.

    00027 {
    00028   // The logic is:
    00029   // if no R.I.T., give back location
    00030   // if R.I.T., this is the mapping:
    00031   // (note that R.I.T. contains a trailing '/')
    00032   //  location       -> result
    00033   //  -------------------------------------------------
    00034   //  ""             -> R.I.T.[:-1]      ("rit")
    00035   //  "/Event"       -> R.I.T.[:-1]      ("rit")
    00036   //  "/Event/MyObj" -> R.I.T. + "MyObj" ("rit/MyObj")
    00037   //  "MyObj"        -> R.I.T. + "MyObj" ("rit/MyObj")
    00038   return ( !useRootInTES || rootInTES().empty() ?
    00039            location
    00040          :
    00041            location.empty() || ( location == "/Event" ) ?
    00042              rootInTES().substr(0,rootInTES().size()-1)
    00043            :
    00044              0 == location.find("/Event/") ?
    00045                rootInTES() + location.substr(7)
    00046              :
    00047                rootInTES() + location );
    00048 }

## Member Data Documentation

template<class PBASE>

const bool GaudiCommon< PBASE >::IgnoreRootInTES = false`[static, protected]`

Simple definition to be used with the new useRootInTES argument get<TYPE> and put methods.

If used with cause the RootInTES option to be IGNORED.

Useful to aid with code readability. e.g.

      // Get data, ignoring the setting of rootInTES()
      MyData * data = get<MyData>( "/Event/MyData", IgnoreRootInTES );

Definition at line 72 of file GaudiCommon.h.

template<class PBASE>

const bool GaudiCommon< PBASE >::UseRootInTES = true`[static, protected]`

Simple definition to be used with the new useRootInTES argument get<TYPE> and put methods.

If used with cause the RootInTES option to be USED

Useful to aid with code readability. e.g.

      // Get data, using the setting of rootInTES()
      MyData * data = get<MyData>( "/Event/MyData", UseRootInTES );
      // note the default setting is true, so this is equivalent to
      MyData * data = get<MyData>( "/Event/MyData" );

Definition at line 84 of file GaudiCommon.h.

template<class PBASE>

ICounterSummarySvc* GaudiCommon< PBASE >::m_counterSummarySvc`[protected]`

a pointer to the CounterSummarySvc

Definition at line 99 of file GaudiCommon.h.

template<class PBASE>

std::vector<std::string> GaudiCommon< PBASE >::m_counterList`[protected]`

list of counters to declare. Set by property CounterList. This can be a regular expression.

Definition at line 101 of file GaudiCommon.h.

template<class PBASE>

std::vector<std::string> GaudiCommon< PBASE >::m_statEntityList`[protected]`

Definition at line 103 of file GaudiCommon.h.

template<class PBASE>

MSG::Level GaudiCommon< PBASE >::m_msgLevel`[private]`

The message level.

Definition at line 770 of file GaudiCommon.h.

template<class PBASE>

MsgStream* GaudiCommon< PBASE >::m_msgStream`[mutable, private]`

The predefined message stream.

Definition at line 773 of file GaudiCommon.h.

template<class PBASE>

AlgTools GaudiCommon< PBASE >::m_tools`[mutable, private]`

List of active tools.

Definition at line 775 of file GaudiCommon.h.

template<class PBASE>

Services GaudiCommon< PBASE >::m_services`[mutable, private]`

List of active services.

Definition at line 777 of file GaudiCommon.h.

template<class PBASE>

Counter GaudiCommon< PBASE >::m_errors`[mutable, private]`

Counter of errors.

Definition at line 780 of file GaudiCommon.h.

template<class PBASE>

Counter GaudiCommon< PBASE >::m_warnings`[mutable, private]`

counter of warnings

Definition at line 782 of file GaudiCommon.h.

template<class PBASE>

Counter GaudiCommon< PBASE >::m_infos`[mutable, private]`

counter of infos

Definition at line 784 of file GaudiCommon.h.

template<class PBASE>

Counter GaudiCommon< PBASE >::m_exceptions`[mutable, private]`

Counter of exceptions.

Definition at line 786 of file GaudiCommon.h.

template<class PBASE>

Statistics GaudiCommon< PBASE >::m_counters`[mutable, private]`

General counters.

Definition at line 788 of file GaudiCommon.h.

template<class PBASE>

IUpdateManagerSvc* GaudiCommon< PBASE >::m_updMgrSvc`[mutable, private]`

Pointer to the Update Manager Service instance.

Definition at line 791 of file GaudiCommon.h.

template<class PBASE>

IDataProviderSvc* GaudiCommon< PBASE >::m_fastContainersSvc`[mutable, private]`

Pointer to the service providing transient fast containers.

Definition at line 793 of file GaudiCommon.h.

template<class PBASE>

bool GaudiCommon< PBASE >::m_typePrint`[private]`

insert the actual C++ type of the algorithm in the messages?

Definition at line 796 of file GaudiCommon.h.

template<class PBASE>

bool GaudiCommon< PBASE >::m_propsPrint`[private]`

print properties at initialization?

Definition at line 798 of file GaudiCommon.h.

template<class PBASE>

bool GaudiCommon< PBASE >::m_statPrint`[private]`

print counters at finalization ?

Definition at line 800 of file GaudiCommon.h.

template<class PBASE>

bool GaudiCommon< PBASE >::m_errorsPrint`[private]`

print warning and error counters at finalization ?

Definition at line 802 of file GaudiCommon.h.

template<class PBASE>

std::string GaudiCommon< PBASE >::m_context`[private]`

The context string.

Definition at line 805 of file GaudiCommon.h.

template<class PBASE>

std::string GaudiCommon< PBASE >::m_rootInTES`[private]`

The rootInTES string.

Definition at line 807 of file GaudiCommon.h.

template<class PBASE>

std::string GaudiCommon< PBASE >::m_rootOnTES`[private]`

The rootOnTES string.

Note, this job option is OBSOLETE, but retained temporarily to allow easy migration. Please update your code to use RootInTES instead. This option will be removed at some point.

Definition at line 811 of file GaudiCommon.h.

template<class PBASE>

double GaudiCommon< PBASE >::m_globalTimeOffset`[private]`

The globalTimeOffset value.

Definition at line 813 of file GaudiCommon.h.

template<class PBASE>

std::string GaudiCommon< PBASE >::m_header`[private]`

the header row

Definition at line 816 of file GaudiCommon.h.

template<class PBASE>

std::string GaudiCommon< PBASE >::m_format1`[private]`

format for regular statistical printout rows

Definition at line 818 of file GaudiCommon.h.

template<class PBASE>

std::string GaudiCommon< PBASE >::m_format2`[private]`

format for "efficiency" statistical printout rows

Definition at line 820 of file GaudiCommon.h.

template<class PBASE>

bool GaudiCommon< PBASE >::m_useEffFormat`[private]`

flag to use the special "efficiency" format

Definition at line 822 of file GaudiCommon.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiAlg/GaudiAlg/GaudiCommon.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiAlg/GaudiAlg/GaudiCommonImp.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiAlg/src/lib/GaudiCommon.icpp