Namespaces
	Utils

Classes
struct	BoolGrammar

class	Catalog

struct	CharGrammar

struct	DataObjIDGrammar

class	EdgeGrammar

struct	FileGrammar

struct	Grammar_

struct	Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper >

struct	Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper >

struct	Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper >

struct	Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper >

struct	Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, std::tuple< Args... >, Skipper >

struct	Grammar_< Iterator, std::unordered_map< KeyT, ValueT, HashT, KeyCompareT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, std::unordered_set< InnerT, HashT, CompareT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper >

struct	Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type >

struct	Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type >

class	H1Grammar

class	H2Grammar

struct	Histo1DGrammar

struct	IdentifierGrammar

class	IncludedFiles

struct	InputData
	Helper class to enable ADL for parsers. More...

struct	InterpolGrammar

struct	IntGrammar

struct	KeyValueGrammar

struct	MapGrammar

class	Messages

struct	Node

struct	NodeOperations

struct	PairGrammar

struct	Pnt3DGrammar

struct	Pnt4DGrammar

class	Position

class	PositionalPropertyValueException

class	PragmaOptions

class	Property

class	PropertyName

class	PropertyValue

class	PropertyValueException

struct	RealGrammar

struct	SkipperGrammar

struct	StringGrammar

struct	tuple_get_first_type

struct	tuple_get_first_type< std::tuple< T, Ts... > >

struct	tuple_remove_first_type

struct	tuple_remove_first_type< std::tuple< T, Ts... > >

struct	TupleGrammar

struct	TupleInnerGrammar

struct	TupleInnerGrammar< Iterator, TupleT, 1, Skipper >

class	Units

struct	UnitsGrammar

struct	VectorGrammar

Typedefs
typedef std::string::const_iterator	IteratorT

typedef SkipperGrammar< IteratorT >	Skipper

typedef std::string::const_iterator	DefaultIterator

typedef enc::space_type	DefaultSkipper

Functions
template<typename K , typename V >
StatusCode	parse (GaudiUtils::HashMap< K, V > &result, const std::string &input)
	Basic parser for the types of HashMap used in DODBasicMapper. More...

bool	ReadOptions (const std::string &filename, const std::string &search_path, Messages messages, Catalog catalog, Units units, PragmaOptions pragma, Node *root)
	Parse and analyze filename, save all messages and properties. More...

std::ostream &	operator<< (std::ostream &o, const Catalog &c)
	printout operator More...

bool	Parse (const std::string &filename, const std::string &search_path, IncludedFiles included, Messages messages, Node *root)

bool	Parse (const Position &from, const std::string &filename, const std::string &search_path, IncludedFiles included, Messages messages, Node *root)

bool	ParseUnits (const Position &from, const std::string &filename, const std::string &search_path, IncludedFiles included, Messages messages, Node *root)

	REGISTER_GRAMMAR (GaudiMath::Interpolation::Type, InterpolGrammar)

GAUDI_API StatusCode	parse (std::vector< std::pair< double, double >> &result, const std::string &input)
	parse the `bool` value More...

GAUDI_API StatusCode	parse (std::vector< std::pair< int, int >> &result, const std::string &input)
	parse the `std::vector<std::pair<int,int> >` value More...

GAUDI_API StatusCode	parse (std::vector< std::vector< std::string >> &result, const std::string &input)
	parse the `std::vector<std::vector<std::string> >` value More...

GAUDI_API StatusCode	parse (std::vector< std::vector< double >> &result, const std::string &input)
	parse the `std::vector<std::vector<double> >` value More...

GAUDI_API StatusCode	parse (std::map< int, int > &result, const std::string &input)
	parse the `std::map<int , int>` value More...

GAUDI_API StatusCode	parse (std::map< int, double > &result, const std::string &input)
	parse the `std::map<int , double>` value More...

GAUDI_API StatusCode	parse (std::map< std::string, std::string > &result, const std::string &input)
	parse the `std::map<std::string , std::string>` value More...

GAUDI_API StatusCode	parse (std::map< std::string, int > &result, const std::string &input)
	parse the `std::map<std::string , int>` value More...

GAUDI_API StatusCode	parse (std::map< std::string, double > &result, const std::string &input)
	parse the `std::map<std::string , double>` value More...

GAUDI_API StatusCode	parse (std::map< std::string, std::vector< std::string >> &result, const std::string &input)
	parse the `std::map<std::string , std::vector<std::string> >` value More...

GAUDI_API StatusCode	parse (std::map< std::string, std::vector< int >> &result, const std::string &input)
	parse the `std::map<std::string , std::vector<int> >` value More...

GAUDI_API StatusCode	parse (std::map< std::string, std::vector< double >> &result, const std::string &input)
	parse the `std::map<std::string , std::vector<double> >` value More...

GAUDI_API StatusCode	parse (std::map< int, std::string > &result, const std::string &input)
	parse the `std::map<int,std::string> >` objects More...

GAUDI_API StatusCode	parse (std::map< unsigned int, std::string > &result, const std::string &input)
	parse the `std::map<unsigned int,std::string> >` objects More...

GAUDI_API StatusCode	parse (std::map< std::string, unsigned int > &result, const std::string &input)
	parse the `std::map<unsigned int,std::string> >` objects More...

template<typename K , typename V , typename M >
GAUDI_API StatusCode	parse (GaudiUtils::Map< K, V, M > &result, const std::string &input)
	parse the `GaudiUtils::Map<K, V, M>` objects More...

GAUDI_API StatusCode	parse (std::string &name, std::string &value, const std::string &input)
	parse the pair expression (map-component) " 'name' :value" More...

GAUDI_API StatusCode	parse (Gaudi::Histo1DDef &histo, const std::string &input)
	helper function, needed for implementation of "Histogram Property" More...

GAUDI_API StatusCode	parse (std::map< std::string, Gaudi::Histo1DDef > &histos, const std::string &input)
	helper function, needed for implementation of "Histogram Property" More...

GAUDI_API StatusCode	parse (std::map< std::string, std::pair< double, double >> &params, const std::string &input)
	helper function, needed for implementation of map of pairs It is very useful construction for monitoring to represent the value and error or the allowed range for some parameter More...

template<class T , unsigned int N>
StatusCode	parse (T(&result)[N], const std::string &input)
	parser function for C-arrays More...

template<unsigned int N>
StatusCode	parse (char(&result)[N], const std::string &input)
	parser function for C-strings More...

template<typename ResultT >
StatusCode	parse_ (ResultT &result, const std::string &input)

template<>
StatusCode	parse_ (std::string &result, const std::string &input)

template<typename ResultT >
StatusCode	parse (ResultT &result, const std::string &input)

	REGISTER_GRAMMAR (std::string, StringGrammar)

	REGISTER_GRAMMAR (Gaudi::StringKey, StringGrammar)

	REGISTER_GRAMMAR (char, CharGrammar)

	REGISTER_GRAMMAR (bool, BoolGrammar)

	REGISTER_GRAMMAR (Gaudi::Histo1DDef, Histo1DGrammar)

template<class TYPE , std::size_t N>
StatusCode	parse (boost::array< TYPE, N > &result, const std::string &input)
	parse class boost::array from the string More...

StatusCode	parse (DataObjectHandleBase &, const std::string &)

template<class TYPE , std::size_t N>
StatusCode	parse (std::array< TYPE, N > &result, const std::string &input)
	parse class std::array from the string More...

GAUDI_API StatusCode	parse (Gaudi::StringKey &result, const std::string &input)
	parse the key from the string More...

GAUDI_API StatusCode	parse (std::vector< Gaudi::StringKey > &result, const std::string &input)
	parse the vector of keys from the string More...

template<class SCALAR , unsigned int N>
StatusCode	parse (ROOT::Math::SVector< SCALAR, N > &result, const std::string &input)
	parse SVector More...

GAUDI_API StatusCode	parse (GaudiUtils::VectorMap< std::string, double > &result, const std::string &input)
	parse the key from the string More...

GAUDI_API StatusCode	parse (GaudiUtils::VectorMap< Gaudi::StringKey, double > &result, const std::string &input)
	parse the vector of keys from the string More...

GAUDI_API StatusCode	parse (Gaudi::XYZPoint &result, const std::string &input)
	parse 3D-point More...

GAUDI_API StatusCode	parse (Gaudi::XYZVector &result, const std::string &input)
	parse 3D-vector More...

GAUDI_API StatusCode	parse (Gaudi::LorentzVector &result, const std::string &input)
	parse LorentzVector More...

GAUDI_API StatusCode	parse (std::vector< Gaudi::XYZPoint > &result, const std::string &input)
	parse the vector of points More...

GAUDI_API StatusCode	parse (std::vector< Gaudi::XYZVector > &result, const std::string &input)
	parse the vector of vectors More...

GAUDI_API StatusCode	parse (std::vector< Gaudi::LorentzVector > &result, const std::string &input)
	parse the vector of vectors More...

	REGISTER_GRAMMAR (DataObjID, DataObjIDGrammar)

template<typename T1 , typename T2 >
StatusCode	parse_ (ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)

GAUDI_API StatusCode	parse (TH1D &result, const std::string &input)
	parse ROOT histogram from text representation More...

GAUDI_API StatusCode	parse (TH2D &result, const std::string &input)
	parse ROOT histogram from text representation More...

GAUDI_API StatusCode	parse (TH1F &result, const std::string &input)
	parse ROOT histogram from text representation More...

GAUDI_API StatusCode	parse (TH2F &result, const std::string &input)
	parse ROOT histogram from text representation More...

GAUDI_API StatusCode	parse (AIDA::IHistogram1D &result, const std::string &input)
	parse AIDA histogram from text representation More...

GAUDI_API StatusCode	parse (AIDA::IHistogram2D &result, const std::string &input)
	parse AIDA histogram from text representation More...

GAUDI_API StatusCode	parse (TH1D *&result, const std::string &input)
	parse ROOT histogram from text representation More...

GAUDI_API StatusCode	parse (TH2D *&result, const std::string &input)
	parse ROOT histogram from text representation More...

	REGISTER_GRAMMAR (Edges, EdgeGrammar)

	REGISTER_GRAMMAR (H1, H1Grammar)

	REGISTER_GRAMMAR (H2, H2Grammar)

Typedef Documentation

typedef std::string::const_iterator Gaudi::Parsers::DefaultIterator

Definition at line 56 of file Grammars.h.

typedef enc::space_type Gaudi::Parsers::DefaultSkipper

Definition at line 57 of file Grammars.h.

typedef std::string::const_iterator Gaudi::Parsers::IteratorT

Definition at line 24 of file Factory.h.

typedef SkipperGrammar<IteratorT> Gaudi::Parsers::Skipper

Definition at line 26 of file Factory.h.

Function Documentation

std::ostream& Gaudi::Parsers::operator<<	(	std::ostream &	o,
		const Catalog &	c
	)

inline

printout operator

Definition at line 58 of file Catalog.h.

58 { return c.fillStream( o ); }

gaudirun.c

c

Definition: gaudirun.py:483

template<typename K , typename V >

StatusCode Gaudi::Parsers::parse	(	GaudiUtils::HashMap< K, V > &	result,
		const std::string &	input
	)

Basic parser for the types of HashMap used in DODBasicMapper.

Delegates to the parser of map<string,string>.

Definition at line 11 of file DODBasicMapper.cpp.

                                                                                 {
       std::map<std::string, std::string> tmp;
       StatusCode                         sc = parse( tmp, input );
       if ( sc.isSuccess() ) {
         result.clear();
         result.insert( tmp.begin(), tmp.end() );
       }
       return sc;
     }

bool Gaudi::Parsers::Parse	(	const std::string &	filename,
		const std::string &	search_path,
		IncludedFiles *	included,
		Messages *	messages,
		Node *	root
	)

Definition at line 114 of file Parser.cpp.

                                                  {
   return Parse( Position(), filename, search_path, included, messages, root );
 }

bool Gaudi::Parsers::Parse	(	const Position &	from,
		const std::string &	filename,
		const std::string &	search_path,
		IncludedFiles *	included,
		Messages *	messages,
		Node *	root
	)

Definition at line 119 of file Parser.cpp.

                                                                           {
   using Grammar = FileGrammar<Iterator, SkipperGrammar<Iterator>>;
   return ParseFile<Grammar>( from, filename, search_path, included, messages, root );
 }

StatusCode Gaudi::Parsers::parse	(	TH1D &	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 284 of file HistoParsers.cpp.

                                                                      {
   // 1) check the parsing
   std::string name;
   //
   auto h1 = _parse_1D<TH1D>( input, name );
   if ( h1 ) {
     result.Reset();
     h1->Copy( result ); // ASSIGN
     result.SetName( name.c_str() );
     return StatusCode::SUCCESS; // RETURN
   }
   //
   // XML-like text?
   return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                     : StatusCode::FAILURE;
 }

template<class TYPE , std::size_t N>

StatusCode Gaudi::Parsers::parse	(	std::array< TYPE, N > &	result,
		const std::string &	input
	)

parse class std::array from the string

Parameters

result	(OUTPUT) the actual result
input	(INPUT) the input string

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-16

Definition at line 38 of file StdArrayAsProperty.h.

                                                                           {
       std::vector<TYPE> tmp;
       StatusCode        sc = parse( tmp, input );
       if ( sc.isFailure() ) return sc; // RETURN
       if ( N != tmp.size() ) return StatusCode( StatusCode::FAILURE, true );
       std::copy( tmp.begin(), tmp.end(), result.begin() );
       return StatusCode::SUCCESS;
     }

template<class SCALAR , unsigned int N>

StatusCode Gaudi::Parsers::parse	(	ROOT::Math::SVector< SCALAR, N > &	result,
		const std::string &	input
	)

parse SVector

Parameters

result	(output) the parsed vector
input	(input) the input string

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 42 of file SVectorAsProperty.h.

                                                                                    {
       std::vector<double> tmp;
       StatusCode          sc = parse( tmp, input );
       if ( sc.isFailure() ) { return sc; }                   // RETURN
       if ( N != tmp.size() ) { return StatusCode::FAILURE; } // RETURN
 #ifdef WIN32
 // Disable warning
 //    C4996: 'std::copy': Function call with parameters that may be unsafe
 // The parameters are checked
 #  pragma warning( push )
 #  pragma warning( disable : 4996 )
 #endif
       std::copy( tmp.begin(), tmp.end(), result.begin() );
 #ifdef WIN32
 #  pragma warning( pop )
 #endif
       return StatusCode::SUCCESS;
     }

StatusCode Gaudi::Parsers::parse	(	TH2D &	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 330 of file HistoParsers.cpp.

                                                                      {
   // 1) check the parsing
   std::string name;
   auto        h2 = _parse_2D<TH2D>( input, name );
   if ( h2 ) {
     result.Reset();
     h2->Copy( result ); // ASSIGN
     result.SetName( name.c_str() );
     return StatusCode::SUCCESS; // RETURN
   }
   //
   // XML-like text?
   return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                     : StatusCode::FAILURE;
 }

template<typename ResultT >

StatusCode Gaudi::Parsers::parse	(	ResultT &	result,
		const std::string &	input
	)

inline

Definition at line 48 of file Factory.h.

                                                                        {
       return parse_( result, input );
     }

StatusCode Gaudi::Parsers::parse	(	TH1F &	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 307 of file HistoParsers.cpp.

                                                                      {
   // 1) check the parsing
   std::string name;
   //
   auto h1 = _parse_1D<TH1F>( input, name );
   if ( h1 ) {
     result.Reset();
     h1->Copy( result ); // ASSIGN
     result.SetName( name.c_str() );
     return StatusCode::SUCCESS; // RETURN
   }
   //
   // XML-like text?
   return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                     : StatusCode::FAILURE;
 }

StatusCode Gaudi::Parsers::parse	(	TH2F &	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 352 of file HistoParsers.cpp.

                                                                      {
   // 1) check the parsing
   std::string name;
   auto        h2 = _parse_2D<TH2F>( input, name );
   if ( h2 ) {
     result.Reset();
     h2->Copy( result ); // ASSIGN
     result.SetName( name.c_str() );
     return StatusCode::SUCCESS; // RETURN
   }
   //
   // XML-like text?
   if ( std::string::npos != input.find( '<' ) ) { return Gaudi::Utils::Histos::fromXml( result, input ); }
   //
   return StatusCode::FAILURE;
 }

StatusCode Gaudi::Parsers::parse	(	AIDA::IHistogram1D &	result,
		const std::string &	input
	)

parse AIDA histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 421 of file HistoParsers.cpp.

                                                                                  {
   // 1) convert to ROOT
   auto root = Gaudi::Utils::Aida2ROOT::aida2root( &result );
   // 2) read ROOT histogram
   return root ? parse( *root, input ) : StatusCode::FAILURE;
 }

StatusCode Gaudi::Parsers::parse	(	Gaudi::XYZPoint &	result,
		const std::string &	input
	)

parse 3D-point

Valid representations of 3D-point:

- a'la python tuple with 3 elements ("canonical")
- a'la python list with 3 elements
- tuple or list with named ordered fields

" (1,2,3) "
" [1,2,3] "
" [ x : 1, 2, Z:3 ] "
" [ pX : 1 , PY : 2, 3] "

Valid keys for names fields:

"x", "X" , "pX" , "Px" , "PX "
"y", "Y" , "pY" , "Py" , "PY "
"z", "Z" , "pZ" , "Pz" , "PZ "

Attention: Named fields must be ordered (x,y,z)

Parameters

result	(output) the parsed point
input	(input) the input string

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 42 of file ParsersVct.cpp.

42 { return parse_( result, input ); }

Gaudi::Parsers::parse_

StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)

Definition: ParsersVct.cpp:32

StatusCode Gaudi::Parsers::parse	(	AIDA::IHistogram2D &	result,
		const std::string &	input
	)

parse AIDA histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 434 of file HistoParsers.cpp.

                                                                                  {
   // 1) convert to ROOT
   auto root = Gaudi::Utils::Aida2ROOT::aida2root( &result );
   // 2) read ROOT histogram
   return root ? parse( *root, input ) : StatusCode::FAILURE;
 }

template<class TYPE , std::size_t N>

StatusCode Gaudi::Parsers::parse	(	boost::array< TYPE, N > &	result,
		const std::string &	input
	)

parse class boost::array from the string

Parameters

result	(OUTPUT) the actual result
input	(INPUT) the input string

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-16

Definition at line 73 of file BoostArrayAsProperty.h.

                                                                             {
       typedef std::vector<TYPE> _Vct;
       // create the temporaty vector
       _Vct tmp;
       // parse the string
       StatusCode sc = parse( tmp, input );
       if ( sc.isFailure() ) { return sc; }                                       // RETURN
       if ( N != tmp.size() ) { return StatusCode( StatusCode::FAILURE, true ); } // RETURN
       // copy vector into array
       std::copy( tmp.begin(), tmp.end(), result.begin() );
       //
       return StatusCode::SUCCESS;
     }

StatusCode Gaudi::Parsers::parse	(	TH1D *&	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 375 of file HistoParsers.cpp.

                                                                       {
   if ( result ) { return parse( *result, input ); } // RETURN
 
   // 1) check the parsing
   std::string name;
   auto        h1 = _parse_1D<TH1D>( input, name );
   if ( h1 ) {
     result = h1.release();
     result->SetName( name.c_str() );
     return StatusCode::SUCCESS; // RETURN
   }
   //
   // XML-like text?
   return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                     : StatusCode::FAILURE;
 }

StatusCode Gaudi::Parsers::parse	(	TH2D *&	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns: status code

Definition at line 398 of file HistoParsers.cpp.

                                                                       {
   if ( result ) { return parse( *result, input ); } // RETURN
 
   // 1) check the parsing
   std::string name;
   auto        h2 = _parse_2D<TH2D>( input, name );
   if ( h2 ) {
     result = h2.release();
     result->SetName( name.c_str() );
     return StatusCode::SUCCESS; // RETURN
   }
   //
   // XML-like text?
   return ( std::string::npos != input.find( '<' ) ) ? Gaudi::Utils::Histos::fromXml( result, input )
                                                     : StatusCode::FAILURE;
 }

StatusCode Gaudi::Parsers::parse	(	DataObjectHandleBase &	v,
		const std::string &	s
	)

Definition at line 11 of file DataObjectHandleProperty.cpp.

                                                                     {
       DataObjID id;
       auto      sc = parse( id, s );
       if ( sc ) v.setKey( std::move( id ) );
       return sc;
     }

StatusCode Gaudi::Parsers::parse	(	Gaudi::XYZVector &	result,
		const std::string &	input
	)

parse 3D-vector

Valid representations of 3D-vector:

- a'la python tuple with 3 elements ("canonical")
- a'la python list with 3 elements
- tuple or list with named ordered fields

" (1,2,3) "
" [1,2,3] "
" [ x : 1, 2, Z:3 ] "
" [ pX : 1 , PY : 2, 3] "

Valid keys for names fields:

"x", "X" , "pX" , "Px" , "PX "
"y", "Y" , "pY" , "Py" , "PY "
"z", "Z" , "pZ" , "Pz" , "PZ "

Attention: Named fields must be ordered (x,y,z)

Parameters

result	(output) the parsed vector
input	(input) the input string

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 52 of file ParsersVct.cpp.

                                                                        {
 
       Gaudi::XYZPoint point;
       StatusCode      sc = parse( point, input );
       if ( sc.isFailure() ) { return sc; } // RETURN
       result = point;
       return StatusCode::SUCCESS; // RETURN
     }

StatusCode Gaudi::Parsers::parse	(	Gaudi::LorentzVector &	result,
		const std::string &	input
	)

parse LorentzVector

Valid representations of Lorenzt vector

- a'la python tuple with 4 elements ("canonical")
- a'la python list with 4 elements
- python/list with inner representation of 3D-point/vector
- tuple or list with named ordered fields

" (1,2,3,4) "
" (1,2,3;4) "
" [1,2,3,4] "
" [1,2,3;4] "
" [ x:1 ,2,3; e= 4] "
" [ pX : 1 , PY : 2, 3 , T= 4] "
" [ ( pX : 1 , PY : 2, 3 ) , 4] "
" [ ( pX : 1 , PY : 2, 3 ) ; 4] "
" [ 4 , ( pX : 1 , PY : 2, 3 ) ] "
" [ 4 ; ( pX : 1 , PY : 2, 3 ) ] "
" [ [ pX : 1 , PY : 2, 3 ] , 4] "
" [ [ pX : 1 , PY : 2, 3 ] ; 4] "
" [ 4 , [ pX : 1 , PY : 2, 3 ] ] "
" [ 4 ; [ pX : 1 , PY : 2, 3 ] ] "
" ( ( pX : 1 , PY : 2, 3 ) , 4 )"
" ( ( pX : 1 , PY : 2, 3 ) ; 4 )"
" ( 4 , ( pX : 1 , PY : 2, 3 ) )"
" ( 4 ; ( pX : 1 , PY : 2, 3 ) )"
" ( [ pX : 1 , PY : 2, 3 ] , 4 )"
" ( [ pX : 1 , PY : 2, 3 ] ; 4 )"
" ( 4 , [ pX : 1 , PY : 2, 3 ] )"
" ( 4 ; [ pX : 1 , PY : 2, 3 ] )"

Note that "eenrgy" element can be separated with semicolumn.

Valid keys for names fields:

"x", "X" , "pX" , "Px" , "PX "
"y", "Y" , "pY" , "Py" , "PY "
"z", "Z" , "pZ" , "Pz" , "PZ "
"t", "T" , "e"  , "E"

Attention: Named fields must be ordered (x,y,z)

Parameters

result	(output) the parsed lorentz vector
input	(input) the input string

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 61 of file ParsersVct.cpp.

61 { return parse_( result, input ); }

Gaudi::Parsers::parse_

StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)

Definition: ParsersVct.cpp:32

StatusCode Gaudi::Parsers::parse	(	std::vector< Gaudi::XYZPoint > &	result,
		const std::string &	input
	)

parse the vector of points

Parameters

resut	(OUTPUT) the parser vector
input	(INPIUT) the string to be parsed

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 71 of file ParsersVct.cpp.

                                                                                  {
       result.clear();
       return parse_( result, input );
     }

StatusCode Gaudi::Parsers::parse	(	std::vector< Gaudi::XYZVector > &	result,
		const std::string &	input
	)

parse the vector of vectors

Parameters

resut	(OUTPUT) the parser vector
input	(INPIUT) the string to be parsed

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 83 of file ParsersVct.cpp.

                                                                                   {
       result.clear();
       return parse_( result, input );
     }

StatusCode Gaudi::Parsers::parse	(	std::vector< Gaudi::LorentzVector > &	result,
		const std::string &	input
	)

parse the vector of vectors

Parameters

resut	(OUTPUT) the parser vector
input	(INPIUT) the string to be parsed

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-05

Definition at line 97 of file ParsersVct.cpp.

                                                                                       {
       return parse_( result, input );
     }

StatusCode Gaudi::Parsers::parse	(	std::vector< std::pair< double, double >> &	result,
		const std::string &	input
	)

parse the bool value

See also: Gaudi::Parsers::BoolGrammar

Parameters

result	(output) boolean result
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-12parse the char value

See also: Gaudi::Parsers::CharGrammar

Parameters

result	(output) boolean result
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-12

See also: Gaudi::Parsers::parser( char&, const std::string& ); Gaudi::Parsers::parser( char&, const std::string& ) parse the int value; Gaudi::Parsers::IntGrammar

Parameters

result	(output) integer result
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

See also: Gaudi::Parsers::parser( int&, const std::string& ); Gaudi::Parsers::parser( int&, const std::string& ); Gaudi::Parsers::parser( int&, const std::string& ); Gaudi::Parsers::parser( int&, const std::string& ); Gaudi::Parsers::parser( int&, const std::string& ); Gaudi::Parsers::parser( int&, const std::string& ); Gaudi::Parsers::parser( int&, const std::string& ) parse the double value; Gaudi::Parsers::RealGrammar

Parameters

result	(output) double result
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

See also: Gaudi::Parsers::parser( double&, const std::string& ); Gaudi::Parsers::parser( double&, const std::string& ) parse the std::string value; Gaudi::Parsers::StringGrammar

Parameters

result	(output) string result
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14parse the std::pair<double,double> value

See also: Gaudi::Parsers::PairGrammar; Gaudi::Parsers::RealGrammar

Parameters

result	(output) pair of doubles
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14parse the std::pair<int,int> value

See also: Gaudi::Parsers::PairGrammar; Gaudi::Parsers::IntGrammar

Parameters

result	(output) pair of integers
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14parse the std::vector<std::pair<double,double> > value

See also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::PairGrammar; Gaudi::Parsers::RealGrammar

Parameters

result	(output) vector with pairs of doubles
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 11 of file ParsersStandardMisc1.cpp.

                                                                                                    {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::vector< std::pair< int, int >> &	result,
		const std::string &	input
	)

parse the std::vector<std::pair<int,int> > value

See also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::PairGrammar; Gaudi::Parsers::IntGrammar

Parameters

result	(output) vector with pairs of int
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 15 of file ParsersStandardMisc1.cpp.

                                                                                              {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::vector< std::vector< std::string >> &	result,
		const std::string &	input
	)

parse the std::vector<std::vector<std::string> > value

See also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::StringGrammar

Parameters

result	(output) vector with vectors of strings
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 19 of file ParsersStandardMisc1.cpp.

                                                                                                 {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	Gaudi::StringKey &	result,
		const std::string &	input
	)

parse the key from the string

See also: Gaudi::Parsers; Gaudi::Parsers::parse; Gaudi::StringKey

Attention: : this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns: status code

Definition at line 74 of file StringKey.cpp.

                                                                                {
   std::string _result;
   StatusCode  sc = parse( _result, input );
   result         = Gaudi::StringKey( _result );
   return sc;
 }

StatusCode Gaudi::Parsers::parse	(	std::vector< std::vector< double >> &	result,
		const std::string &	input
	)

parse the std::vector<std::vector<double> > value

See also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::RealGrammar

Parameters

result	(output) vector with vectors of doubles
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 3 of file ParsersStandardMisc2.cpp.

                                                                                              {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::vector< Gaudi::StringKey > &	result,
		const std::string &	input
	)

parse the vector of keys from the string

See also: Gaudi::Parsers; Gaudi::Parsers::parse; Gaudi::StringKey

Attention: : this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns: status code

Definition at line 91 of file StringKey.cpp.

                                                                                           {
   result.clear();
   typedef std::vector<std::string> Strings;
   Strings                          _result;
   StatusCode                       sc = parse( _result, input );
   if ( sc.isFailure() ) { return sc; } // RETURN
   result.reserve( _result.size() );
   //
   std::copy( _result.begin(), _result.end(), std::back_inserter( result ) );
   //
   return StatusCode::SUCCESS;
 }

StatusCode Gaudi::Parsers::parse	(	std::map< int, int > &	result,
		const std::string &	input
	)

parse the std::map<int , int> value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::IntGrammar

Parameters

result	(output) map with integer key and double value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 7 of file ParsersStandardMisc2.cpp.

                                                                                  {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< int, double > &	result,
		const std::string &	input
	)

parse the std::map<int , double> value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::IntGrammar; Gaudi::Parsers::RealGrammar

Parameters

result	(output) map with integer key and double value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 11 of file ParsersStandardMisc2.cpp.

                                                                                     {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, std::string > &	result,
		const std::string &	input
	)

parse the std::map<std::string , std::string> value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::StringGrammar

Parameters

result	(output) map with string key and value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 15 of file ParsersStandardMisc2.cpp.

                                                                                              {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, int > &	result,
		const std::string &	input
	)

parse the std::map<std::string , int> value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::StringGrammar; Gaudi::Parsers::IntGrammar

Parameters

result	(output) map with string key and integer value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 3 of file ParsersStandardMisc3.cpp.

                                                                                        {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, double > &	result,
		const std::string &	input
	)

parse the std::map<std::string , double> value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::StringGrammar; Gaudi::Parsers::RealGrammar

Parameters

result	(output) map with string key and integer value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 11 of file ParsersStandardMisc3.cpp.

                                                                                           {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, std::vector< std::string >> &	result,
		const std::string &	input
	)

parse the std::map<std::string , std::vector<std::string> > value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::StringGrammar; Gaudi::Parsers::VectorGrammar

Parameters

result	(output) map with string value and vector of strings as value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 15 of file ParsersStandardMisc3.cpp.

                                                                                                         {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, std::vector< int >> &	result,
		const std::string &	input
	)

parse the std::map<std::string , std::vector<int> > value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::StringGrammar; Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::IntGrammar

Parameters

result	(output) map with string value and vector of integers as value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 3 of file ParsersStandardMisc4.cpp.

                                                                                                   {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, std::vector< double >> &	result,
		const std::string &	input
	)

parse the std::map<std::string , std::vector<double> > value

See also: Gaudi::Parsers::MapGrammar; Gaudi::Parsers::StringGrammar; Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::RealGrammar

Parameters

result	(output) map with string value and vector of doubles as value
input	(input) the string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-14

Definition at line 7 of file ParsersStandardMisc4.cpp.

                                                                                                      {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< int, std::string > &	result,
		const std::string &	input
	)

parse the std::map<int,std::string> > objects

See also: Gaudi::Parsers::MapGrammar

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u; Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date: 2007-12-06

Definition at line 11 of file ParsersStandardMisc4.cpp.

                                                                                        {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< unsigned int, std::string > &	result,
		const std::string &	input
	)

parse the std::map<unsigned int,std::string> > objects

See also: Gaudi::Parsers::MapGrammar

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u; Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date: 2007-12-06

Definition at line 3 of file ParsersStandardMisc5.cpp.

                                                                                                 {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, unsigned int > &	result,
		const std::string &	input
	)

parse the std::map<unsigned int,std::string> > objects

See also: Gaudi::Parsers::MapGrammar

Definition at line 7 of file ParsersStandardMisc3.cpp.

                                                                                                 {
   return Gaudi::Parsers::parse_( result, input );
 }

template<typename K , typename V , typename M >

GAUDI_API StatusCode Gaudi::Parsers::parse	(	GaudiUtils::Map< K, V, M > &	result,
		const std::string &	input
	)

parse the GaudiUtils::Map<K, V, M> objects

See also: Gaudi::Parsers::MapGrammar

Definition at line 416 of file CommonParsers.h.

                                                                                          {
       return parse( (M&)result, input );
     }

StatusCode Gaudi::Parsers::parse	(	std::string &	name,
		std::string &	value,
		const std::string &	input
	)

parse the pair expression (map-component) " 'name' :value"

const std::string input = "'PackageName':GaudiKernel" ;
std::string name  ;
std::string value ;
StatusCode sc = Gaudi::Parsers::parse ( name , value , input ) ;
if ( sc.isFailure() ) { ... }
std::cout <<  "\tParsed name  is " << name
          <<  "\tParsed value is " << value << std::endl

Parameters

name	(output) the parsed name of the component, defined as 'name' or "name" before the column symbol ":", the leading and trailing blans are omitted
value	(output) the parsed value of the component, defined as everything after the column symbol ":" till the end of the string
input	(input) string to be parsed

Returns: status code

Author: Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com; Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date: 2006-05-12

Definition at line 7 of file ParsersStandardMisc5.cpp.

                                                                                           {
   Skipper                                      skipper;
   KeyValueGrammar<IteratorT, Skipper>          g;
   KeyValueGrammar<IteratorT, Skipper>::ResultT result;
   auto                                         iter = input.begin();
   bool parse_result = qi::phrase_parse( iter, input.end(), g, skipper, result ) && ( iter == input.end() );
   if ( parse_result ) {
     name  = result.first;
     value = result.second;
     return StatusCode::SUCCESS;
   }
   return StatusCode::FAILURE;
 }

StatusCode Gaudi::Parsers::parse	(	Gaudi::Histo1DDef &	histo,
		const std::string &	input
	)

helper function, needed for implementation of "Histogram Property"

Parameters

histo	the histogram description (output)
input	the string to be parsed

Returns: status code

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u; Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date: 2007-09-17

Definition at line 8 of file ParsersHistograms.cpp.

                                                                                 {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, Gaudi::Histo1DDef > &	histos,
		const std::string &	input
	)

helper function, needed for implementation of "Histogram Property"

Parameters

histos	the map of the histogram descriptions (output)
input	the string to be parsed

Returns: status code

Author: Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u; Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date: 2007-09-17

Definition at line 12 of file ParsersHistograms.cpp.

                                                                                                    {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	std::map< std::string, std::pair< double, double >> &	params,
		const std::string &	input
	)

helper function, needed for implementation of map of pairs It is very useful construction for monitoring to represent the value and error or the allowed range for some parameter

Parameters

params	the map of pair
input	the string to be parsed

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl; Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date: 2009-05-19

Definition at line 21 of file ParsersStandardMisc5.cpp.

                                                                                                            {
   return Gaudi::Parsers::parse_( result, input );
 }

template<class T , unsigned int N>

StatusCode Gaudi::Parsers::parse	(	T(&)	result[N],
		const std::string &	input
	)

parser function for C-arrays

Parameters

params	C-array
input	the string to be parsed

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-15

Definition at line 489 of file CommonParsers.h.

                                                                  {
       typedef std::vector<T> _Vct;
       // create the temporary vector
       _Vct       tmp;
       StatusCode sc = parse( tmp, input );
       if ( sc.isFailure() ) { return sc; }                   //  RETURN
       if ( N != tmp.size() ) { return StatusCode::FAILURE; } //  RETURN
       //
       std::copy( tmp.begin(), tmp.end(), result );
       //
       return StatusCode::SUCCESS; //  RETURN
     }

template<unsigned int N>

StatusCode Gaudi::Parsers::parse	(	char(&)	result[N],
		const std::string &	input
	)

parser function for C-strings

Parameters

params	C-string
input	the string to be parsed

Returns: status code

Author: Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date: 2009-09-15

Definition at line 510 of file CommonParsers.h.

                                                                     {
       // clear the string
       std::fill_n( result, N, ' ' );
       // create the temporary string
       std::string tmp;
       StatusCode  sc = parse( tmp, input );
       if ( sc.isFailure() ) { return sc; } //  RETURN
       if ( N == tmp.size() ) {
         std::copy( tmp.begin(), tmp.end(), result );
       } else if ( N + 2 == tmp.size() && ( '\'' == tmp[0] || '\"' == tmp[0] ) && ( tmp[0] == tmp[tmp.size() - 1] ) ) {
         std::copy( tmp.begin() + 1, tmp.end() - 1, result );
       } else {
         return StatusCode::FAILURE;
       }
       //
       return StatusCode::SUCCESS; //  RETURN
     }

StatusCode Gaudi::Parsers::parse	(	GaudiUtils::VectorMap< std::string, double > &	result,
		const std::string &	input
	)

parse the key from the string

See also: Gaudi::Parsers; Gaudi::Parsers::parse; Gaudi::VectorMap

Attention: : this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns: status code

Definition at line 9 of file ParsersCollections.cpp.

                                                                                                        {
   return Gaudi::Parsers::parse_( result, input );
 }

StatusCode Gaudi::Parsers::parse	(	GaudiUtils::VectorMap< Gaudi::StringKey, double > &	result,
		const std::string &	input
	)

parse the vector of keys from the string

See also: Gaudi::Parsers; Gaudi::Parsers::parse; Gaudi::VectorMap; Gaudi::StringKey

Attention: : this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns: status code

Definition at line 13 of file ParsersCollections.cpp.

                                                                                                             {
   return Gaudi::Parsers::parse_( result, input );
 }

template<typename ResultT >

StatusCode Gaudi::Parsers::parse_	(	ResultT &	result,
		const std::string &	input
	)

inline

Definition at line 29 of file Factory.h.

                                                                         {
       Skipper                                                 skipper;
       typename Grammar_<IteratorT, ResultT, Skipper>::Grammar g;
       IteratorT                                               iter = input.begin(), end = input.end();
       return ( qi::phrase_parse( iter, end, g, skipper, result ) && ( iter == end ) ? StatusCode::SUCCESS
                                                                                     : StatusCode::FAILURE );
     }

template<typename T1 , typename T2 >

StatusCode Gaudi::Parsers::parse_	(	ROOT::Math::PositionVector3D< T1, T2 > &	result,
		const std::string &	input
	)

inline

Definition at line 32 of file ParsersVct.cpp.

                                                                                                  {
       Skipper                                                                              skipper;
       typename Grammar_<IteratorT, ROOT::Math::PositionVector3D<T1, T2>, Skipper>::Grammar g;
       IteratorT iter = input.begin(), end = input.end();
       if ( qi::phrase_parse( iter, end, g, skipper, result ) ) { return StatusCode::SUCCESS; }
       //@attention always
       return StatusCode::SUCCESS;
     }

template<>

StatusCode Gaudi::Parsers::parse_	(	std::string &	result,
		const std::string &	input
	)

inline

Definition at line 38 of file Factory.h.

                                                                           {
       Skipper                                            skipper;
       Grammar_<IteratorT, std::string, Skipper>::Grammar g;
       IteratorT                                          iter = input.begin(), end = input.end();
       if ( !( qi::phrase_parse( iter, end, g, skipper, result ) && ( iter == end ) ) ) { result = input; }
       //@attention always
       return StatusCode::SUCCESS;
     }

bool Gaudi::Parsers::ParseUnits	(	const Position &	from,
		const std::string &	filename,
		const std::string &	search_path,
		IncludedFiles *	included,
		Messages *	messages,
		Node *	root
	)

Definition at line 126 of file Parser.cpp.

                                                                                {
   using Grammar = UnitsGrammar<Iterator, SkipperGrammar<Iterator>>;
   return ParseFile<Grammar>( from, filename, search_path, included, messages, root );
 }

bool Gaudi::Parsers::ReadOptions	(	const std::string &	filename,
		const std::string &	search_path,
		Messages *	messages,
		Catalog *	catalog,
		Units *	units,
		PragmaOptions *	pragma,
		Node *	root
	)

Parse and analyze filename, save all messages and properties.

Also output AST tree (http://en.wikipedia.org/wiki/Abstract_syntax_tree). Returns true if there were no errors during analysis.

Definition at line 374 of file Analyzer.cpp.

                                                                         {
   // Extract Path
   IncludedFiles included;
   bool          result = Parse( filename, search_path, &included, messages, root );
   if ( !result ) return false;
 
   bool result1 = Analyze( root, search_path, &included, messages, catalog, units, pragma );
   bool result2 = Unreference( *catalog, messages );
   return result1 && result2;
 }

Gaudi::Parsers::REGISTER_GRAMMAR	(	GaudiMath::Interpolation::Type	,
		InterpolGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	DataObjID	,
		DataObjIDGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	Edges	,
		EdgeGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	std::string	,
		StringGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	Gaudi::StringKey	,
		StringGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	char	,
		CharGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	H1	,
		H1Grammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	bool	,
		BoolGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	H2	,
		H2Grammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	Gaudi::Histo1DDef	,
		Histo1DGrammar
	)

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation