| # Gaudi Framework, version v23r0 |

Home |  | Generated: Mon Jan 30 2012

Namespaces | Classes | Functions

# Gaudi::Utils Namespace Reference

## Namespaces
namespace | Histos

| Collection of useful utilities for manipulations with AIDA hisgograms.
namespace | RegEx

| RegeEx: nemspace to hold gaudi regular expression checking.
## 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...
## 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
std::ostream & | operator<< (std::ostream &s, const TypeNameString &tn)
| Output stream operator for TypeNameString instances.
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
GAUDI_API std::ostream & | toStream (const TH1D &histo, std::ostream &stream, const bool asXML=false)
| stream the ROOT histogram into output stream
GAUDI_API std::ostream & | toStream (const TH2D &histo, std::ostream &stream, const bool asXML=false)
| stream the ROOT histogram into output stream
GAUDI_API std::ostream & | toStream (const TH1F &histo, std::ostream &stream, const bool asXML=false)
| stream the ROOT histogram into output stream
GAUDI_API std::ostream & | toStream (const TH2F &histo, std::ostream &stream, const bool asXML=false)
| stream the ROOT histogram into output stream
GAUDI_API std::ostream & | toStream (const AIDA::IHistogram1D &histo, std::ostream &stream, const bool asXML=false)
| stream the AIDA histogram into output stream
GAUDI_API std::ostream & | toStream (const AIDA::IHistogram2D &histo, std::ostream &stream, const bool asXML=false)
| stream the AIDA histogram into output stream
GAUDI_API std::string | toString (const TH1D &histo, const bool asXML=false)
| convert the histogram into the string
GAUDI_API std::string | toString (const TH2D &histo, const bool asXML=false)
| convert the histogram into the string
GAUDI_API std::string | toString (const TH1F &histo, const bool asXML=false)
| convert the histogram into the string
GAUDI_API std::string | toString (const TH2F &histo, const bool asXML=false)
| convert the histogram into the string
GAUDI_API std::string | toString (const AIDA::IHistogram1D &histo, const bool asXML=false)
| convert the histogram into the string
GAUDI_API std::string | toString (const AIDA::IHistogram2D &histo, const bool asXML=false)
| convert the histogram into the string
GAUDI_API std::string | toString (const AIDA::IHistogram1D *histo)
| convert the histogram into the string
GAUDI_API std::string | toString (AIDA::IHistogram1D *histo)
| convert the histogram into the string
GAUDI_API std::string | toString (const TH1D *histo)
| convert the histogram into the string
GAUDI_API std::string | toString (TH1D *histo)
| convert the histogram into the string
GAUDI_API std::string | toString (const TH2D *histo)
| convert the histogram into the string
GAUDI_API std::string | toString (TH2D *histo)
| convert the histogram into the string

