| The Gaudi Framework v27r1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Namespace List
- Namespace Members

Namespaces | Classes | Typedefs | Functions
Gaudi::Parsers Namespace Reference

## Namespaces
| Utils

## Classes
struct | BoolGrammar
class | Catalog
struct | CharGrammar
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::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 | IntGrammar
struct | KeyValueGrammar
struct | MapGrammar
class | Messages
class | Node
class | 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 | DefaultIterator
typedef enc::space_type | DefaultSkipper
typedef std::string::const_iterator | IteratorT
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. 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)
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 &)
StatusCode | parse (DataObjID &, const std::string &)
StatusCode | parse (DataObjIDColl &, const std::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 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)
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...
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 54 of file GrammarsV2.h.

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

Definition at line 55 of file GrammarsV2.h.

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

Definition at line 26 of file ParsersFactory.h.

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

Definition at line 28 of file ParsersFactory.h.

## Function Documentation

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

printout operator

Definition at line 56 of file Catalog.h.

56 {
57 return c.fillStream(o);
58 }
gaudirun.c
tuple c
Definition: gaudirun.py:391
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.

11 {
12 std::map<std::string, std::string> tmp;
13 StatusCode sc = parse(tmp, input);
14 if (sc.isSuccess()) {
15 result.clear();
16 result.insert(tmp.begin(), tmp.end());
17 }
18 return sc;
19 }
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
std::map::end
T end(T...args)
merge_files.sc
int sc
Definition: merge_files.py:167
std::map< std::string, std::string >
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::map::begin
T begin(T...args)
GaudiUtils::Map::insert
std::pair< iterator, bool > insert(ValueType &&val)
Definition: Map.h:168
GaudiUtils::Map::clear
void clear()
Definition: Map.h:178

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

Definition at line 125 of file Parser.cpp.

127 {
128 return Parse(Position(), filename, search_path, included, messages,
129 root);
130 }
Gaudi::Parsers::Parse
bool Parse(const std::string &filename, const std::string &search_path, IncludedFiles *included, Messages *messages, Node *root)
Definition: Parser.cpp:125
IOTest.root
tuple root
Definition: IOTest.py:42

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

135 {
136 using Grammar = FileGrammar<Iterator,SkipperGrammar<Iterator>>;
137 return ParseFile<Grammar>(from, filename, search_path, included,
138 messages, root);
139 }
graphanalysis.filename
string filename
Definition: graphanalysis.py:109
IOTest.root
tuple root
Definition: IOTest.py:42

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

341 {
342 // 1) check the parsing
343 std::string name ;
344 //
345 auto h1 = _parse_1D<TH1D> ( input , name ) ;
346 if ( h1 )
347 {
348 result.Reset() ;
349 h1->Copy ( result ) ; // ASSIGN
350 result.SetName ( name.c_str () ) ;
351 return StatusCode::SUCCESS ; // RETURN
352 }
353 //
354 // XML-like text?
355 return ( std::string::npos != input.find('<') )
356 ? Gaudi::Utils::Histos::fromXml ( result , input )
357 : StatusCode::FAILURE ;
358 }
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:229
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
read_lhcb_event_file.h1
tuple h1
Definition: read_lhcb_event_file.py:17
std::string
STL class.
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::string::c_str
T c_str(T...args)
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 45 of file SVectorAsProperty.h.

47 {
48 std::vector<double> tmp ;
49 StatusCode sc = parse ( tmp , input ) ;
50 if ( sc.isFailure() ) { return sc ; } // RETURN
51 if ( N != tmp.size() ) { return StatusCode::FAILURE ; } // RETURN
52 #ifdef WIN32
53 // Disable warning
54 // C4996: 'std::copy': Function call with parameters that may be unsafe
55 // The parameters are checked
56 #pragma warning(push)
57 #pragma warning(disable:4996)
58 #endif
59 std::copy ( tmp.begin() , tmp.end() , result.begin() ) ;
60 #ifdef WIN32
61 #pragma warning(pop)
62 #endif
63 return StatusCode::SUCCESS ;
64 }
std::copy
T copy(T...args)
Gaudi::Parsers::parse
StatusCode parse(ROOT::Math::SVector< SCALAR, N > &result, const std::string &input)
parse SVector
Definition: SVectorAsProperty.h:45
std::vector::end
T end(T...args)
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
IOTest.N
int N
Definition: IOTest.py:90
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::vector::size
T size(T...args)
std::vector< double >
std::vector::begin
T begin(T...args)

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

395 {
396 // 1) check the parsing
397 std::string name ;
398 auto h2 = _parse_2D<TH2D> ( input , name ) ;
399 if ( h2 )
400 {
401 result.Reset() ;
402 h2->Copy ( result ) ; // ASSIGN
403 result.SetName ( name.c_str () ) ;
404 return StatusCode::SUCCESS ; // RETURN
405 }
406 //
407 // XML-like text?
408 return ( std::string::npos != input.find('<') )
409 ? Gaudi::Utils::Histos::fromXml ( result , input )
410 : StatusCode::FAILURE ;
411 }
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:229
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
std::string
STL class.
Test.h2
tuple h2
Definition: Test.py:42
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::string::c_str
T c_str(T...args)
template<typename ResultT >

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

Definition at line 51 of file ParsersFactory.h.

51 {
52
53 return parse_(result, input);
54 }
Gaudi::Parsers::parse_
StatusCode parse_(std::string &result, const std::string &input)
Definition: ParsersFactory.h:39

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

368 {
369 // 1) check the parsing
370 std::string name ;
371 //
372 auto h1 = _parse_1D<TH1F> ( input , name ) ;
373 if ( h1 )
374 {
375 result.Reset() ;
376 h1->Copy ( result ) ; // ASSIGN
377 result.SetName ( name.c_str () ) ;
378 return StatusCode::SUCCESS ; // RETURN
379 }
380 //
381 // XML-like text?
382 return ( std::string::npos != input.find('<') )
383 ? Gaudi::Utils::Histos::fromXml ( result , input )
384 : StatusCode::FAILURE ;
385 }
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:229
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
read_lhcb_event_file.h1
tuple h1
Definition: read_lhcb_event_file.py:17
std::string
STL class.
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::string::c_str
T c_str(T...args)

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

421 {
422 // 1) check the parsing
423 std::string name ;
424 auto h2 = _parse_2D<TH2F> ( input , name ) ;
425 if ( h2 )
426 {
427 result.Reset() ;
428 h2->Copy ( result ) ; // ASSIGN
429 result.SetName ( name.c_str () ) ;
430 return StatusCode::SUCCESS ; // RETURN
431 }
432 //
433 // XML-like text?
434 if ( std::string::npos != input.find('<') )
435 { return Gaudi::Utils::Histos::fromXml ( result , input ) ; }
436 //
437 return StatusCode::FAILURE ;
438 }
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:229
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
std::string
STL class.
Test.h2
tuple h2
Definition: Test.py:42
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::string::c_str
T c_str(T...args)

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

50 {
51 return parse_(result, input);
52 }
Gaudi::Parsers::parse_
StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)
Definition: ParsersVct.cpp:37

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

502 {
503 // 1) convert to ROOT
504 auto root = Gaudi::Utils::Aida2ROOT::aida2root ( &result ) ;
505 // 2) read ROOT histogram
506 return root ? parse ( *root , input ) : StatusCode::FAILURE ;
507 }
GaudiPython.Bindings.FAILURE
tuple FAILURE
Definition: Bindings.py:52
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Gaudi::Utils::Aida2ROOT::aida2root
static TH1D * aida2root(AIDA::IHistogram1D *aida)
get the underlying pointer for 1D-histogram
Definition: Aida2ROOT.cpp:72
IOTest.root
tuple root
Definition: IOTest.py:42

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

517 {
518 // 1) convert to ROOT
519 auto root = Gaudi::Utils::Aida2ROOT::aida2root ( &result ) ;
520 // 2) read ROOT histogram
521 return root ? parse ( *root , input ) : StatusCode::FAILURE ;
522 }
GaudiPython.Bindings.FAILURE
tuple FAILURE
Definition: Bindings.py:52
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Gaudi::Utils::Aida2ROOT::aida2root
static TH1D * aida2root(AIDA::IHistogram1D *aida)
get the underlying pointer for 1D-histogram
Definition: Aida2ROOT.cpp:72
IOTest.root
tuple root
Definition: IOTest.py:42
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 81 of file StdArrayAsProperty.h.

82 {
83 typedef std::vector<TYPE> _Vct ;
84 // create the temporaty vector
85 _Vct tmp ;
86 // parse the string
87 StatusCode sc = parse ( tmp , input ) ;
88 if ( sc.isFailure () ) { return sc ; } // RETURN
89 if ( N != tmp.size() )
90 { return StatusCode ( StatusCode::FAILURE , true ) ; } // RETURN
91 // copy vector into array
92 std::copy ( tmp.begin() , tmp.end() , result.begin() ) ;
93 //
94 return StatusCode::SUCCESS ;
95 }
std::copy
T copy(T...args)
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
IOTest.N
int N
Definition: IOTest.py:90
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Gaudi::Parsers::parse
StatusCode parse(std::array< TYPE, N > &result, const std::string &input)
parse class std::array from the string
Definition: StdArrayAsProperty.h:81
std::vector
STL class.
std::array::begin
T begin(T...args)
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 82 of file BoostArrayAsProperty.h.

83 {
84 typedef std::vector<TYPE> _Vct ;
85 // create the temporaty vector
86 _Vct tmp ;
87 // parse the string
88 StatusCode sc = parse ( tmp , input ) ;
89 if ( sc.isFailure () ) { return sc ; } // RETURN
90 if ( N != tmp.size() )
91 { return StatusCode ( StatusCode::FAILURE , true ) ; } // RETURN
92 // copy vector into array
93 std::copy ( tmp.begin() , tmp.end() , result.begin() ) ;
94 //
95 return StatusCode::SUCCESS ;
96 }
std::copy
T copy(T...args)
Gaudi::Parsers::parse
StatusCode parse(boost::array< TYPE, N > &result, const std::string &input)
parse class boost::array from the string
Definition: BoostArrayAsProperty.h:82
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
IOTest.N
int N
Definition: IOTest.py:90
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::vector
STL class.

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

Definition at line 22 of file DataObjectHandleProperty.cpp.

22 {
23
24 // std::cerr << "parse(DataObjectHandleBase) : " << s << std::endl;
25
26 StatusCode sc(StatusCode::FAILURE);
27 std::string prop;
28 sc = Gaudi::Parsers::parse(prop, s);
29
30 if (sc.isSuccess()) {
31
32 typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
33 boost::char_separator<char> sep("|");
34 tokenizer tokens(prop, sep);
35 int nToks(distance(tokens.begin(), tokens.end()));
36 auto it = tokens.begin();
37
38 if (nToks < 3 || nToks > 4) {
39 std::cerr << "Unable to instantiante DataObjectHandle from Property: " << s
40 << " :: Format is bad" << std::endl;
41 return StatusCode::FAILURE;
42 }
43
44 std::string k = *it;
45 boost::erase_all(k,"'");
46 boost::erase_all(k,"(");
47 boost::erase_all(k,")");
48
49 ++it;
50
51 int m = std::stoi(*it);
52 ++it;
53
54 if (v.mode() != m) {
55 std::cerr << "ERROR: mismatch in access mode for DataObjectHandle "
56 << v.fullKey() << " " << v.mode() << " " << m << std::endl;
57 return StatusCode::FAILURE;
58 }
59
60
61 bool o = bool(std::stoi(*it));
62
63 v.setOptional(o);
64 v.setKey( DataObjID(k) );
65
66 // std::cout << "--> key: " << k << " mode: " << m << " opt: " << o << std::endl;
67
68 if (nToks == 4) {
69 // now parse the alt addresses
70 ++it;
71 std::string alt = *it;
72 std::vector<std::string> av = v.alternativeDataProductNames();
73 boost::char_separator<char> sep2("&");
74 tokenizer tok2(alt,sep2);
75
76 for (auto it2 : tok2 ) {
77 std::string aa = it2;
78 av.push_back(aa);
79 // std::cout << " altA: " << aa << std::endl;
80 }
81
82 v.setAlternativeDataProductNames(av);
83
84 }
85 }
86
87 return StatusCode::SUCCESS;
88
89 }
Gaudi::DataHandle::setKey
virtual void setKey(const DataObjID &key)
Definition: DataHandle.h:49
std::distance
T distance(T...args)
DataObjID
Definition: DataObjID.h:38
Gaudi::DataHandle::mode
virtual Mode mode() const
Definition: DataHandle.h:47
std::endl
T endl(T...args)
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
DataObjectHandleBase::setOptional
void setOptional(bool optional=true)
Definition: DataObjectHandleBase.h:46
merge_files.sc
int sc
Definition: merge_files.py:167
std::string
STL class.
Gaudi::DataHandle::fullKey
virtual const DataObjID & fullKey() const
Definition: DataHandle.h:53
std::vector::push_back
T push_back(T...args)
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Gaudi::Units::m
constexpr double m
Definition: SystemOfUnits.h:93
std::vector< std::string >
std::cerr
std::stoi
T stoi(T...args)
DataObjectHandleBase::alternativeDataProductNames
const std::vector< std::string > & alternativeDataProductNames() const
Definition: DataObjectHandleBase.h:48
DataObjectHandleBase::setAlternativeDataProductNames
void setAlternativeDataProductNames(const std::vector< std::string > &alternativeAddresses)
Definition: DataObjectHandleBase.h:50

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

448 {
449 if ( result ) { return parse ( *result , input ) ; } // RETURN
450
451 // 1) check the parsing
452 std::string name ;
453 auto h1 = _parse_1D<TH1D> ( input , name ) ;
454 if ( h1 )
455 {
456 result = h1.release() ;
457 result->SetName ( name.c_str() ) ;
458 return StatusCode::SUCCESS ; // RETURN
459 }
460 //
461 // XML-like text?
462 return ( std::string::npos != input.find('<') )
463 ? Gaudi::Utils::Histos::fromXml ( result , input )
464 : StatusCode::FAILURE ;
465 }
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:229
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
read_lhcb_event_file.h1
tuple h1
Definition: read_lhcb_event_file.py:17
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
std::string
STL class.
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::string::c_str
T c_str(T...args)

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

475 {
476 if ( result ) { return parse ( *result , input ) ; } // RETURN
477
478 // 1) check the parsing
479 std::string name ;
480 auto h2 = _parse_2D<TH2D> ( input , name ) ;
481 if ( h2 )
482 {
483 result = h2.release() ;
484 result->SetName ( name.c_str() ) ;
485 return StatusCode::SUCCESS ; // RETURN
486 }
487 //
488 // XML-like text?
489 return ( std::string::npos != input.find('<') )
490 ? Gaudi::Utils::Histos::fromXml ( result , input )
491 : StatusCode::FAILURE ;
492 }
Gaudi::Utils::Histos::fromXml
GAUDI_API StatusCode fromXml(TH1D &result, const std::string &input)
parse the histogram from standard ROOT XML
Definition: HistoXML.cpp:229
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
std::string
STL class.
Test.h2
tuple h2
Definition: Test.py:42
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
std::string::c_str
T c_str(T...args)

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

65 {
66
67 Gaudi::XYZPoint point ;
68 StatusCode sc = parse ( point , input ) ;
69 if ( sc.isFailure() ){ return sc ; } // RETURN
70 result = point ;
71 return StatusCode::SUCCESS ; // RETURN
72 }
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
ROOT::Math::PositionVector3D
Definition: IMagneticFieldSvc.h:16
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26

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

Definition at line 19 of file DataObjIDProperty.cpp.

19 {
20 // default values
21 StatusCode sc(StatusCode::FAILURE);
22 std::string prop;
23 sc = Gaudi::Parsers::parse(prop, s);
24
25 if (sc.isSuccess()) {
26 //split the string in 1 or 2 words:
27 typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
28 boost::char_separator<char> sep("(), ");
29 tokenizer tokens(prop, sep);
30 int nToks(distance(tokens.begin(), tokens.end()));
31 auto it = tokens.begin();
32
33 if (nToks == 1) {
34 // Gaudi style /path/to/object
35 std::string k = *it;
36 boost::erase_all(k,"'");
37 v = DataObjID( k );
38
39 } else if (nToks == 2) {
40 // ATLAS style (clid, 'key') or ('ClassName', 'key')
41 CLID c(0);
42 std::string cn(*it);
43 DataObjID id;
44
45 try {
46 c = std::stoi(*it);
47 } catch (const std::invalid_argument& /*e*/) {
48 // not a number
49 boost::erase_all(cn,"'");
50 c = 0;
51 }
52
53 ++it;
54 std::string k = *it;
55 boost::erase_all(k,"'");
56 ++it;
57
58 if ( c != 0) {
59 v = DataObjID(c,k);
60 } else {
61 v = DataObjID(cn,k);
62 }
63 } else {
64 std::cerr << "Unable to instantiate a DataObjID from a Property " << s
65 << " :: Format is bad" << std::endl;
66 sc = StatusCode::FAILURE;
67 return sc;
68 }
69
70 }
71 return sc;
72 }
std::distance
T distance(T...args)
DataObjID
Definition: DataObjID.h:38
gaudirun.c
tuple c
Definition: gaudirun.py:391
std::endl
T endl(T...args)
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
merge_files.sc
int sc
Definition: merge_files.py:167
std::string
STL class.
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
std::cerr
std::stoi
T stoi(T...args)
std::invalid_argument
STL class.

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

Definition at line 77 of file DataObjIDProperty.cpp.

77 {
78 // default values
79 StatusCode sc(StatusCode::FAILURE);
80 std::string prop;
81 sc = Gaudi::Parsers::parse(prop, s);
82
83 if (sc.isSuccess()) {
84
85 // Reset Collection
86 v.clear();
87
88 bool isGaudi(true);
89
90 // Gaudi style [ '/path/to/data', '/other/data' ] or
91 // ATLAS style [ ('ClassName', 'key') , (ClassID, 'key2') ]
92 if (s.find("(") != std::string::npos) {
93 isGaudi = false;
94 }
95
96 // split the string in 1 or 2 words:
97 typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
98 boost::char_separator<char> sep("[](), ");
99 tokenizer tokens(prop, sep);
100 auto it = tokens.begin();
101
102 CLID c(0);
103 std::string cn;
104
105 while (it != tokens.end()) {
106
107 if (isGaudi) {
108 v.emplace( DataObjID( *it ) );
109 ++it;
110
111 } else {
112
113 try {
114 c = std::stoi(*it);
115 } catch (const std::invalid_argument& /*e*/) {
116 // class name, not ClassID
117 cn = *it;
118 boost::erase_all(cn,"'");
119 c = 0;
120 }
121
122 ++it;
123 std::string k = *it;
124 boost::erase_all(k,"'");
125 ++it;
126
127 if ( c != 0) {
128 v.emplace( DataObjID(c,k) );
129 } else {
130 v.emplace( DataObjID(cn,k) );
131 }
132 }
133 }
134 }
135 return sc;
136 }
DataObjID
Definition: DataObjID.h:38
gaudirun.c
tuple c
Definition: gaudirun.py:391
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
merge_files.sc
int sc
Definition: merge_files.py:167
std::string
STL class.
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
std::unordered_set::clear
T clear(T...args)
std::string::find
T find(T...args)
std::unordered_set::emplace
T emplace(T...args)
std::stoi
T stoi(T...args)
std::invalid_argument
STL class.

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

74 {
75 return parse_(result, input);
76 }
Gaudi::Parsers::parse_
StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)
Definition: ParsersVct.cpp:37

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

89 {
90 result.clear() ;
91 return parse_(result, input);
92 }
std::vector::clear
T clear(T...args)
Gaudi::Parsers::parse_
StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)
Definition: ParsersVct.cpp:37

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

104 {
105 result.clear() ;
106 return parse_(result, input);
107 }
std::vector::clear
T clear(T...args)
Gaudi::Parsers::parse_
StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)
Definition: ParsersVct.cpp:37

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

121 {
122 return parse_(result, input);
123 }
Gaudi::Parsers::parse_
StatusCode parse_(ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)
Definition: ParsersVct.cpp:37

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.

11 {
12 return Gaudi::Parsers::parse_(result, input);
13 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

15 {
16 return Gaudi::Parsers::parse_(result, input);
17 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

19 {
20 return Gaudi::Parsers::parse_(result, input);
21 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

3 {
4 return Gaudi::Parsers::parse_(result, input);
5 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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 80 of file StringKey.cpp.

82 {
83 std::string _result ;
84 StatusCode sc = parse ( _result , input ) ;
85 result = Gaudi::StringKey ( _result ) ;
86 return sc ;
87 }
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
merge_files.sc
int sc
Definition: merge_files.py:167
Gaudi::StringKey
The helper class to represent the efficient "key" for access.
Definition: StringKey.h:35
std::string
STL class.
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26

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 100 of file StringKey.cpp.

102 {
103 result.clear() ;
104 typedef std::vector<std::string> Strings ;
105 Strings _result ;
106 StatusCode sc = parse ( _result , input ) ;
107 if ( sc.isFailure() ) { return sc ; } // RETURN
108 result.reserve ( _result.size() ) ;
109 //
110 std::copy ( _result.begin() ,
111 _result.end () , std::back_inserter ( result ) ) ;
112 //
113 return StatusCode::SUCCESS ;
114 }
std::copy
T copy(T...args)
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:11
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::vector::clear
T clear(T...args)
std::vector< std::string >
std::back_inserter
T back_inserter(T...args)
std::vector::reserve
T reserve(T...args)

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.

7 {
8 return Gaudi::Parsers::parse_(result, input);
9 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

11 {
12 return Gaudi::Parsers::parse_(result, input);
13 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

15 {
16 return Gaudi::Parsers::parse_(result, input);
17 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

3 {
4 return Gaudi::Parsers::parse_(result, input);
5 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

11 {
12 return Gaudi::Parsers::parse_(result, input);
13 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

15 {
16 return Gaudi::Parsers::parse_(result, input);
17 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

3 {
4 return Gaudi::Parsers::parse_(result, input);
5 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

7 {
8 return Gaudi::Parsers::parse_(result, input);
9 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

11 {
12 return Gaudi::Parsers::parse_(result, input);
13 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

3 {
4 return Gaudi::Parsers::parse_(result, input);
5 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

7 {
8 return Gaudi::Parsers::parse_(result, input);
9 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31
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 454 of file Parsers.h.

455 {
456 return parse((M&)result, input);
457 }
Gaudi::Parsers::parse
StatusCode parse(char(&result)[N], const std::string &input)
parser function for C-strings
Definition: Parsers.h:559

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.

8 {
9 Skipper skipper;
10 KeyValueGrammar<IteratorT, Skipper> g;
11 KeyValueGrammar<IteratorT, Skipper>::ResultT result;
12 auto iter = input.begin();
13 bool parse_result = qi::phrase_parse(iter, input.end(), g, skipper,
14 result) && (iter==input.end());
15 if (parse_result) {
16 name = result.first;
17 value = result.second;
18 }
19 return parse_result;
20 }
Gaudi::Parsers::Skipper
SkipperGrammar< IteratorT > Skipper
Definition: ParsersFactory.h:28
std::string::end
T end(T...args)
std::string::begin
T begin(T...args)
gaudirun.g
dictionary g
Definition: gaudirun.py:420

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.

9 {
10 return Gaudi::Parsers::parse_(result, input);
11 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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 13 of file ParsersHistograms.cpp.

15 {
16 return Gaudi::Parsers::parse_(result, input);
17 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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.

22 {
23 return Gaudi::Parsers::parse_(result, input);
24 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31
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 537 of file Parsers.h.

538 {
539 typedef std::vector<T> _Vct ;
540 // create the temporary vector
541 _Vct tmp ;
542 StatusCode sc = parse ( tmp , input ) ;
543 if ( sc.isFailure() ) { return sc ; } // RETURN
544 if ( N != tmp.size() ) { return StatusCode::FAILURE ; } // RETURN
545 //
546 std::copy ( tmp.begin() , tmp.end() , result ) ;
547 //
548 return StatusCode::SUCCESS ; // RETURN
549 }
Gaudi::Parsers::parse
StatusCode parse(char(&result)[N], const std::string &input)
parser function for C-strings
Definition: Parsers.h:559
std::copy
T copy(T...args)
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
IOTest.N
int N
Definition: IOTest.py:90
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::vector
STL class.
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 559 of file Parsers.h.

560 {
561 // clear the string
562 std::fill_n ( result , N , ' ' ) ;
563 // create the temporary string
564 std::string tmp ;
565 StatusCode sc = parse ( tmp , input ) ;
566 if ( sc.isFailure() ) { return sc ; } // RETURN
567 if ( N == tmp.size() )
568 { std::copy ( tmp.begin() , tmp.end() , result ) ; }
569 else if ( N + 2 == tmp.size() &&
570 ( '\'' == tmp[0] || '\"' == tmp[0] ) &&
571 ( tmp[0] == tmp[tmp.size()-1] ))
572 { std::copy ( tmp.begin() + 1 , tmp.end() -1 , result ) ; }
573 else { return StatusCode::FAILURE ; }
574 //
575 return StatusCode::SUCCESS ; // RETURN
576 }
Gaudi::Parsers::parse
StatusCode parse(char(&result)[N], const std::string &input)
parser function for C-strings
Definition: Parsers.h:559
std::copy
T copy(T...args)
std::string::end
T end(T...args)
merge_files.sc
int sc
Definition: merge_files.py:167
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
std::string
STL class.
IOTest.N
int N
Definition: IOTest.py:90
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::SUCCESS
Definition: StatusCode.h:30
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
std::string::size
T size(T...args)
std::string::begin
T begin(T...args)
std::fill_n
T fill_n(T...args)

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 10 of file ParsersCollections.cpp.

11 {
12 return Gaudi::Parsers::parse_(result, input);
13 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31

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 16 of file ParsersCollections.cpp.

17 {
18 return Gaudi::Parsers::parse_(result, input);
19 }
Gaudi::Parsers::parse_
StatusCode parse_(ResultT &result, const std::string &input)
Definition: ParsersFactory.h:31
template<typename ResultT >

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

Definition at line 31 of file ParsersFactory.h.

31 {
32 Skipper skipper;
33 typename Grammar_<IteratorT, ResultT, Skipper>::Grammar g;
34 IteratorT iter = input.begin(), end = input.end();
35 return qi::phrase_parse( iter, end, g, skipper , result) && (iter==end);
36 }
Gaudi::Parsers::Skipper
SkipperGrammar< IteratorT > Skipper
Definition: ParsersFactory.h:28
std::string::end
T end(T...args)
Gaudi::Parsers::IteratorT
std::string::const_iterator IteratorT
Definition: ParsersFactory.h:26
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47
std::string::begin
T begin(T...args)
gaudirun.g
dictionary g
Definition: gaudirun.py:420
template<typename T1 , typename T2 >

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

Definition at line 37 of file ParsersVct.cpp.

37 {
38 Skipper skipper;
39 typename Grammar_<IteratorT, ROOT::Math::PositionVector3D<T1,T2>, Skipper >::Grammar g;
40 IteratorT iter = input.begin(), end = input.end();
41 if (qi::phrase_parse( iter, end, g, skipper, result)){
42 return StatusCode::SUCCESS;
43 }
44 //@attention always
45 return true;
46 }
Gaudi::Parsers::Skipper
SkipperGrammar< IteratorT > Skipper
Definition: ParsersFactory.h:28
std::string::end
T end(T...args)
Gaudi::Parsers::IteratorT
std::string::const_iterator IteratorT
Definition: ParsersFactory.h:26
StatusCode::SUCCESS
Definition: StatusCode.h:30
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47
std::string::begin
T begin(T...args)
gaudirun.g
dictionary g
Definition: gaudirun.py:420
template<>

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

Definition at line 39 of file ParsersFactory.h.

39 {
40 Skipper skipper;
41 Grammar_<IteratorT, std::string, Skipper>::Grammar g;
42 IteratorT iter = input.begin(), end = input.end();
43 if (!(qi::phrase_parse( iter, end, g, skipper, result) && (iter==end))){
44 result = input;
45 }
46 //@attention always
47 return true;
48 }
Gaudi::Parsers::Skipper
SkipperGrammar< IteratorT > Skipper
Definition: ParsersFactory.h:28
std::string::end
T end(T...args)
Gaudi::Parsers::IteratorT
std::string::const_iterator IteratorT
Definition: ParsersFactory.h:26
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47
std::string::begin
T begin(T...args)
gaudirun.g
dictionary g
Definition: gaudirun.py:420

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

145 {
146 using Grammar = UnitsGrammar<Iterator,SkipperGrammar<Iterator>>;
147 return ParseFile<Grammar>(from, filename, search_path, included,
148 messages, root);
149 }
graphanalysis.filename
string filename
Definition: graphanalysis.py:109
IOTest.root
tuple root
Definition: IOTest.py:42

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 416 of file Analyzer.cpp.

418 {
419 // Extract Path
420 IncludedFiles included;
421 bool result = Parse(filename, search_path, &included, messages, root);
422 if (!result) return false;
423
424 bool result1 = Analyze(root, search_path, &included, messages, catalog, units,
425 pragma);
426 bool result2 = Unreference(*catalog, messages);
427 return result1 && result2;
428 }
Gaudi::Parsers::Parse
bool Parse(const std::string &filename, const std::string &search_path, IncludedFiles *included, Messages *messages, Node *root)
Definition: Parser.cpp:125
IOTest.root
tuple root
Definition: IOTest.py:42
Unreference
bool Unreference(gp::Catalog &catalog, gp::Messages *messages)
Definition: Analyzer.cpp:394

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 |
| ) |  |