| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 2010

# 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< const TYPE >
| the template specialization for const types More...
struct | GetData< TYPE * >
| the template specialization for pointer types More...
struct | GetData< TYPE & >
| the template specialization for reference types More...
struct | CheckData
| Helper structure for implementation of "exists"-functions for GaudiCommon<BASE>. More...
struct | CheckData< Gaudi::Range_< std::vector< const TYPE * > > >
| the template specialization for ranges More...
struct | CheckData< Gaudi::NamedRange_< std::vector< const TYPE * > > >
| the template specialization for ranges More...
struct | CheckData< TYPE * >
| the template specialization for pointer types More...
struct | CheckData< TYPE & >
| the template specialization for reference types More...
struct | CheckData< const TYPE >
| the template specialization for 'const'-type More...
struct | GetOrCreateData
| Helper structure for implementation of "getOrCreate"-functions for GaudiCommon<BASE>. More...
struct | GetOrCreateData< Gaudi::Range_< std::vector< const TYPE * > >, TYPE2 >
struct | GetOrCreateData< Gaudi::NamedRange_< std::vector< const TYPE * > >, TYPE2 >
struct | GetOrCreateData< TYPE, TYPE2 * >
struct | GetOrCreateData< TYPE *, TYPE2 >
struct | GetOrCreateData< TYPE *, TYPE2 * >
struct | GetOrCreateData< TYPE, const TYPE2 >
struct | GetOrCreateData< const TYPE, TYPE2 >
struct | GetOrCreateData< const TYPE, const TYPE2 >
struct | GetOrCreateData< TYPE, TYPE2 & >
struct | GetOrCreateData< TYPE &, TYPE2 >
struct | GetOrCreateData< TYPE &, TYPE2 & >
struct | PropertyTypeTraits< boost::array< T, N > >
| the specialization of property-traits for class boost::array to take care the non-trivial assignements and constructors for this class More...
struct | PropertyTypeTraits< T(&)[N]>
struct | PropertyTypeTraits< T[N]>
| specialization for arrays More...
struct | PropertyTypeTraits< const T(&)[N]>
| specialiation for const-arrays More...
struct | PropertyTypeTraits< char(&)[N]>
| specialisation for C-strings More...
class | AlgContext
| Helper "sentry" class to automatize the safe register/unregister the algorithm's context. More...
class | LockedChrono
| Helper object, useful for measurement of CPU-performance of highly-recursive structures, e.g. More...
class | MapBase
| Helper base-class to allow the generic Python-decoration for all "map-like" classes in Gaudi. More...
struct | PropertyTypeTraits
| helper structure to define the types for properties 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...
class | SignalMonitorSvc
| Implementation of Gaudi::ISignalMonitor. More...
class | StopSignalHandler
| Service that stop the processing if a signal is received. 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
template<class ITERATOR>
std::ostream & | toStream (ITERATOR first,ITERATOR last,std::ostream &s,const std::string &open,const std::string &close,const std::string &delim)
| the helper function to print the sequence
template<class TYPE, std::size_t N>
std::ostream & | toStream (const boost::array< TYPE, N > &obj, std::ostream &s)
| printout of class boost::array The format is "Python's tuple"
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
GAUDI_API std::ostream & | toStream (const Gaudi::StringKey &key, std::ostream &s)
| send the object to stream (needed to use it as property)
template<class SCALAR>
std::ostream & | toStream (const SCALAR &, std::ostream &)
template<class SCALAR, unsigned int N>
std::ostream & | toStream (const ROOT::Math::SVector< SCALAR, N > &obj, std::ostream &s)
| the general streaming function for SVector using python-tupel format
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, const int prec=6)
| the printout of float values with the reasonable precision
std::ostream & | toStream (const double obj, std::ostream &s, const int prec=8)
| the printout of double values with the reasonable precision
std::ostream & | toStream (const long double obj, std::ostream &s, const int prec=10)
| 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, unsigned int N>
std::ostream & | toStream (TYPE(&obj)[N], std::ostream &s)
| the specialization for C-arrays, a'la python tuple
template<class TYPE, unsigned int N>
std::ostream & | toStream (const TYPE(&obj)[N], std::ostream &s)
| the specialization for C-arrays, a'la python tuple
template<unsigned int N>
std::ostream & | toStream (char(&obj)[N], std::ostream &s)
| the specialization for C-string, a'la python tuple
template<unsigned int N>
std::ostream & | toStream (const char(&obj)[N], std::ostream &s)
| the specialization for C-string, a'la python tuple
std::ostream & | toStream (const char *obj, std::ostream &s)
| the specialization for C-string, a'la python tuple
template<class TYPE>
std::string | toString (const TYPE &obj)
| the generic implementation of the type conversion to the string
GAUDI_API std::ostream & | toStream (const Gaudi::XYZPoint &obj, std::ostream &s)
| print XYZ point
GAUDI_API std::ostream & | toStream (const Gaudi::XYZVector &obj, std::ostream &s)
| print XYZ vector
GAUDI_API std::ostream & | toStream (const Gaudi::LorentzVector &obj, std::ostream &s)
| print Lorentz vector

## 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 384 of file StatEntity.cpp.

    00390 {
    00391   using namespace boost::io ;
    00392   if ( flag && ( effCounter ( name ) || effCounter ( group ) )
    00393        && 0 <= counter.eff() && 0 <= counter.effErr() )
    00394   {
    00395     boost::format fmt( format2 ) ;
    00396     fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
    00397     fmt
    00398       % ( "\"" + name  + ":"  )
    00399       % ( ":"  + group + "\"" )
    00400       %   counter.nEntries ()
    00401       %   counter.sum      ()
    00402       % ( counter.eff      () * 100 )
    00403       % ( counter.effErr   () * 100 ) ;
    00404     return fmt.str() ;
    00405   }
    00406   boost::format fmt  ( format1 ) ;
    00407   fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
    00408   fmt
    00409     % ( "\""  + name  + ":"  )
    00410     % ( ":"   + group + "\"" )
    00411     %   counter.nEntries ()
    00412     %   counter.sum      ()
    00413     %   counter.mean     ()
    00414     %   counter.rms      ()
    00415     %   counter.min      ()
    00416     %   counter.max      () ;
    00417   return fmt.str() ;
    00418 }

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 341 of file StatEntity.cpp.

    00346 {
    00347   using namespace boost::io ;
    00348   if ( flag && effCounter ( name ) && 0 <= counter.eff() && 0 <= counter.effErr() )
    00349   {
    00350     boost::format fmt( format2 ) ;
    00351     fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
    00352     fmt
    00353       % ( "\"" + name + "\"" )
    00354       %   counter.nEntries ()
    00355       %   counter.sum      ()
    00356       % ( counter.eff      () * 100 )
    00357       % ( counter.effErr   () * 100 ) ;
    00358     return fmt.str() ;
    00359   }
    00360   boost::format fmt  ( format1 ) ;
    00361   fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
    00362   fmt
    00363     % ( "\"" + name + "\"" )
    00364     %   counter.nEntries ()
    00365     %   counter.sum      ()
    00366     %   counter.mean     ()
    00367     %   counter.rms      ()
    00368     %   counter.min      ()
    00369     %   counter.max      () ;
    00370   return fmt.str() ;
    00371 }

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 302 of file StatEntity.cpp.

    00306 {
    00307   using namespace boost::io ;
    00308   if ( flag && 0 <= counter.eff() && 0 <= counter.effErr() )
    00309   {
    00310     boost::format fmt( format2 ) ;
    00311     fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
    00312     fmt
    00313       %   counter.nEntries ()
    00314       %   counter.sum      ()
    00315       % ( counter.eff      () * 100 )
    00316       % ( counter.effErr   () * 100 ) ;
    00317     return fmt.str() ;
    00318   }
    00319   boost::format fmt  ( format1 ) ;
    00320   fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
    00321   fmt
    00322     %   counter.nEntries ()
    00323     %   counter.sum      ()
    00324     %   counter.mean     ()
    00325     %   counter.rms      ()
    00326     %   counter.min      ()
    00327     %   counter.max      () ;
    00328   return fmt.str() ;
    00329 }

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 1464 of file Property.h.

    01468     {
    01469       const Property* property = &value ;
    01470       return setProperty ( component , name , property , doc ) ;
    01471     }

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 1375 of file Property.h.

    01379     {
    01380       if ( 0 == component ) { return StatusCode::FAILURE ; }
    01381       const std::string val = std::string ( value , value + N ) ;
    01382       return setProperty ( component , name , val , doc ) ;
    01383     }

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 1313 of file Property.h.

    01317     {
    01318       if ( 0 == component ) { return StatusCode::FAILURE ; }
    01319       SmartIF<IProperty> property ( component ) ;
    01320       if ( !property      ) { return StatusCode::FAILURE ; }
    01321       return setProperty ( property , name , value , doc ) ;
    01322     }

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 1282 of file Property.h.

    01286     {
    01287       const Property* property = &value ;
    01288       return setProperty ( component , name , property , doc ) ;
    01289     }

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 1151 of file Property.h.

    01155     {
    01156       if ( 0 == component                    ) { return StatusCode::FAILURE ; }
    01157       const std::string val = std::string ( value , value + N ) ;
    01158       return setProperty ( component , name , val , doc ) ;
    01159     }

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 1093 of file Property.h.

    01096     { 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 1193 of file Property.h.

    01197     {
    01198       if ( 0 == component ) { return StatusCode::FAILURE ; }   // RETURN
    01199       if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
    01200       const std::string val = Gaudi::Utils::toString ( value ) ;
    01201       return Gaudi::Utils::setProperty ( component , name , val , doc ) ;
    01202     }

std::ostream & Gaudi::Utils::toStream | ( | const Gaudi::LorentzVector & | obj,
|  | std::ostream & | s |
| ) |  |  |

print Lorentz vector

Definition at line 275 of file ParseVct.cpp.

    00276 {
    00277
    00278   s << "( " ;
    00279   toStream ( obj.Px () , s , 12 ) ;
    00280   s << " , " ;
    00281   toStream ( obj.Py () , s , 12 ) ;
    00282   s << " , " ;
    00283   toStream ( obj.Pz () , s , 13 ) ;
    00284   s << " , "  ;
    00285   toStream ( obj.E  () , s , 14 ) ;
    00286   s << " )"  ;
    00287
    00288   return s ;
    00289 }

std::ostream & Gaudi::Utils::toStream | ( | const Gaudi::XYZVector & | obj,
|  | std::ostream & | s |
| ) |  |  |

print XYZ vector

Definition at line 259 of file ParseVct.cpp.

    00260 {
    00261   s << "( "  ;
    00262   toStream ( obj.X () , s ) ;
    00263   s << " , " ;
    00264   toStream ( obj.Y () , s ) ;
    00265   s << " , " ;
    00266   toStream ( obj.Z () , s ) ;
    00267   s << " )"  ;
    00268
    00269   return s ;
    00270 }

std::ostream & Gaudi::Utils::toStream | ( | const Gaudi::XYZPoint & | obj,
|  | std::ostream & | s |
| ) |  |  |

print XYZ point

Definition at line 244 of file ParseVct.cpp.

    00245 {
    00246   s << "( "  ;
    00247   toStream ( obj.X () , s ) ;
    00248   s << " , " ;
    00249   toStream ( obj.Y () , s ) ;
    00250   s << " , " ;
    00251   toStream ( obj.Z () , s ) ;
    00252   s << " )"  ;
    00253   return s ;
    00254 }

std::ostream& Gaudi::Utils::toStream | ( | const char * | obj,
|  | std::ostream & | s |
| ) |  |  | `[inline]`

the specialization for C-string, a'la python tuple

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhenf.nl

Date:
  2009-10-05

Definition at line 316 of file ToStream.h.

    00317     { return toStream ( std::string ( obj ) , s ) ; }

template<unsigned int N>

std::ostream& Gaudi::Utils::toStream | ( | const char(&) | obj[N],
|  | std::ostream & | s |
| ) |  |  | `[inline]`

the specialization for C-string, a'la python tuple

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhenf.nl

Date:
  2009-10-05

Definition at line 309 of file ToStream.h.

    00310     { return toStream ( std::string ( obj , obj+N ) , s ) ; }

template<unsigned int N>

std::ostream& Gaudi::Utils::toStream | ( | char(&) | obj[N],
|  | std::ostream & | s |
| ) |  |  | `[inline]`

the specialization for C-string, a'la python tuple

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhenf.nl

Date:
  2009-10-05

Definition at line 301 of file ToStream.h.

    00302     { return toStream ( std::string ( obj , obj+N ) , s ) ; }

template<class TYPE, unsigned int N>

std::ostream& Gaudi::Utils::toStream | ( | const TYPE(&) | obj[N],
|  | std::ostream & | s |
| ) |  |  | `[inline]`

the specialization for C-arrays, a'la python tuple

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhenf.nl

Date:
  2009-10-05

Definition at line 291 of file ToStream.h.

    00292     {
    00293       return toStream ( obj , obj + N , s , "( " , " )" , " , " ) ;
    00294     }

template<class TYPE, unsigned int N>

std::ostream& Gaudi::Utils::toStream | ( | TYPE(&) | obj[N],
|  | std::ostream & | s |
| ) |  |  | `[inline]`

the specialization for C-arrays, a'la python tuple

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhenf.nl

Date:
  2009-10-05

Definition at line 281 of file ToStream.h.

    00282     {
    00283       return toStream ( obj , obj + N , s , "( " , " )" , " , " ) ;
    00284     }

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 262 of file ToStream.h.

    00263     {
    00264       s << "{ ";
    00265       for ( typename GaudiUtils::HashMap<KTYPE,VTYPE,HASH,MAP>::const_iterator cur = obj.begin() ;
    00266             obj.end() != cur ; ++cur )
    00267       {
    00268         if ( obj.begin() != cur ) { s << " , " ; }
    00269         toStream ( cur -> first  , s ) ;
    00270         s << " : " ;
    00271         toStream ( cur -> second , s ) ;
    00272       }
    00273       return s << " }";
    00274     }

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 238 of file ToStream.h.

    00239     {
    00240       s << "{ ";
    00241       for ( typename GaudiUtils::Map<KTYPE,VTYPE,MAP>::const_iterator cur = obj.begin() ;
    00242             obj.end() != cur ; ++cur )
    00243       {
    00244         if ( obj.begin() != cur ) { s << " , " ; }
    00245         toStream ( cur -> first  , s ) ;
    00246         s << " : " ;
    00247         toStream ( cur -> second , s ) ;
    00248       }
    00249       return s << " }";
    00250     }

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 214 of file ToStream.h.

    00215     {
    00216       s << "{ ";
    00217       for ( typename GaudiUtils::VectorMap<KTYPE,VTYPE,CMP,ALLOCATOR>::const_iterator cur = obj.begin() ;
    00218             obj.end() != cur ; ++cur )
    00219       {
    00220         if ( obj.begin() != cur ) { s << " , " ; }
    00221         toStream ( cur -> first  , s ) ;
    00222         s << " : " ;
    00223         toStream ( cur -> second , s ) ;
    00224       }
    00225       return s << " }";
    00226     }

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 190 of file ToStream.h.

    00191     {
    00192       s << "{ ";
    00193       for ( typename std::map<KTYPE,VTYPE,CMP,ALLOCATOR>::const_iterator cur =
    00194               obj.begin() ; obj.end() != cur ; ++cur )
    00195       {
    00196         if ( obj.begin() != cur ) { s << " , " ; }
    00197         toStream ( cur -> first  , s ) ;
    00198         s << " : " ;
    00199         toStream ( cur -> second , s ) ;
    00200       }
    00201       return s << " }";
    00202     }

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 176 of file ToStream.h.

    00177     {
    00178       return toStream ( obj.begin() , obj.end () , s , "[ " , " ]" , " , " ) ;
    00179     }

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 163 of file ToStream.h.

    00164     {
    00165       return toStream ( obj.begin() , obj.end () , s , "[ " , " ]" , " , " ) ;
    00166     }

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 150 of file ToStream.h.

    00151     {
    00152       return toStream ( obj.begin() , obj.end () , s , "[ " , " ]" , " , " ) ;
    00153     }

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 133 of file ToStream.h.

    00134     {
    00135       s << "( "  ;
    00136       toStream ( obj.first  , s ) ;
    00137       s << " , " ;
    00138       toStream ( obj.second , s ) ;
    00139       return s << " )" ;
    00140     }

std::ostream& Gaudi::Utils::toStream | ( | const long double | obj,
|  | std::ostream & | s,
|  | const int | prec = `10` |
| ) |  |  | `[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 118 of file ToStream.h.

    00119     {
    00120       const int p = s.precision() ;
    00121       return s << std::setprecision ( prec ) << obj << std::setprecision ( p ) ;
    00122     }

std::ostream& Gaudi::Utils::toStream | ( | const double | obj,
|  | std::ostream & | s,
|  | const int | prec = `8` |
| ) |  |  | `[inline]`

the printout of double values with the reasonable precision

Author:
  Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
  2006-09-09

Definition at line 108 of file ToStream.h.

    00109     {
    00110       const int p = s.precision() ;
    00111       return s << std::setprecision ( prec ) << obj << std::setprecision ( p ) ;
    00112     }

std::ostream& Gaudi::Utils::toStream | ( | const float | obj,
|  | std::ostream & | s,
|  | const int | prec = `6` |
| ) |  |  | `[inline]`

the printout of float values with the reasonable precision

Author:
  Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
  2006-09-09

Definition at line 98 of file ToStream.h.

    00099     {
    00100       const int  p = s.precision() ;
    00101       return s << std::setprecision (  prec ) << obj << std::setprecision ( p ) ;
    00102     }

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 91 of file ToStream.h.

    00092     { 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 78 of file ToStream.h.

    00079     {
    00080       if ( std::string::npos == obj.find('\'') )
    00081       { s << "\'" << obj << "\'" ; }
    00082       else
    00083       { s << "\"" << obj << "\"" ; }
    00084       return s ;
    00085     }

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 325 of file ToStream.h.

    00326     { return s << obj ; }

template<class SCALAR, unsigned int N>

std::ostream& Gaudi::Utils::toStream | ( | const ROOT::Math::SVector< SCALAR, N > & | obj,
|  | std::ostream & | s |
| ) |  |  | `[inline]`

the general streaming function for SVector using python-tupel format

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-10-07

Definition at line 77 of file SVectorAsProperty.h.

    00078     {
    00079       s << "( ";
    00080       for ( typename ROOT::Math::SVector<SCALAR,N>::const_iterator cur = obj.begin() ;
    00081             obj.end() != cur ; ++cur )
    00082       {
    00083         if ( obj.begin() != cur ) { s << " , "; }
    00084         toStream ( *cur , s ) ;
    00085       }
    00086       return s << " )";
    00087     }

template<class SCALAR>

std::ostream& Gaudi::Utils::toStream | ( | const SCALAR & | ,
|  | std::ostream & |  |
| ) |  |  | `[inline]`

std::ostream & Gaudi::Utils::toStream | ( | const Gaudi::StringKey & | key,
|  | std::ostream & | s |
| ) |  |  |

send the object to stream (needed to use it as property)

See also:
  Gaudi::StringKey

  Gaudi::Utils::toString

  Gaudi::Utils::toStream

Parameters:

  | key | (INPUT) the object to be printed
  | s | (OUTPUT) the stream

Returns:
  the stream

Author:
  Vanya BELYAEV Iavn.Belyaev@nikhef.nl

Date:
  2009-10-07

Definition at line 68 of file StringKey.cpp.

    00069 { return Gaudi::Utils::toStream ( key.str() , s ) ; }

template<class TYPE, std::size_t N>

std::ostream& Gaudi::Utils::toStream | ( | const boost::array< TYPE, N > & | obj,
|  | std::ostream & | s |
| ) |  |  | `[inline]`

printout of class boost::array The format is "Python's tuple"

Parameters:

  | obj | (INPUT) the arary to be printed
  | s | (UPDATE) the actual stream

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-16

Definition at line 53 of file BoostArrayAsProperty.h.

    00054     {
    00055       return toStream
    00056         ( obj.begin () , obj.end   () , s , "( "  , " )"   , " , "  ) ;
    00057     }

template<class ITERATOR>

std::ostream & Gaudi::Utils::toStream | ( | ITERATOR | first,
|  | ITERATOR | last,
|  | std::ostream & | s,
|  | const std::string & | open,
|  | const std::string & | close,
|  | const std::string & | delim |
| ) |  |  | `[inline]`

the helper function to print the sequence

Parameters:

  | first | (INPUT) begin-iterator for the sequence
  | last | (INPUT) end-iterator for the sequence
  | s | (UPDATE) the stream itself
  | open | (INPUT) "open"-symbol
  | close | (INPUT) "close"-symbol
  | delim | (INPUT) "delimiter"-symbol

Returns:
  the stream

Author:
  Vanya BELYAEV Ivan.BElyaev@nikhef.nl

Date:
  2009-09-15

Definition at line 341 of file ToStream.h.

    00347     {
    00348       s << open ;
    00349       for ( ITERATOR curr = first ; curr != last ; ++curr )
    00350       {
    00351         if ( first != curr ) { s << delim ; }
    00352         toStream ( *curr , s ) ;
    00353       }
    00354       s << close ;
    00355       //
    00356       return s ;
    00357     }

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 367 of file ToStream.h.

    00368     {
    00369       std::ostringstream s;
    00370       toStream ( obj , s);
    00371       return s.str();
    00372     }