## Function Documentation

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.

    {
      using namespace boost::io ;
      if ( flag && 0 <= counter.eff() && 0 <= counter.effErr() )
      {
        boost::format fmt( format2 ) ;
        fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
        fmt
          %   counter.nEntries ()
          %   counter.sum      ()
          % ( counter.eff      () * 100 )
          % ( counter.effErr   () * 100 ) ;
        return fmt.str() ;
      }
      boost::format fmt  ( format1 ) ;
      fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
      fmt
        %   counter.nEntries ()
        %   counter.sum      ()
        %   counter.mean     ()
        %   counter.rms      ()
        %   counter.min      ()
        %   counter.max      () ;
      return fmt.str() ;
    }

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.

    {
      using namespace boost::io ;
      if ( flag && effCounter ( name ) && 0 <= counter.eff() && 0 <= counter.effErr() )
      {
        boost::format fmt( format2 ) ;
        fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
        fmt
          % ( "\"" + name + "\"" )
          %   counter.nEntries ()
          %   counter.sum      ()
          % ( counter.eff      () * 100 )
          % ( counter.effErr   () * 100 ) ;
        return fmt.str() ;
      }
      boost::format fmt  ( format1 ) ;
      fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
      fmt
        % ( "\"" + name + "\"" )
        %   counter.nEntries ()
        %   counter.sum      ()
        %   counter.mean     ()
        %   counter.rms      ()
        %   counter.min      ()
        %   counter.max      () ;
      return fmt.str() ;
    }

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.

    {
      using namespace boost::io ;
      if ( flag && ( effCounter ( name ) || effCounter ( group ) )
           && 0 <= counter.eff() && 0 <= counter.effErr() )
      {
        boost::format fmt( format2 ) ;
        fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
        fmt
          % ( "\"" + name  + ":"  )
          % ( ":"  + group + "\"" )
          %   counter.nEntries ()
          %   counter.sum      ()
          % ( counter.eff      () * 100 )
          % ( counter.effErr   () * 100 ) ;
        return fmt.str() ;
      }
      boost::format fmt  ( format1 ) ;
      fmt.exceptions ( all_error_bits ^ ( too_many_args_bit | too_few_args_bit ) ) ;
      fmt
        % ( "\""  + name  + ":"  )
        % ( ":"   + group + "\"" )
        %   counter.nEntries ()
        %   counter.sum      ()
        %   counter.mean     ()
        %   counter.rms      ()
        %   counter.min      ()
        %   counter.max      () ;
      return fmt.str() ;
    }

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.

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

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.

    {
      for ( std::vector<IAlgorithm*>::const_reverse_iterator it = lst.rbegin() ;
            lst.rend() != it ; ++it )
      {
        // use the selector:
        if ( sel ( *it ) ) { return *it ; }  // return
      }
      return 0 ;
    }

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.

    { 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.

    { 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.

    { 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 452 of file Property.cpp.

    {
      // trivial check
      if ( 0 == p             ) { return 0 ; }                 // RETURN
      std::vector<const Property*>::const_iterator ifound =
        std::find_if ( p->begin() , p->end() , _ByName_( name ) ) ;
      if ( p->end() == ifound ) { return 0 ; }                 // RETURN
      // OK
      return *ifound ;
    }

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 349 of file Property.cpp.

    {
      // trivial check
      if ( 0 == p      ) { return 0 ; }                          // RETURN
      // get all properties
      typedef std::vector<Property*> List ;
      const List& lst = p->getProperties() ;
      if ( lst.empty() ) { return 0 ; }                          // RETURN
      // comparison criteria:
      List::const_iterator ifound =
        std::find_if ( lst.begin() , lst.end() , _ByName_( name ) ) ;
      if ( lst.end() == ifound ) { return 0 ; }                  // RETURN
      // OK
      return *ifound ;
    }

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 385 of file Property.cpp.

    {
      // trivial check
      if ( 0 ==  p        ) { return 0 ; }                                // RETURN
      // remove const-qualifier
      IInterface* _i = const_cast<IInterface*>( p ) ;
      if ( 0 == _i        ) { return 0 ; }                                // RETURN
      SmartIF<IProperty> property ( _i ) ;
      if ( !property      ) { return 0 ; }                                // RETURN
      return getProperty ( property , name ) ;
    }

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.

    {
      if ( 0 == svc            ) { return 0 ; }  // RETURN
      //
      typedef IAlgContextSvc::Algorithms ALGS ;
      const ALGS& algs = svc->algorithms() ;
      AlgTypeSelector<GaudiSequencer> sel1 ;
      AlgTypeSelector<Sequencer>      sel2 ;
      for ( ALGS::const_reverse_iterator it = algs.rbegin() ;
            algs.rend() != it ; ++it )
      {
        if ( sel1 ( *it ) ) { return *it ; }
        if ( sel2 ( *it ) ) { return *it ; }
      }
      return 0 ;                                    // RETURN ;
    }

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.

    { 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.

    { return getAlg<GaudiTupleAlg> ( svc ) ; }

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.

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

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.

    {
      // trivial check
      if ( 0 ==  p ) { return false ; }                                // RETURN
      // gelegate to another method
      return 0 != getProperty ( p , name ) ;
    }

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 421 of file Property.cpp.

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

std::ostream& Gaudi::Utils::operator<< | ( | std::ostream & | s,
|  | const TypeNameString & | tn
| ) |  | `[inline]`

Output stream operator for TypeNameString instances.

Definition at line 27 of file TypeNameString.h.

                                                                                {
          return s << tn.type() << '/' << tn.name();
        }

template<class TYPE >

StatusCode Gaudi::Utils::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

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

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

template<class TYPE >

StatusCode Gaudi::Utils::setProperty | ( | IProperty * | component,
|  | const std::string & | name,
|  | const TYPE & | value
| ) |  |

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

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

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 502 of file Property.cpp.

    {
      if ( 0 == component ) { return StatusCode::FAILURE ; }   // RETURN
      if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
      StatusCode sc = component -> setProperty ( name , value ) ;
      if ( !doc.empty() )
      {
        Property* p = getProperty( component , name ) ;
        if ( 0 != p ) { p -> setDocumentation ( doc ) ; }
      }
      sc.ignore() ;
      return sc ;
    }

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 479 of file Property.cpp.

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

template<unsigned N>

StatusCode Gaudi::Utils::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

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

        {
          if ( 0 == component                    ) { return StatusCode::FAILURE ; }
          const std::string val = std::string ( value , value + N ) ;
          return setProperty ( component , name , val , 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 542 of file Property.cpp.

    {
      if ( 0 == component || 0 == property   ) { return StatusCode::FAILURE ; }
      if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
      Property* p = getProperty ( component , name ) ;
      if ( 0 == p                            ) { return StatusCode::FAILURE ; }
      if ( !p->assign ( *property )          ) { return StatusCode::FAILURE ; }
      if ( !doc.empty()  ) { p->setDocumentation( doc ) ; }
      return StatusCode::SUCCESS ;
    }

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 579 of file Property.cpp.

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

template<class TYPE >

StatusCode Gaudi::Utils::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

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

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

template<class TYPE >

StatusCode Gaudi::Utils::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

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

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

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 599 of file Property.cpp.

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

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 624 of file Property.cpp.

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

template<unsigned N>

StatusCode Gaudi::Utils::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

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

        {
          if ( 0 == component ) { return StatusCode::FAILURE ; }
          const std::string val = std::string ( value , value + N ) ;
          return setProperty ( component , name , val , 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 656 of file Property.cpp.

    {
      if ( 0 == component ) { return StatusCode::FAILURE ; }
      SmartIF<IProperty> prop  ( component ) ;
      if ( !prop          ) { return StatusCode::FAILURE ; }
      return setProperty ( prop  , 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 690 of file Property.cpp.

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

template<class TYPE >

StatusCode Gaudi::Utils::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

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

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

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.

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

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

print Lorentz vector

Definition at line 162 of file ParsersVct.cpp.

    {

      s << "( " ;
      toStream ( obj.Px () , s , 12 ) ;
      s << " , " ;
      toStream ( obj.Py () , s , 12 ) ;
      s << " , " ;
      toStream ( obj.Pz () , s , 13 ) ;
      s << " , "  ;
      toStream ( obj.E  () , s , 14 ) ;
      s << " )"  ;

      return s ;
    }

std::ostream & Gaudi::Utils::toStream | ( | const TH1F & | histo,
|  | std::ostream & | stream,
|  | const bool | asXML = `false`
| ) |  |

stream the ROOT histogram into output stream

Parameters:

  histo | (INPUT) the histogram to be streamed
  stream | (OUTPUT) the stream
  asXML | (INPUT) use XML-format

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 195 of file Histo2String.cpp.

                             { return _toStream_1D_ ( histo , stream , asXML ) ; }

std::ostream & Gaudi::Utils::toStream | ( | const TH2F & | histo,
|  | std::ostream & | stream,
|  | const bool | asXML = `false`
| ) |  |

stream the ROOT histogram into output stream

Parameters:

  histo | (INPUT) the histogram to be streamed
  stream | (OUTPUT) the stream
  asXML | (INPUT) use XML-format

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 217 of file Histo2String.cpp.

                             { return _toStream_2D_ ( histo , stream , asXML ) ; }

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.

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

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.

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

std::ostream & Gaudi::Utils::toStream | ( | const AIDA::IHistogram1D & | histo,
|  | std::ostream & | stream,
|  | const bool | asXML = `false`
| ) |  |

stream the AIDA histogram into output stream

Parameters:

  histo | (INPUT) the histogram to be streamed
  stream | (OUTPUT) the stream
  asXML | (INPUT) use XML-format

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 228 of file Histo2String.cpp.

    {
      //
      AIDA::IHistogram1D* aida = const_cast<AIDA::IHistogram1D*> ( &histo ) ;
      //
      const TH1D* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
      if ( 0 == root ) { return stream ; }                                // RETURN
      //
      return toStream  ( *root , stream , asXML ) ;
    }

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.

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

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.

        {
          if ( std::string::npos == obj.find('\'') )
          { s << "\'" << obj << "\'" ; }
          else
          { s << "\"" << obj << "\"" ; }
          return s ;
        }

std::ostream & Gaudi::Utils::toStream | ( | const TH1D & | histo,
|  | std::ostream & | stream,
|  | const bool | asXML = `false`
| ) |  |

stream the ROOT histogram into output stream

Parameters:

  histo | (INPUT) the histogram to be streamed
  stream | (OUTPUT) the stream
  asXML | (INPUT) use XML-format

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 184 of file Histo2String.cpp.

                             { return _toStream_1D_ ( histo , stream , asXML ) ; }

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.

        {
          s << open ;
          for ( ITERATOR curr = first ; curr != last ; ++curr )
          {
            if ( first != curr ) { s << delim ; }
            toStream ( *curr , s ) ;
          }
          s << close ;
          //
          return s ;
        }

template<class SCALAR >

std::ostream& Gaudi::Utils::toStream | ( | const SCALAR & | ,
|  | std::ostream & |
| ) |  |

template<class SCALAR , unsigned int N>

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

the general streaming function for SVector using python-tupel format

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-10-07

Definition at line 87 of file SVectorAsProperty.h.

        {
          s << "( ";
          for ( typename ROOT::Math::SVector<SCALAR,N>::const_iterator cur = obj.begin() ;
                obj.end() != cur ; ++cur )
          {
            if ( obj.begin() != cur ) { s << " , "; }
            toStream ( *cur , s ) ;
          }
          return s << " )";
        }

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.

        { return s << obj ; }

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.

        {
          return toStream
            ( obj.begin () , obj.end   () , s , "( "  , " )"   , " , "  ) ;
        }

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.

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

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.

        {
          s << "{ ";
          for ( typename GaudiUtils::HashMap<KTYPE,VTYPE,HASH,MAP>::const_iterator cur = obj.begin() ;
                obj.end() != cur ; ++cur )
          {
            if ( obj.begin() != cur ) { s << " , " ; }
            toStream ( cur -> first  , s ) ;
            s << " : " ;
            toStream ( cur -> second , s ) ;
          }
          return s << " }";
        }

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.

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

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

print XYZ point

Definition at line 131 of file ParsersVct.cpp.

    {
      s << "( "  ;
      toStream ( obj.X () , s ) ;
      s << " , " ;
      toStream ( obj.Y () , s ) ;
      s << " , " ;
      toStream ( obj.Z () , s ) ;
      s << " )"  ;
      return s ;
    }

std::ostream & Gaudi::Utils::toStream | ( | const AIDA::IHistogram2D & | histo,
|  | std::ostream & | stream,
|  | const bool | asXML = `false`
| ) |  |

stream the AIDA histogram into output stream

Parameters:

  histo | (INPUT) the histogram to be streamed
  stream | (OUTPUT) the stream
  asXML | (INPUT) use XML-format

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 248 of file Histo2String.cpp.

    {
      //
      AIDA::IHistogram2D* aida = const_cast<AIDA::IHistogram2D*> ( &histo ) ;
      //
      const TH2D* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
      if ( 0 == root ) { return stream ; }                                // RETURN
      //
      return toStream  ( *root , stream , asXML ) ;
    }

template<unsigned int N>

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

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.

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

template<class TYPE , unsigned int N>

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

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.

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

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.

        {
          s << "{ ";
          for ( typename GaudiUtils::Map<KTYPE,VTYPE,MAP>::const_iterator cur = obj.begin() ;
                obj.end() != cur ; ++cur )
          {
            if ( obj.begin() != cur ) { s << " , " ; }
            toStream ( cur -> first  , s ) ;
            s << " : " ;
            toStream ( cur -> second , s ) ;
          }
          return s << " }";
        }

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.

        {
          s << "( "  ;
          toStream ( obj.first  , s ) ;
          s << " , " ;
          toStream ( obj.second , s ) ;
          return s << " )" ;
        }

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.

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

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.

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

template<class TYPE , unsigned int N>

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

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.

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

std::ostream & Gaudi::Utils::toStream | ( | const TH2D & | histo,
|  | std::ostream & | stream,
|  | const bool | asXML = `false`
| ) |  |

stream the ROOT histogram into output stream

Parameters:

  histo | (INPUT) the histogram to be streamed
  stream | (OUTPUT) the stream
  asXML | (INPUT) use XML-format

Returns:
  the updated stream

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 206 of file Histo2String.cpp.

                             { return _toStream_2D_ ( histo , stream , asXML ) ; }

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.

        {
          s << "{ ";
          for ( typename std::map<KTYPE,VTYPE,CMP,ALLOCATOR>::const_iterator cur =
                  obj.begin() ; obj.end() != cur ; ++cur )
          {
            if ( obj.begin() != cur ) { s << " , " ; }
            toStream ( cur -> first  , s ) ;
            s << " : " ;
            toStream ( cur -> second , s ) ;
          }
          return s << " }";
        }

template<unsigned int N>

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

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.

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

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.

        {
          s << "{ ";
          for ( typename GaudiUtils::VectorMap<KTYPE,VTYPE,CMP,ALLOCATOR>::const_iterator cur = obj.begin() ;
                obj.end() != cur ; ++cur )
          {
            if ( obj.begin() != cur ) { s << " , " ; }
            toStream ( cur -> first  , s ) ;
            s << " : " ;
            toStream ( cur -> second , s ) ;
          }
          return s << " }";
        }

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.

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

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

print XYZ vector

Definition at line 146 of file ParsersVct.cpp.

    {
      s << "( "  ;
      toStream ( obj.X () , s ) ;
      s << " , " ;
      toStream ( obj.Y () , s ) ;
      s << " , " ;
      toStream ( obj.Z () , s ) ;
      s << " )"  ;

      return s ;
    }

std::string Gaudi::Utils::toString | ( | const TH2D * | histo ) |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 413 of file Histo2String.cpp.

    {
      if ( 0 == histo ) { return std::string ("{}") ; }
      return toString ( *histo ) ;
    }

std::string Gaudi::Utils::toString | ( | TH2D * | histo ) |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 441 of file Histo2String.cpp.

    {
      if ( 0 == histo ) { return std::string ("{}") ; }
      return toString ( *histo ) ;
    }

std::string Gaudi::Utils::toString | ( | const TH1D * | histo ) |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 399 of file Histo2String.cpp.

    {
      if ( 0 == histo ) { return std::string ("{}") ; }
      return toString ( *histo ) ;
    }

std::string Gaudi::Utils::toString | ( | const AIDA::IHistogram1D * | histo ) |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 371 of file Histo2String.cpp.

    {
      if ( 0 == histo ) { return std::string ("{}") ; }
      return toString ( *histo ) ;
    }

std::string Gaudi::Utils::toString | ( | const AIDA::IHistogram1D & | histo,
|  | const bool | asXML = `false`
| ) |  |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 338 of file Histo2String.cpp.

    {
      std::ostringstream o ;
      toStream ( histo , o , asXML ) ;
      return o.str() ;
    }

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.

        {
          std::ostringstream s;
          std::ios::fmtflags orig_flags = s.flags();
          s.setf(std::ios::fixed); // to display correctly floats
          toStream ( obj , s);
          s.flags(orig_flags);
          return s.str();
        }

std::string Gaudi::Utils::toString | ( | const TH2D & | histo,
|  | const bool | asXML = `false`
| ) |  |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 304 of file Histo2String.cpp.

    {
      std::ostringstream o ;
      toStream ( histo , o , asXML ) ;
      return o.str() ;
    }

std::string Gaudi::Utils::toString | ( | TH1D * | histo ) |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 427 of file Histo2String.cpp.

    {
      if ( 0 == histo ) { return std::string ("{}") ; }
      return toString ( *histo ) ;
    }

std::string Gaudi::Utils::toString | ( | const TH1F & | histo,
|  | const bool | asXML = `false`
| ) |  |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 287 of file Histo2String.cpp.

    {
      std::ostringstream o ;
      toStream ( histo , o , asXML ) ;
      return o.str() ;
    }

std::string Gaudi::Utils::toString | ( | AIDA::IHistogram1D * | histo ) |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 385 of file Histo2String.cpp.

    {
      if ( 0 == histo ) { return std::string ("{}") ; }
      return toString ( *histo ) ;
    }

std::string Gaudi::Utils::toString | ( | const AIDA::IHistogram2D & | histo,
|  | const bool | asXML = `false`
| ) |  |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 355 of file Histo2String.cpp.

    {
      std::ostringstream o ;
      toStream ( histo , o , asXML ) ;
      return o.str() ;
    }

std::string Gaudi::Utils::toString | ( | const TH2F & | histo,
|  | const bool | asXML = `false`
| ) |  |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 321 of file Histo2String.cpp.

    {
      std::ostringstream o ;
      toStream ( histo , o , asXML ) ;
      return o.str() ;
    }

std::string Gaudi::Utils::toString | ( | const TH1D & | histo,
|  | const bool | asXML = `false`
| ) |  |

convert the histogram into the string

Parameters:

  histo | (INPUT) the histogram to be streamed
  asXML | (INPUT) use XML-format

Returns:
  the string representation of the histogram

Author:
  Vanya BELYAEV Ivan.Belyaev@nikhef.nl

Date:
  2009-09-26

Definition at line 270 of file Histo2String.cpp.

    {
      std::ostringstream o ;
      toStream ( histo , o , asXML ) ;
      return o.str() ;
    }

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines