Gaudi Framework, version v21r4
Home   Generated: 7 Sep 2009

Gaudi::Utils Namespace Reference


Classes

class  AlgSelector
 Simple interface class for selection of algorithms. More...
class  AlgTypeSelector
 The trivial selector of algorithm by type. More...
class  AlgTypeSelector< TYPE * >
class  AlgTypeSelector< const TYPE * >
class  AlgTypeSelector< TYPE & >
class  AlgTypeSelector< const TYPE & >
class  AlgTypeSelector< const TYPE >
class  AlgNameSelector
 The trivial selector of algorithm by type. More...
struct  _GetType
 Helper structure to define the proper return type for "get"-functions. More...
struct  _GetType< TYPE * >
 the template specialization for pointers More...
struct  _GetType< TYPE & >
 the template specialization for references More...
struct  _GetType< Gaudi::Range_< CONTAINER > >
 the template specialization for "ranges" More...
struct  _GetType< Gaudi::NamedRange_< CONTAINER > >
 the template specialization for "named ranges" More...
struct  GetData
 Helper structure for implementation of "get"-functions for GaudiCommon<BASE>. More...
struct  GetData< Gaudi::Range_< std::vector< const TYPE * > > >
 the template specialization for ranges More...
struct  GetData< Gaudi::NamedRange_< std::vector< const TYPE * > > >
 the template specialization for named ranges More...
struct  GetData< TYPE * >
 the template specialization for pointer types More...
struct  GetData< TYPE & >
 the template specialization for reference types More...
class  AlgContext
 Helper "sentry" class to automatize the safe register/unregister the algorithm's context. More...
class  TypeNameString
 Helper class to parse a string of format "type/name". More...
class  Aida2ROOT
 Accessor to underlying ROOT-representation of transient histograms The actual code is imported from Bender project. More...
class  HistoStats
 The collection of trivial functions to access the statistical information for the histograms. More...

Namespaces

namespace  Histos
 Collection of useful utilities for manipulations with AIDA hisgograms.
namespace  RegEx
 RegeEx: nemspace to hold gaudi regular expression checking.

Functions

GAUDI_API IAlgorithm * getAlgorithm (const IAlgContextSvc *svc, const AlgSelector &sel)
 simple function to get the algorithm from Context Service
GAUDI_API IAlgorithm * getAlgorithm (const std::vector< IAlgorithm * > &lst, const AlgSelector &sel)
 simple function to get the algorithm from Context Service
GAUDI_API GaudiAlgorithm * getGaudiAlg (const IAlgContextSvc *svc)
 simple function to extract the last active GaudiAlgorithm from the context
GAUDI_API GaudiHistoAlg * getHistoAlg (const IAlgContextSvc *svc)
 simple function to extract the last active GaudiHistoAlg from the context
GAUDI_API GaudiTupleAlg * getTupleAlg (const IAlgContextSvc *svc)
 simple function to extract the last active GaudiTupleAlg from the context
GAUDI_API GaudiSequencer * getGaudiSequencer (const IAlgContextSvc *svc)
 simple function to extract the last active GaudiSequencer from the context
GAUDI_API Sequencer * getSequencerAlg (const IAlgContextSvc *svc)
 simple function to extract the last active Sequencer from the context
GAUDI_API IAlgorithm * getSequencer (const IAlgContextSvc *svc)
 simple function to extract the last active "Sequencer" () GaudiSequencer or simple Sequencer) from the context
GAUDI_API bool hasProperty (const IProperty *p, const std::string &name)
 simple function which check the existence of the property with the given name.
GAUDI_API bool hasProperty (const IInterface *p, const std::string &name)
 simple function which check the existence of the property with the given name.
GAUDI_API Property * getProperty (const IProperty *p, const std::string &name)
 simple function which gets the property with given name from the component
GAUDI_API Property * getProperty (const IInterface *p, const std::string &name)
 simple function which gets the property with given name from the component
GAUDI_API bool hasProperty (const std::vector< const Property * > *p, const std::string &name)
 check the property by name from the list of the properties
GAUDI_API const Property * getProperty (const std::vector< const Property * > *p, const std::string &name)
 get the property by name from the list of the properties
template<class TYPE>
StatusCode setProperty (IProperty *component, const std::string &name, const TYPE &value, const std::string &doc)
 simple function to set the property of the given object from the value
template<class TYPE>
StatusCode setProperty (IProperty *component, const std::string &name, const TYPE &value)
 simple function to set the property of the given object from the value
GAUDI_API StatusCode setProperty (IProperty *component, const std::string &name, const std::string &value, const std::string &doc="")
 the full specialization of the previous method setProperty( IProperty, std::string, const TYPE&) for standard strings
GAUDI_API StatusCode setProperty (IProperty *component, const std::string &name, const char *value, const std::string &doc="")
 the full specialization of the method setProperty( IProperty, std::string, const TYPE&) for C-strings
template<unsigned N>
StatusCode setProperty (IProperty *component, const std::string &name, const char(&value)[N], const std::string &doc="")
 the full specialization of the method setProperty( IProperty, std::string, const TYPE&) for C-arrays
GAUDI_API StatusCode setProperty (IProperty *component, const std::string &name, const Property *property, const std::string &doc="")
 simple function to set the property of the given object from another property
GAUDI_API StatusCode setProperty (IProperty *component, const std::string &name, const Property &property, const std::string &doc="")
 simple function to set the property of the given object from another property
template<class TYPE>
StatusCode setProperty (IProperty *component, const std::string &name, const SimpleProperty< TYPE > &value, const std::string &doc="")
 simple function to set the property of the given object from another property
template<class TYPE>
StatusCode setProperty (IInterface *component, const std::string &name, const TYPE &value, const std::string &doc="")
 simple function to set the property of the given object from the value
GAUDI_API StatusCode setProperty (IInterface *component, const std::string &name, const std::string &value, const std::string &doc="")
 the full specialization of the method setProperty( IInterface , std::string, const TYPE&) for standard strings
GAUDI_API StatusCode setProperty (IInterface *component, const std::string &name, const char *value, const std::string &doc="")
 the full specialization of the method setProperty( IInterface , std::string, const TYPE&) for C-strings
template<unsigned N>
StatusCode setProperty (IInterface *component, const std::string &name, const char(&value)[N], const std::string &doc="")
 the full specialization of the method setProperty( IInterface, std::string, const TYPE&) for C-arrays
GAUDI_API StatusCode setProperty (IInterface *component, const std::string &name, const Property *property, const std::string &doc="")
 simple function to set the property of the given object from another property
GAUDI_API StatusCode setProperty (IInterface *component, const std::string &name, const Property &property, const std::string &doc="")
 simple function to set the property of the given object from another property
template<class TYPE>
StatusCode setProperty (IInterface *component, const std::string &name, const SimpleProperty< TYPE > &value, const std::string &doc="")
 simple function to set the property of the given object from another property
GAUDI_API std::string formatAsTableRow (const StatEntity &counter, const bool flag, const std::string &format1=" |%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |", const std::string &format2="*|%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%| ----- | ----- |")
 print the counter in a form of the table row
GAUDI_API std::string formatAsTableRow (const std::string &name, const StatEntity &counter, const bool flag=true, const std::string &format1=" %|-15.15s|%|17t||%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |", const std::string &format2="*%|-15.15s|%|17t||%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%| ----- | ----- |")
 print the counter in a form of the table row
GAUDI_API std::string formatAsTableRow (const std::string &name, const std::string &group, const StatEntity &entity, const bool flag=true, const std::string &format1=" %|15.15s|%|-15.15s|%|32t||%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |", const std::string &format2="*%|15.15s|%|-15.15s|%|32t||%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%| ----- | ----- |")
 print the counter in a form of the table row
template<class TYPE>
std::ostream & toStream (const TYPE &obj, std::ostream &s)
 the generic implementation of the printout to the std::ostream
std::ostream & toStream (const std::string &obj, std::ostream &s)
 the printtout of the strings.
std::ostream & toStream (const bool obj, std::ostream &s)
 the printout of boolean values "a'la Python"
std::ostream & toStream (const float obj, std::ostream &s)
 the printout of float values with the reasonable precision
std::ostream & toStream (const double obj, std::ostream &s)
 the printout of double values with the reasonable precision
std::ostream & toStream (const long double obj, std::ostream &s)
 the printout of long double values with the reasonable precision
template<class KTYPE, class VTYPE>
std::ostream & toStream (const std::pair< KTYPE, VTYPE > &obj, std::ostream &s)
 the partial template specialization of std::pair<KTYPE,VTYPE> printout the pair is printed a'la Python tuple: " ( a , b )"
template<class TYPE, class ALLOCATOR>
std::ostream & toStream (const std::vector< TYPE, ALLOCATOR > &obj, std::ostream &s)
 the partial template specialization of std::vector<TYPE,ALLOCATOR> printout.
template<class TYPE, class ALLOCATOR>
std::ostream & toStream (const std::list< TYPE, ALLOCATOR > &obj, std::ostream &s)
 the partial template specialization of std::list<TYPE,ALLOCATOR> printout.
template<class TYPE, class CMP, class ALLOCATOR>
std::ostream & toStream (const std::set< TYPE, CMP, ALLOCATOR > &obj, std::ostream &s)
 the partial template specialization of std::set<TYPE,CMP,ALLOCATOR> printout.
template<class KTYPE, class VTYPE, class CMP, class ALLOCATOR>
std::ostream & toStream (const std::map< KTYPE, VTYPE, CMP, ALLOCATOR > &obj, std::ostream &s)
 the partial template specialization of std::map<KTYPE,VTYPE,CMP,ALLOCATOR> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"
template<class KTYPE, class VTYPE, class CMP, class ALLOCATOR>
std::ostream & toStream (const GaudiUtils::VectorMap< KTYPE, VTYPE, CMP, ALLOCATOR > &obj, std::ostream &s)
 the partial template specialization of GaudiUtils::VectorMap<KTYPE,VTYPE,CMP,ALLOCATOR> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"
template<class KTYPE, class VTYPE, class MAP>
std::ostream & toStream (const GaudiUtils::Map< KTYPE, VTYPE, MAP > &obj, std::ostream &s)
 the partial template specialization of GaudiUtils::Map<KTYPE,VTYPE,MAP> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"
template<class KTYPE, class VTYPE, class HASH, class MAP>
std::ostream & toStream (const GaudiUtils::HashMap< KTYPE, VTYPE, HASH, MAP > &obj, std::ostream &s)
 the partial template specialization of GaudiUtils::HashMap<KTYPE,VTYPE,HASH,MAP> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"
template<class TYPE>
std::string toString (const TYPE &obj)
 the generic implementation of the type conversion to the string

Function Documentation

std::string Gaudi::Utils::formatAsTableRow ( const std::string &  name,
const std::string &  group,
const StatEntity &  entity,
const bool  flag = true,
const std::string &  format1 = " %|15.15s|%|-15.15s|%|32t||%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |",
const std::string &  format2 = "*%|15.15s|%|-15.15s|%|32t||%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%|    -----    |   -----   |" 
)

print the counter in a form of the table row 

   std::string header = "       Counter :: Group         |     #     |";
   header += "    sum     | mean/eff^* | rms/err^*  |     min     |";
   header += "     max     |") ;

   info() << header << endmsg ;

    // loop over counters:
    for ( ... )
     {
      const std::string& name    = ... ;
      const std::string& group   = .. ;
      const StatEntity&  counter = ... ;
      info() << formatAsTableRow ( name , group , counter ) << endmsg ;
     }

The table row for the regular counter is printed as 8 fields

  • counter name (string)
  • counter group (string)
  • number of entries (long)
  • overall sum (double)
  • mean value (double)
  • RMS (double)
  • minimal value (double)
  • maximal value (double)

The printout is performed according to the format, described in optional "format1" parameter using Boost Format Library. The incredible flexibility of Boost Format Library allows to customize the overall layout of the table form minor change the format of individual columns to the overall reshuffling of the reformatted columns

If the parameter "flag" is set to true AND either the counter name or counter group, converted to the lowercase contains one of the substrings: "eff","acc","fltr","filt","pass" AND (of course) the content of the counter allows the interpretation of the counter as the binomial efficiency counter, the printout is performed using 6 fields ("binomial efficiency format")

  • counter name (string)
  • counter group (string)
  • number of entries (long)
  • overall sum (double)
  • binomial efficiency [perCent] (double)
  • uncertainty in binomial efficiency [perCent] (double)

The printout is performed according to format, specified by parameter "format2"

See also:
http://boost.org/libs/format
Parameters:
name the name associated with the counter
group the group associated with the counter
counter counter to be printed
flag use the special format for "efficiency" rows
format1 row format for the regular rows
format2 the special row format for the "efficiency" rows
Returns:
formatted row in the table

Definition at line 372 of file StatEntity.cpp.

00378 {
00379   using namespace boost::io ;
00380   if ( flag && ( effCounter ( name ) || effCounter ( group ) ) 
00381        && 0 <= counter.eff() && 0 <= counter.effErr() ) 
00382   {
00383     boost::format fmt( format2 ) ;
00384     fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
00385     fmt 
00386       % ( "\"" + name  + ":"  ) 
00387       % ( ":"  + group + "\"" ) 
00388       %   counter.nEntries () 
00389       %   counter.flag     () 
00390       % ( counter.eff      () * 100 ) 
00391       % ( counter.effErr   () * 100 ) ;
00392     return fmt.str() ;
00393   }
00394   boost::format fmt  ( format1 ) ;
00395   fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
00396   fmt 
00397     % ( "\""  + name  + ":"  ) 
00398     % ( ":"   + group + "\"" ) 
00399     %   counter.nEntries () 
00400     %   counter.flag     () 
00401     %   counter.flagMean () 
00402     %   counter.flagRMS  ()  
00403     %   counter.flagMin  () 
00404     %   counter.flagMax  () ;
00405   return fmt.str() ;
00406 }

std::string Gaudi::Utils::formatAsTableRow ( const std::string &  name,
const StatEntity &  counter,
const bool  flag = true,
const std::string &  format1 = " %|-15.15s|%|17t||%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |",
const std::string &  format2 = "*%|-15.15s|%|17t||%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%|   -----   |   -----   |" 
)

print the counter in a form of the table row 

  std::string header = "     Counter     |     #     |    sum     |" ;
  header += " mean/eff^* | rms/err^*  |     min     |     max     |" ;

   info() << header << endmsg ;

    // loop over counters:
    for ( ... )
     {
      const std::string& name    = ... ;
      const StatEntity&  counter = ... ;
      info() << formatAsTableRow( name , counter ) << endmsg ;
     }

The table row for the regular counter is printed as 7 fields

  • counter name (string)
  • number of entries (long)
  • overal sum (double)
  • mean value (double)
  • RMS (double)
  • minimal value (double)
  • maximal value (double)

The printout is performed according to the format, described in optional "format1" parameter using Boost Format Library. The incredible flexibility of Boost Format Library allows to customize the overall layout of the table form minor change the format of individual columns to the overall reshuffling of the reformatted columns

If the parameter "flag" is set to true AND the counter name, converted to the lowercase constant one of the substrings: "eff","acc","fltr","filt","pass" AND (of course) the content of the counter allows the interpretation of the counter as the binomial efficiency counter, the printout is performed using 5 fields ("binomial efficiency format")

  • counter name (string)
  • number of entries (long)
  • overall sum (double)
  • binomial efficiency [perCent] (double)
  • uncertainty in binomial efficiency [perCent] (double)

The printout is performed according to format, specified by parameter "format2"

See also:
http://boost.org/libs/format
Parameters:
name the name associated with the counter
counter counter to be printed
flag use the special format for "efficiency" rows
format1 row format for the regular rows
format2 special row format for the "efficiency" rows
Returns:
formatted row in the table

Definition at line 329 of file StatEntity.cpp.

00334 {
00335   using namespace boost::io ;
00336   if ( flag && effCounter ( name ) && 0 <= counter.eff() && 0 <= counter.effErr() ) 
00337   {
00338     boost::format fmt( format2 ) ;
00339     fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
00340     fmt 
00341       % ( "\"" + name + "\"" ) 
00342       %   counter.nEntries ()       
00343       %   counter.flag     () 
00344       % ( counter.eff      () * 100 ) 
00345       % ( counter.effErr   () * 100 ) ;
00346     return fmt.str() ;
00347   }
00348   boost::format fmt  ( format1 ) ;
00349   fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
00350   fmt 
00351     % ( "\"" + name + "\"" ) 
00352     %   counter.nEntries () 
00353     %   counter.flag     () 
00354     %   counter.flagMean () 
00355     %   counter.flagRMS  ()  
00356     %   counter.flagMin  () 
00357     %   counter.flagMax  () ;
00358   return fmt.str() ;
00359 }

std::string Gaudi::Utils::formatAsTableRow ( const StatEntity &  counter,
const bool  flag,
const std::string &  format1 = " |%|7d| |%|11.7g| |%|#11.5g| |%|#10.5g| |%|#10.5g| |%|#10.5g| |",
const std::string &  format2 = "*|%|7d| |%|11.5g| |(%|#9.7g| +- %|-#8.6g|)%%|   -----   |   -----   |" 
)

print the counter in a form of the table row 

    // loop over counters:
    for ( ... )
     {
      const StatEntity&  counter = ... ;
      info() << formatAsTableRow( counter , true ) << endmsg ;
     }

The regular counter is printed as 6 fields

  • number of entries (long)
  • overal sum (double)
  • mean value (double)
  • RMS (double)
  • minimal value (double)
  • maximal value (double)

The printout is performed according to the format, described in optional "format1" parameter using Boost Format Library. The incredible flexibility of Boost Format Library allows to customize the overall layout of the table form minor change the format of individual columns to the overall reshuffling of the reformatted columns

If the parameter "flag" is set to true, AND the content of the counter allows the interpretation of the counter as binomial efficiency counter, the printout is performed in a form of 4 numbers:

  • number of entries (long)
  • overall sum (double)
  • binomial efficiency [perCent] (double)
  • uncertainty in binomial efficiency [perCent] (double)

The printout is performed according to format, specified by parameter "format2"

See also:
http://boost.org/libs/format
Parameters:
name the name associated with the counter
counter counter to be printed
flag use the special format for "efficiency" rows
format1 row format for the regular rows
format2 special row format for the "efficiency" rows
Returns:
formatted row in the table

Definition at line 290 of file StatEntity.cpp.

00294 {
00295   using namespace boost::io ;
00296   if ( flag && 0 <= counter.eff() && 0 <= counter.effErr() ) 
00297   {
00298     boost::format fmt( format2 ) ;
00299     fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
00300     fmt 
00301       %   counter.nEntries ()       
00302       %   counter.flag     () 
00303       % ( counter.eff      () * 100 ) 
00304       % ( counter.effErr   () * 100 ) ;
00305     return fmt.str() ;
00306   }
00307   boost::format fmt  ( format1 ) ;
00308   fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
00309   fmt 
00310     %   counter.nEntries () 
00311     %   counter.flag     () 
00312     %   counter.flagMean () 
00313     %   counter.flagRMS  ()  
00314     %   counter.flagMin  () 
00315     %   counter.flagMax  () ;
00316   return fmt.str() ;
00317 }

IAlgorithm * Gaudi::Utils::getAlgorithm ( const std::vector< IAlgorithm * > &  lst,
const AlgSelector &  sel 
)

simple function to get the algorithm from Context Service 

  // get the selector
  const AlgSelector& selector = ... ;

  // get the list of algorithms:
  const std::vector<IAlgorithm*>& algs = ... ;

  // get the appropriate algorithm:
  IAlgorithm* alg = getAlgorithm ( algs  , selector ) ;

See also:
IAlgContextSvc

Gaudi::Utils::AlgSelector

Parameters:
lst list of the algorithms
sel the selection functor
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 40 of file GetAlg.cpp.

00042 {
00043   for ( std::vector<IAlgorithm*>::const_reverse_iterator it = lst.rbegin() ; 
00044         lst.rend() != it ; ++it ) 
00045   {
00046     // use the selector:
00047     if ( sel ( *it ) ) { return *it ; }  // return 
00048   }
00049   return 0 ;
00050 }

IAlgorithm * Gaudi::Utils::getAlgorithm ( const IAlgContextSvc *  svc,
const AlgSelector &  sel 
)

simple function to get the algorithm from Context Service 

  // get the selector
  const AlgSelector& selector = ... ;

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  // get the appropriate algorithm:
  IAlgorithm* alg = getAlgorithm ( svc , selector ) ;

See also:
IAlgContextSvc

Gaudi::Utils::AlgSelector

Parameters:
svc pointer to Algororithm Contetx Service
sel the selection functor
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 29 of file GetAlg.cpp.

00031 {
00032   if ( 0 == svc ) { return  0 ; } // RETURN 
00033   return getAlgorithm ( svc->algorithms() , sel ) ;
00034 }

GaudiAlgorithm * Gaudi::Utils::getGaudiAlg ( const IAlgContextSvc *  svc  ) 

simple function to extract the last active GaudiAlgorithm from the context 

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  GaudiAlgorithm* ga = getGaudiAlg ( svc ) ;

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 67 of file GetAlgs.cpp.

00068 { return getAlg<GaudiAlgorithm> ( svc ) ; }

GaudiSequencer * Gaudi::Utils::getGaudiSequencer ( const IAlgContextSvc *  svc  ) 

simple function to extract the last active GaudiSequencer from the context 

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  GaudiSequencer* sa = getGaudiSequencer ( svc ) ;

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 127 of file GetAlgs.cpp.

00128 { return getAlg<GaudiSequencer> ( svc ) ; }

GaudiHistoAlg * Gaudi::Utils::getHistoAlg ( const IAlgContextSvc *  svc  ) 

simple function to extract the last active GaudiHistoAlg from the context 

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  GaudiHistoAlg* ha = getHistoAlg ( svc ) ;

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 87 of file GetAlgs.cpp.

00088 { return getAlg<GaudiHistoAlg> ( svc ) ; }

const Property * Gaudi::Utils::getProperty ( const std::vector< const Property * > *  p,
const std::string &  name 
)

get the property by name from the list of the properties 

   IJobOptionsSvc* svc = ... ;

   const std::string client = ... ;

  // get the property:
  const Property* context =
      getProperty ( svc->getProperties( client ) , "Context" )

See also:
IJobOptionsSvc
Parameters:
p list of properties
name property name (case insensitive)
Returns:
property with the given name (if exists), NULL otherwise
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 441 of file Property.cpp.

00443 {
00444   // trivial check 
00445   if ( 0 == p             ) { return 0 ; }                 // RETURN 
00446   std::vector<const Property*>::const_iterator ifound = 
00447     std::find_if ( p->begin() , p->end() , _ByName_( name ) ) ;
00448   if ( p->end() == ifound ) { return 0 ; }                 // RETURN 
00449   // OK 
00450   return *ifound ;
00451 }

Property * Gaudi::Utils::getProperty ( const IInterface *  p,
const std::string &  name 
)

simple function which gets the property with given name from the component 

  const IInterface* p = ... ;

  const Property* pro = getProperty( p , "Context" ) ;

Parameters:
p pointer to IInterface object
name property name (case insensitive)
Returns:
property with the given name (if exists), NULL otherwise
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 374 of file Property.cpp.

00375 {
00376   // trivial check 
00377   if ( 0 ==  p        ) { return 0 ; }                                // RETURN 
00378   // remove const-qualifier 
00379   IInterface* _i = const_cast<IInterface*>( p ) ;
00380   if ( 0 == _i        ) { return 0 ; }                                // RETURN
00381   SmartIF<IProperty> property ( _i ) ;
00382   if ( !property      ) { return 0 ; }                                // RETURN
00383   return getProperty ( property , name ) ;
00384 }

Property * Gaudi::Utils::getProperty ( const IProperty *  p,
const std::string &  name 
)

simple function which gets the property with given name from the component 

  const IProperty* p = ... ;

  const Property* pro = getProperty( p , "Context" ) ;

Parameters:
p pointer to IProperty object
name property name (case insensitive)
Returns:
property with the given name (if exists), NULL otherwise
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 338 of file Property.cpp.

00340 {
00341   // trivial check 
00342   if ( 0 == p      ) { return 0 ; }                          // RETURN 
00343   // get all properties 
00344   typedef std::vector<Property*> List ;
00345   const List& lst = p->getProperties() ;
00346   if ( lst.empty() ) { return 0 ; }                          // RETURN 
00347   // comparison criteria:
00348   List::const_iterator ifound = 
00349     std::find_if ( lst.begin() , lst.end() , _ByName_( name ) ) ;
00350   if ( lst.end() == ifound ) { return 0 ; }                  // RETURN 
00351   // OK 
00352   return *ifound ;
00353 }

IAlgorithm * Gaudi::Utils::getSequencer ( const IAlgContextSvc *  svc  ) 

simple function to extract the last active "Sequencer" () GaudiSequencer or simple Sequencer) from the context 

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  IAlgorithm* a = getSequencer ( svc ) ;

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 167 of file GetAlgs.cpp.

00168 {
00169   if ( 0 == svc            ) { return 0 ; }  // RETURN
00170   //
00171   typedef IAlgContextSvc::Algorithms ALGS ;
00172   const ALGS& algs = svc->algorithms() ;
00173   AlgTypeSelector<GaudiSequencer> sel1 ;
00174   AlgTypeSelector<Sequencer>      sel2 ;
00175   for ( ALGS::const_reverse_iterator it = algs.rbegin() ; 
00176         algs.rend() != it ; ++it ) 
00177   {
00178     if ( sel1 ( *it ) ) { return *it ; }
00179     if ( sel2 ( *it ) ) { return *it ; }
00180   }
00181   return 0 ;                                    // RETURN ;
00182 }

Sequencer * Gaudi::Utils::getSequencerAlg ( const IAlgContextSvc *  svc  ) 

simple function to extract the last active Sequencer from the context 

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  Sequencer* sa = getSequencerAlg ( svc ) ;

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 146 of file GetAlgs.cpp.

00147 { return getAlg<Sequencer> ( svc ) ; }

GaudiTupleAlg * Gaudi::Utils::getTupleAlg ( const IAlgContextSvc *  svc  ) 

simple function to extract the last active GaudiTupleAlg from the context 

  // get the context service:
  const IAlgContextSvc* svc = ... ;

  GaudiTupleAlg* ta = getTupleAlg ( svc ) ;

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-09-07

Definition at line 107 of file GetAlgs.cpp.

00108 { return getAlg<GaudiTupleAlg> ( svc ) ; }

bool Gaudi::Utils::hasProperty ( const std::vector< const Property * > *  p,
const std::string &  name 
)

check the property by name from the list of the properties 

   IJobOptionsSvc* svc = ... ;

   const std::string client = ... ;

  // get the property:
  bool context =
      hasProperty ( svc->getProperties( client ) , "Context" )

See also:
IJobOptionsSvc
Parameters:
p list of properties
name property name (case insensitive)
Returns:
true if the property exists
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 410 of file Property.cpp.

00412 {
00413   // delegate to another method 
00414   return 0 != getProperty ( p , name ) ;
00415 }

bool Gaudi::Utils::hasProperty ( const IInterface *  p,
const std::string &  name 
)

simple function which check the existence of the property with the given name. 

  IInterface* p = .

  const bool = hasProperty( p , "Context" ) ;

Parameters:
p pointer to IInterface object (any component)
name property name (case insensitive)
Returns:
true if "p" has a property with such name
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 204 of file Property.cpp.

00206 {
00207   // trivial check 
00208   if ( 0 ==  p ) { return false ; }                                // RETURN 
00209   // gelegate to another method 
00210   return 0 != getProperty ( p , name ) ;
00211 }

bool Gaudi::Utils::hasProperty ( const IProperty *  p,
const std::string &  name 
)

simple function which check the existence of the property with the given name. 

  const IProperty* p = ... ;

  const bool = hasProperty( p , "Context" ) ;

Parameters:
p pointer to IProperty object
name property name (case insensitive)
Returns:
true if "p" has a property with such name
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 232 of file Property.cpp.

00234 {
00235   if ( 0 == p ) { return false ; }
00236   // delegate the actual work to another method ;
00237   return 0 != getProperty ( p , name ) ;
00238 }

template<class TYPE>
StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const SimpleProperty< TYPE > &  value,
const std::string &  doc = "" 
) [inline]

simple function to set the property of the given object from another property 

  IInterface* component = ... ;

  SimpleProperty<std::vector<int> > m_data = ... ;

  StatusCode sc = setProperty ( component , "Data" ,  prop  ) ;

Parameters:
component component which needs to be configured
name name of the property
value the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1423 of file Property.h.

01427     {
01428       const Property* property = &value ;
01429       return setProperty ( component , name , property , doc ) ;
01430     }

StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const Property &  property,
const std::string &  doc = "" 
)

simple function to set the property of the given object from another property 

  IInterface* component = ... ;

  const Property& prop = ... ;
  StatusCode sc = setProperty ( component , "Data" ,  prop  ) ;

Parameters:
component component which needs to be configured
name name of the property
property the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 679 of file Property.cpp.

00683 { return setProperty ( component , name , &property , doc ) ; }

StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const Property *  property,
const std::string &  doc = "" 
)

simple function to set the property of the given object from another property 

  IInterface* component = ... ;

  const Property* prop = ... ;
  StatusCode sc = setProperty ( component , "Data" ,  prop  ) ;

Parameters:
component component which needs to be configured
name name of the property
property the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 645 of file Property.cpp.

00649 {
00650   if ( 0 == component ) { return StatusCode::FAILURE ; }
00651   SmartIF<IProperty> prop  ( component ) ;
00652   if ( !prop          ) { return StatusCode::FAILURE ; }
00653   return setProperty ( prop  , name , property , doc ) ;
00654 }

template<unsigned N>
StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const char(&)  value[N],
const std::string &  doc = "" 
) [inline]

the full specialization of the method setProperty( IInterface, std::string, const TYPE&) for C-arrays

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1334 of file Property.h.

01338     {
01339       if ( 0 == component ) { return StatusCode::FAILURE ; }
01340       const std::string val = std::string ( value , value + N ) ;
01341       return setProperty ( component , name , val , doc ) ;
01342     }

StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const char *  value,
const std::string &  doc = "" 
)

the full specialization of the method setProperty( IInterface , std::string, const TYPE&) for C-strings

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 613 of file Property.cpp.

00617 {
00618   const std::string val = std::string( value ) ;
00619   return setProperty ( component , name , val , doc ) ;
00620 }

StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const std::string &  value,
const std::string &  doc = "" 
)

the full specialization of the method setProperty( IInterface , std::string, const TYPE&) for standard strings

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 588 of file Property.cpp.

00592 {
00593   if ( 0 == component ) { return StatusCode::FAILURE ; }
00594   SmartIF<IProperty> property ( component ) ;
00595   if ( !property      ) { return StatusCode::FAILURE ; }
00596   return setProperty ( property , name , value , doc ) ;
00597 }

template<class TYPE>
StatusCode Gaudi::Utils::setProperty ( IInterface *  component,
const std::string &  name,
const TYPE &  value,
const std::string &  doc = "" 
) [inline]

simple function to set the property of the given object from the value 

  IInterface* component = ... ;

  std::vector<double> data = ... ;
  StatusCode sc = setProperty ( component , "Data" ,  data ) ;

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1272 of file Property.h.

01276     {
01277       if ( 0 == component ) { return StatusCode::FAILURE ; }
01278       SmartIF<IProperty> property ( component ) ;
01279       if ( !property      ) { return StatusCode::FAILURE ; }
01280       return setProperty ( property , name , value , doc ) ;
01281     }

template<class TYPE>
StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const SimpleProperty< TYPE > &  value,
const std::string &  doc = "" 
) [inline]

simple function to set the property of the given object from another property 

  IProperty* component = ... ;

  SimpleProperty<std::vector<int> > m_data = ... ;

  StatusCode sc = setProperty ( component , "Data" ,  prop  ) ;

Parameters:
component component which needs to be configured
name name of the property
value the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1241 of file Property.h.

01245     {
01246       const Property* property = &value ;
01247       return setProperty ( component , name , property , doc ) ;
01248     }

StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const Property &  property,
const std::string &  doc = "" 
)

simple function to set the property of the given object from another property 

  IProperty* component = ... ;

  const Property& prop = ... ;
  StatusCode sc = setProperty ( component , "Data" ,  prop  ) ;

Parameters:
component component which needs to be configured
name name of the property
property the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 568 of file Property.cpp.

00572 { return setProperty ( component , name , &property , doc ) ; }

StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const Property *  property,
const std::string &  doc = "" 
)

simple function to set the property of the given object from another property 

  IProperty* component = ... ;

  const Property* prop = ... ;
  StatusCode sc = setProperty ( component , "Data" ,  prop  ) ;

Parameters:
component component which needs to be configured
name name of the property
property the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 531 of file Property.cpp.

00535 {
00536   if ( 0 == component || 0 == property   ) { return StatusCode::FAILURE ; }
00537   if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
00538   Property* p = getProperty ( component , name ) ;
00539   if ( 0 == p                            ) { return StatusCode::FAILURE ; }
00540   if ( !p->assign ( *property )          ) { return StatusCode::FAILURE ; }
00541   if ( !doc.empty()  ) { p->setDocumentation( doc ) ; }
00542   return StatusCode::SUCCESS ;
00543 }

template<unsigned N>
StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const char(&)  value[N],
const std::string &  doc = "" 
) [inline]

the full specialization of the method setProperty( IProperty, std::string, const TYPE&) for C-arrays

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1110 of file Property.h.

01114     {
01115       if ( 0 == component                    ) { return StatusCode::FAILURE ; }
01116       const std::string val = std::string ( value , value + N ) ;
01117       return setProperty ( component , name , val , doc ) ;
01118     }

StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const char *  value,
const std::string &  doc = "" 
)

the full specialization of the method setProperty( IProperty, std::string, const TYPE&) for C-strings

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 468 of file Property.cpp.

00472 {
00473   const std::string val = std::string( value ) ;
00474   return Gaudi::Utils::setProperty ( component , name , val , doc ) ;   
00475 }

StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const std::string &  value,
const std::string &  doc = "" 
)

the full specialization of the previous method setProperty( IProperty, std::string, const TYPE&) for standard strings

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 491 of file Property.cpp.

00495 {
00496   if ( 0 == component ) { return StatusCode::FAILURE ; }   // RETURN
00497   if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
00498   StatusCode sc = component -> setProperty ( name , value ) ;
00499   if ( !doc.empty() ) 
00500   {
00501     Property* p = getProperty( component , name ) ;
00502     if ( 0 != p ) { p -> setDocumentation ( doc ) ; }
00503   }
00504   sc.ignore() ;
00505   return sc ;
00506 }

template<class TYPE>
StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const TYPE &  value 
) [inline]

simple function to set the property of the given object from the value 

  IProperty* component = ... ;

  std::vector<double> data = ... ;
  StatusCode sc = setProperty ( componet , "Data" ,  data ) ;

Note: the interface IProperty allows setting of the properties either directly from other properties or from strings only

Parameters:
component component which needs to be configured
name name of the property
value value of the property
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1052 of file Property.h.

01055     { return setProperty ( component , name , value , std::string() ) ; }

template<class TYPE>
StatusCode Gaudi::Utils::setProperty ( IProperty *  component,
const std::string &  name,
const TYPE &  value,
const std::string &  doc 
) [inline]

simple function to set the property of the given object from the value 

  IProperty* component = ... ;

  std::vector<double> data = ... ;
  StatusCode sc = setProperty ( componet , "Data" ,  data ) ;

Note: the interface IProperty allows setting of the properties either directly from other properties or from strings only

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13
  IProperty* component = ... ;

  std::vector<double> data = ... ;
  StatusCode sc = setProperty ( component , "Data" ,  data ) ;

  std::map<std::string,double> cuts = ... ;
  sc = setProperty ( component , "Cuts" , cuts ) ;

  std::map<std::string,std::string> dict = ... ;
  sc = setProperty ( component , "Dictionary" , dict ) ;

Note: the native interface IProperty allows setting of the properties either directly from other properties or from strings only

Parameters:
component component which needs to be configured
name name of the property
value value of the property
doc the new documentation string
See also:
IProperty
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2007-05-13

Definition at line 1152 of file Property.h.

01156     {
01157       if ( 0 == component ) { return StatusCode::FAILURE ; }   // RETURN
01158       if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
01159       const std::string val = Gaudi::Utils::toString ( value ) ;
01160       return Gaudi::Utils::setProperty ( component , name , val , doc ) ;
01161     }

template<class KTYPE, class VTYPE, class HASH, class MAP>
std::ostream& Gaudi::Utils::toStream ( const GaudiUtils::HashMap< KTYPE, VTYPE, HASH, MAP > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of GaudiUtils::HashMap<KTYPE,VTYPE,HASH,MAP> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"

See also:
GaudiUtils::VectorMap
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 255 of file ToStream.h.

00256     {
00257       s << "{ ";
00258       for ( typename GaudiUtils::HashMap<KTYPE,VTYPE,HASH,MAP>::const_iterator cur = obj.begin() ;
00259             obj.end() != cur ; ++cur )
00260       {
00261         if ( obj.begin() != cur ) { s << " , " ; }
00262         toStream ( cur -> first  , s ) ;
00263         s << " : " ;
00264         toStream ( cur -> second , s ) ;
00265       }
00266       return s << " }";
00267     }

template<class KTYPE, class VTYPE, class MAP>
std::ostream& Gaudi::Utils::toStream ( const GaudiUtils::Map< KTYPE, VTYPE, MAP > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of GaudiUtils::Map<KTYPE,VTYPE,MAP> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"

See also:
GaudiUtils::VectorMap
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 231 of file ToStream.h.

00232     {
00233       s << "{ ";
00234       for ( typename GaudiUtils::Map<KTYPE,VTYPE,MAP>::const_iterator cur = obj.begin() ;
00235             obj.end() != cur ; ++cur )
00236       {
00237         if ( obj.begin() != cur ) { s << " , " ; }
00238         toStream ( cur -> first  , s ) ;
00239         s << " : " ;
00240         toStream ( cur -> second , s ) ;
00241       }
00242       return s << " }";
00243     }

template<class KTYPE, class VTYPE, class CMP, class ALLOCATOR>
std::ostream& Gaudi::Utils::toStream ( const GaudiUtils::VectorMap< KTYPE, VTYPE, CMP, ALLOCATOR > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of GaudiUtils::VectorMap<KTYPE,VTYPE,CMP,ALLOCATOR> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"

See also:
GaudiUtils::VectorMap
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 207 of file ToStream.h.

00208     {
00209       s << "{ ";
00210       for ( typename GaudiUtils::VectorMap<KTYPE,VTYPE,CMP,ALLOCATOR>::const_iterator cur = obj.begin() ;
00211             obj.end() != cur ; ++cur )
00212       {
00213         if ( obj.begin() != cur ) { s << " , " ; }
00214         toStream ( cur -> first  , s ) ;
00215         s << " : " ;
00216         toStream ( cur -> second , s ) ;
00217       }
00218       return s << " }";
00219     }

template<class KTYPE, class VTYPE, class CMP, class ALLOCATOR>
std::ostream& Gaudi::Utils::toStream ( const std::map< KTYPE, VTYPE, CMP, ALLOCATOR > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of std::map<KTYPE,VTYPE,CMP,ALLOCATOR> printout the map is printed a'la Python dict: " ( a : b , c: d , e : f )"

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 183 of file ToStream.h.

00184     {
00185       s << "{ ";
00186       for ( typename std::map<KTYPE,VTYPE,CMP,ALLOCATOR>::const_iterator cur = 
00187               obj.begin() ; obj.end() != cur ; ++cur )
00188       {
00189         if ( obj.begin() != cur ) { s << " , " ; }
00190         toStream ( cur -> first  , s ) ;
00191         s << " : " ;
00192         toStream ( cur -> second , s ) ;
00193       }
00194       return s << " }";
00195     }

template<class TYPE, class CMP, class ALLOCATOR>
std::ostream& Gaudi::Utils::toStream ( const std::set< TYPE, CMP, ALLOCATOR > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of std::set<TYPE,CMP,ALLOCATOR> printout.

The vector is printed a'la Python list: "[ a, b, c ]"

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 162 of file ToStream.h.

00163     {
00164       s << "[ ";
00165       for ( typename std::set<TYPE,CMP,ALLOCATOR>::const_iterator cur = obj.begin() ;
00166             obj.end() != cur ; ++cur )
00167       {
00168         if ( obj.begin() != cur ) { s << " , "; }
00169         toStream ( *cur , s ) ;
00170       }
00171       return s << " ]";
00172     }

template<class TYPE, class ALLOCATOR>
std::ostream& Gaudi::Utils::toStream ( const std::list< TYPE, ALLOCATOR > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of std::list<TYPE,ALLOCATOR> printout.

The vector is printed a'la Python list: "[ a, b, c ]"

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2007-04-08

Definition at line 142 of file ToStream.h.

00143     {
00144       s << "[ ";
00145       for ( typename std::list<TYPE,ALLOCATOR>::const_iterator cur = obj.begin() ;
00146             obj.end() != cur ; ++cur )
00147       {
00148         if ( obj.begin() != cur ) { s << " , "; }
00149         toStream ( *cur , s ) ;
00150       }
00151       return s << " ]";
00152     }

template<class TYPE, class ALLOCATOR>
std::ostream& Gaudi::Utils::toStream ( const std::vector< TYPE, ALLOCATOR > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of std::vector<TYPE,ALLOCATOR> printout.

The vector is printed a'la Python list: "[ a, b, c ]"

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 122 of file ToStream.h.

00123     {
00124       s << "[ ";
00125       for ( typename std::vector<TYPE,ALLOCATOR>::const_iterator cur = obj.begin() ;
00126             obj.end() != cur ; ++cur )
00127       {
00128         if ( obj.begin() != cur ) { s << " , "; }
00129         toStream ( *cur , s ) ;
00130       }
00131       return s << " ]";
00132     }

template<class KTYPE, class VTYPE>
std::ostream& Gaudi::Utils::toStream ( const std::pair< KTYPE, VTYPE > &  obj,
std::ostream &  s 
) [inline]

the partial template specialization of std::pair<KTYPE,VTYPE> printout the pair is printed a'la Python tuple: " ( a , b )"

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 105 of file ToStream.h.

00106     {
00107       s << "( "  ; 
00108       toStream ( obj.first  , s ) ;
00109       s << " , " ;
00110       toStream ( obj.second , s ) ;
00111       return s << " )" ;
00112     }

std::ostream& Gaudi::Utils::toStream ( const long double  obj,
std::ostream &  s 
) [inline]

the printout of long double values with the reasonable precision

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 90 of file ToStream.h.

00091     { 
00092       const int p = s.precision() ;
00093       return s << std::setprecision ( 10 ) << obj << std::setprecision ( p ) ;
00094     }

std::ostream& Gaudi::Utils::toStream ( const double  obj,
std::ostream &  s 
) [inline]

the printout of double values with the reasonable precision

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 80 of file ToStream.h.

00081     { 
00082       const int p = s.precision() ;
00083       return s << std::setprecision (  8 ) << obj << std::setprecision ( p ) ;
00084     }

std::ostream& Gaudi::Utils::toStream ( const float  obj,
std::ostream &  s 
) [inline]

the printout of float values with the reasonable precision

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 70 of file ToStream.h.

00071     { 
00072       const int  p = s.precision() ;
00073       return s << std::setprecision (  6 ) << obj << std::setprecision ( p ) ;
00074     }

std::ostream& Gaudi::Utils::toStream ( const bool  obj,
std::ostream &  s 
) [inline]

the printout of boolean values "a'la Python"

Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-09-09

Definition at line 63 of file ToStream.h.

00064     { return s << ( obj ? "True" : "False" ) ; }

std::ostream& Gaudi::Utils::toStream ( const std::string &  obj,
std::ostream &  s 
) [inline]

the printtout of the strings.

the string is printed a'la Python using the quotes

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 50 of file ToStream.h.

00051     {
00052       if ( std::string::npos == obj.find('\'') )
00053       { s << "\'" << obj << "\'" ; }
00054       else 
00055       { s << "\"" << obj << "\"" ; }
00056       return s ;
00057     }

template<class TYPE>
std::ostream & Gaudi::Utils::toStream ( const TYPE &  obj,
std::ostream &  s 
) [inline]

the generic implementation of the printout to the std::ostream

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 276 of file ToStream.h.

00277     { return s << obj ; }

template<class TYPE>
std::string Gaudi::Utils::toString ( const TYPE &  obj  )  [inline]

the generic implementation of the type conversion to the string

Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12
See also:
Gaudi::Utils::toStream
Todo:
need to be compared with boost::lexical_cast

Definition at line 288 of file ToStream.h.

00289     {
00290       std::ostringstream s;
00291       toStream ( obj , s);
00292       return s.str();
00293     }

Generated at Mon Sep 7 18:26:05 2009 for Gaudi Framework, version v21r4 by Doxygen version 1.5.6 written by Dimitri van Heesch, © 1997-2004