Namespaces
namespace	Utils

Classes
class	Catalog

class	SkipperGrammar
	Skipping spaces and comments. More...

class	StringGrammar
	The valid represenation of string values are: More...

struct	IdentifierGrammar

class	BoolGrammar
	The valid represenation of boolean values are: More...

class	RealGrammar
	The valid represenation of real values are: More...

struct	UnitsGrammar

struct	FileGrammar

class	IncludedFiles

class	Messages

class	Node

class	NodeOperations

class	Position

class	PragmaOptions

class	Property

class	PropertyName

class	PropertyValue

class	PropertyValueException

class	PositionalPropertyValueException

class	Units

struct	ClosureGrammar
	Grammar or grammar rule which derive from this struct will have attribute of type `T` and name `val` More...

struct	AttributesClosureGrammar
	Grammar or grammar rule which derive from this struct will have two attributes: type `T1` and name `val`, type `T2` and name `attrs` More...

class	CharGrammar
	The valid represenation of char values are: More...

class	IntGrammar
	The valid representation of integers values are: More...

class	PairGrammar
	The valid represenation of pairs are: ("abc",123) or ("abc","def") Inner types of pair depends on KeyGrammarT and ValueGrammarT grammars. More...

class	VectorGrammar
	The valid represenation of vector are: More...

class	MapGrammar
	The valid represenation of map are: More...

struct	Grammar_

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

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

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

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

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

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

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

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

struct	Pnt3DGrammar

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

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

struct	Pnt4DGrammar

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

struct	Histo1DGrammar

struct	KeyValueGrammar

class	EdgeGrammar

class	H1Grammar

class	H2Grammar

Typedefs
typedef std::string::const_iterator	DefaultIterator

typedef enc::space_type	DefaultSkipper

typedef boost::spirit::position_iterator < string::const_iterator >	IteratorT
	the actual type of position iterator

typedef SkipperGrammar< IteratorT >	Skipper

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.

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.

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

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)

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

	REGISTER_GRAMMAR (std::string, StringGrammar)

	REGISTER_GRAMMAR (Gaudi::StringKey, StringGrammar)

	REGISTER_GRAMMAR (char, CharGrammar)

	REGISTER_GRAMMAR (bool, BoolGrammar)

	REGISTER_GRAMMAR (Gaudi::Histo1DDef, Histo1DGrammar)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

IteratorT	createIterator (const std::string &input)
	create the position iterator from the input

template<typename IntegerT >
StatusCode	parse_integer (IntegerT &result, const string &input)
	helper function to "merge" the implementation of all parsers for integer-like quantities into one templated grammar

template<typename IntegerT >
StatusCode	parse_integer_vector (std::vector< IntegerT > &result, const string &input)
	helper function to "merge" the implementation of all parsers for vector of integer-like quantities into the combination of templated grammars

template<typename CharT >
StatusCode	parse_char (CharT &result, const string &input)
	helper function to "merge" the implementation of all parsers for "char-like" quantities into one templated grammar

template<typename CharT >
StatusCode	parse_char_vector (std::vector< CharT > &result, const string &input)
	helper function to "merge" the implementation of all parsers for vector of 'char-like' quantities into the combination of templated grammars

template<typename RealT >
StatusCode	parse_real (RealT &result, const string &input)
	helper function to "merge" the implementation of all parsers for "float-like" quantities into one templated grammar

template<typename RealT >
StatusCode	parse_real_vector (std::vector< RealT > &result, const string &input)
	helper function to "merge" the implementation of all parsers for vector of 'char-like' quantities into the combination of templated grammars

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	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 53 of file GrammarsV2.h.

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

Definition at line 54 of file GrammarsV2.h.

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

the actual type of position iterator

Definition at line 64 of file Parsers.icpp.

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

Definition at line 28 of file ParsersFactory.h.

Function Documentation

IteratorT Gaudi::Parsers::createIterator ( const std::string & input )

inline

create the position iterator from the input

Definition at line 67 of file Parsers.icpp.

{ return IteratorT ( input.begin(), input.end() ) ; }

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

inline

printout operator

Definition at line 57 of file Catalog.h.

                                                                {
   return c.fillStream(o);
 }

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 104 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 111 of file Parser.cpp.

                                        {
    typedef FileGrammar<Iterator,SkipperGrammar<Iterator> > Grammar;
    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 344 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  //
  std::auto_ptr<TH1D> h1 = _parse_1D<TH1D> ( input , name ) ;
  if ( 0 != h1.get() )
  {
    result.Reset() ;
    h1->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	(	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 400 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  std::auto_ptr<TH2D> h2 = _parse_2D<TH2D> ( input , name ) ;
  if ( 0 != h2.get() )
  {
    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 ;
}

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 47 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	(	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 372 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  //
  std::auto_ptr<TH1F> h1 = _parse_1D<TH1F> ( input , name ) ;
  if ( 0 != h1.get() )
  {
    result.Reset() ;
    h1->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	(	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 427 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  std::auto_ptr<TH2F> h2 = _parse_2D<TH2F> ( input , name ) ;
  if ( 0 != h2.get() )
  {
    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 510 of file HistoParsers.cpp.

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

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 50 of file ParsersVct.cpp.

                                             {
    return parse_(result, input);
  }

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 526 of file HistoParsers.cpp.

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

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 84 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 454 of file HistoParsers.cpp.

{
  if ( 0 != result ) { return parse ( *result , input ) ; } // RETURN
  // 1) check the parsing
  std::string name ;
  std::auto_ptr<TH1D> h1 = _parse_1D<TH1D>  ( input , name ) ;
  if ( 0 != h1.get() )
  {
    result = h1.release() ;
    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	(	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 482 of file HistoParsers.cpp.

{
  if ( 0 != result ) { return parse ( *result , input ) ; } // RETURN
  // 1) check the parsing
  std::string name ;
  std::auto_ptr<TH2D> h2 = _parse_2D<TH2D>  ( input , name ) ;
  if ( 0 != h2.get() )
  {
    result = h2.release() ;
    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	(	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 64 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 75 of file ParsersVct.cpp.

                                                                       {
    return parse_(result, input);
  }

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 88 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 103 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 120 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&,std::string&); Gaudi::Parsers::parser(char&,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	(	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	(	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 79 of file StringKey.cpp.

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

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 99 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);
}

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;
  std::string::const_iterator 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 parse_result;
}

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 9 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 14 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 22 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 525 of file Parsers.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 547 of file Parsers.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 11 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 17 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 31 of file ParsersFactory.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);
    }

template<typename T1 , typename T2 >

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

inline

Definition at line 38 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 true;
  }

template<>

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

inline

Definition at line 39 of file ParsersFactory.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 true;
    }

template<typename CharT >

StatusCode Gaudi::Parsers::parse_char	(	CharT &	result,
		const string &	input
	)

inline

helper function to "merge" the implementation of all parsers for "char-like" quantities into one templated grammar

See Also: Gaudi::Parsers::CharGrammar

Parameters

result	(output) parsing result
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 138 of file Parsers.icpp.

    {
      CharGrammar<CharT> g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1]).full;
    }

template<typename CharT >

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

inline

helper function to "merge" the implementation of all parsers for vector of 'char-like' quantities into the combination of templated grammars

See Also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::CharGrammar; Gaudi::Parsers::SkipperGrammar

Parameters

result	(output) parsing result
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 165 of file Parsers.icpp.

    {
      VectorGrammar<CharGrammar<CharT> > g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }

template<typename IntegerT >

StatusCode Gaudi::Parsers::parse_integer	(	IntegerT &	result,
		const string &	input
	)

inline

helper function to "merge" the implementation of all parsers for integer-like quantities into one templated grammar

See Also: Gaudi::Parsers::IntGrammar

Parameters

result	(output) parsing result
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 86 of file Parsers.icpp.

    {
      IntGrammar<IntegerT> g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1]).full;
    }

template<typename IntegerT >

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

inline

helper function to "merge" the implementation of all parsers for vector of integer-like quantities into the combination of templated grammars

See Also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::IntGrammar; Gaudi::Parsers::SkipperGrammar

Parameters

result	(output) parsing result
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 113 of file Parsers.icpp.

    {
      VectorGrammar<IntGrammar<IntegerT> > g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }

template<typename RealT >

StatusCode Gaudi::Parsers::parse_real	(	RealT &	result,
		const string &	input
	)

inline

helper function to "merge" the implementation of all parsers for "float-like" quantities into one templated grammar

See Also: Gaudi::Parsers::RealGrammar

Parameters

result	(output) parsing result
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 189 of file Parsers.icpp.

    {
      RealGrammar<RealT> g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }

template<typename RealT >

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

helper function to "merge" the implementation of all parsers for vector of 'char-like' quantities into the combination of templated grammars

See Also: Gaudi::Parsers::VectorGrammar; Gaudi::Parsers::RealGrammar; Gaudi::Parsers::SkipperGrammar

Parameters

result	(output) parsing result
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 217 of file Parsers.icpp.

    {
      VectorGrammar< RealGrammar<RealT> > g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }

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 121 of file Parser.cpp.

                                        {
    typedef UnitsGrammar<Iterator,SkipperGrammar<Iterator> > Grammar;
    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 439 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	(	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	(	bool	,
		BoolGrammar
	)

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

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

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

Gaudi Framework, version v23r7

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation