Gaudi Framework, version v20r4

Generated: 8 Jan 2009

Gaudi::Parsers Namespace Reference


Classes

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  BoolGrammar
 The valid represenation of boolean values are:. More...
class  CharGrammar
 The valid represenation of char values are:. More...
class  IntGrammar
 The valid representation of integers values are:. More...
class  RealGrammar
 The valid represenation of real values are:. More...
class  StringGrammar
 The valid represenation of string values are:. More...
class  SkipperGrammar
 Skipping spaces and comments. 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:
  • {"abc","defj","i"} or {1,2,3,4,5}
  • ["abc","defj","i"] or [1,2,3,4,5] Inner type depends on GrammarT grammar.
More...
class  MapGrammar
 The valid represenation of map are:
  • {"file1":"path1","something":"nothing"}
  • {"file1"="path1","something"="nothing"}
  • ["file1":10,"something":20]
  • ["file1"=30,"something"=40] Inner key type depends on KeyGrammarT grammar Inner value type depends on ValueGrammarT grammar.
More...
class  Histo1DGrammar
 The simple grammar for histogram description/definition:. More...
struct  _NoCaseCmp_
 case-insensitive comparison criteria for strings More...
class  Catalogue
 Catalogue of PropertyEntry. More...
class  PropertyEntry
class  PushBackImpl
class  PushBackRefImpl
class  AssignBoolToStringImpl
class  IdentifierGrammar
 Recognize alphanumeric strings and _ starting with alpha: Example, abc, ab_cd123, a_12. More...
class  PropertyGrammar
 Recognize property Example, A.B, A::B::C.D, A::B.C::D.E. More...
class  RealUnitsGrammar
 The valid represenation of reals with units are
  • 1, 1.0, 1.0e+2, 1e-2, 0.5mm, 0.5 mm, 0.5*mm.
More...
class  UnitsFileGrammar
 The valid represenation units file: 1 cm = 10 1 m = 1000 . More...
class  ValueGrammar
 Grammar recognize value that can appear in right side of '=' operator in job options file. More...
class  ParserGrammar
 Grammar recognize job options file Grammar's EBNF: job_options_file ::= (platform_statement | platform_dependency)*. More...
class  Message
 Parser message interface. More...
class  Parser
 Parser controller. More...
class  Position
 Parser position entity. More...

Namespaces

namespace  Utils

Typedefs

typedef
boost::spirit::position_iterator
< string::const_iterator > 		IteratorT
 the actual type of position iterator
typedef
AttributesClosureGrammar
< boost::tuple< std::string,
std::vector< std::string >
>, boost::tuple< int > > 		ValueClosureT
typedef
AttributesClosureGrammar
< IteratorT, boost::tuple
< bool, std::string,
std::vector< std::string > > > 		ParserClosureT

Functions

StatusCode parse (bool &result, const std::string &input)
 parse the bool value
StatusCode parse (char &result, const std::string &input)
 parse the char value
StatusCode parse (unsigned char &result, const std::string &input)
StatusCode parse (signed char &result, const std::string &input)
StatusCode parse (int &result, const std::string &input)
 parse the int value
StatusCode parse (short &result, const std::string &input)
StatusCode parse (unsigned short &result, const std::string &input)
StatusCode parse (unsigned int &result, const std::string &input)
StatusCode parse (long &result, const std::string &input)
StatusCode parse (unsigned long &result, const std::string &input)
StatusCode parse (long long &result, const std::string &input)
StatusCode parse (unsigned long long &result, const std::string &input)
StatusCode parse (double &result, const std::string &input)
 parse the double value
StatusCode parse (float &result, const std::string &input)
StatusCode parse (long double &result, const std::string &input)
StatusCode parse (std::string &result, const std::string &input)
 parse the std::string value
StatusCode parse (std::vector< bool > &result, const std::string &input)
 parse the std::vector<bool> value
StatusCode parse (std::vector< char > &result, const std::string &input)
 parse the std::vector<char> value
StatusCode parse (std::vector< unsigned char > &result, const std::string &input)
StatusCode parse (std::vector< signed char > &result, const std::string &input)
StatusCode parse (std::vector< int > &result, const std::string &input)
 parse the std::vector<int> value
StatusCode parse (std::vector< short > &result, const std::string &input)
StatusCode parse (std::vector< unsigned short > &result, const std::string &input)
StatusCode parse (std::vector< unsigned int > &result, const std::string &input)
StatusCode parse (std::vector< long > &result, const std::string &input)
StatusCode parse (std::vector< unsigned long > &result, const std::string &input)
StatusCode parse (std::vector< long long > &result, const std::string &input)
StatusCode parse (std::vector< unsigned long long > &result, const std::string &input)
StatusCode parse (std::vector< double > &result, const std::string &input)
 parse the std::vector<double> value
StatusCode parse (std::vector< float > &result, const std::string &input)
StatusCode parse (std::vector< long double > &result, const std::string &input)
StatusCode parse (std::vector< std::string > &result, const std::string &input)
 parse the std::vector<std::string> value
StatusCode parse (std::pair< double, double > &result, const std::string &input)
 parse the std::pair<double,double> value
StatusCode parse (std::pair< int, int > &result, const std::string &input)
 parse the std::pair<int,int> value
StatusCode parse (std::vector< std::pair< double, double > > &result, const std::string &input)
 parse the std::vector<std::pair<double,double> > value
StatusCode parse (std::vector< std::pair< int, int > > &result, const std::string &input)
 parse the std::vector<std::pair<int,int> > value
StatusCode parse (std::vector< std::vector< std::string > > &result, const std::string &input)
 parse the std::vector<std::vector<std::string> > value
StatusCode parse (std::vector< std::vector< double > > &result, const std::string &input)
 parse the std::vector<std::vector<double> > value
StatusCode parse (std::map< int, int > &result, const std::string &input)
 parse the std::map<int , int> value
StatusCode parse (std::map< int, double > &result, const std::string &input)
 parse the std::map<int , double> value
StatusCode parse (std::map< std::string, std::string > &result, const std::string &input)
 parse the std::map<std::string , std::string> value
StatusCode parse (std::map< std::string, int > &result, const std::string &input)
 parse the std::map<std::string , int> value
StatusCode parse (std::map< std::string, double > &result, const std::string &input)
 parse the std::map<std::string , double> value
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
StatusCode parse (std::map< std::string, std::vector< int > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<int> > value
StatusCode parse (std::map< std::string, std::vector< double > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<double> > value
StatusCode parse (std::map< int, std::string > &result, const std::string &input)
 parse the std::map<int,std::string> > objects
StatusCode parse (std::map< unsigned int, std::string > &result, const std::string &input)
 parse the std::map<unsigned int,std::string> > objects
StatusCode parse (std::string &name, std::string &value, const std::string &input)
 parse the pair expression (map-component) " 'name' :value"
StatusCode parse (Gaudi::Histo1DDef &histo, const std::string &input)
 helper function, needed for implementation of "Histogram Property"
StatusCode parse (std::map< std::string, Gaudi::Histo1DDef > &histos, const std::string &input)
 helper function, needed for implementation of "Histogram Property"
StatusCode parse (pair< double, double > &result, const string &input)
StatusCode parse (pair< int, int > &result, const string &input)
IteratorT createIterator (const std::string &input)
 create the position iterator from the inptut
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 iteger-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<class T>
phoenix::actor< PushBackImpl< T > > PushBack (T &x)
template<class T, typename IT>
phoenix::actor
< PushBackRefImpl< T, IT > > 		PushBack (T &x, IT it)
template<class T>
phoenix::actor
< AssignBoolToStringImpl< T > > 		AssignBoolToString (T &x)
StatusCode parse (Parser parser, const std::string &fileName, std::vector< Message > &msgs)
 Parse job options fiel using the configured parser object.
StatusCode parse (const std::string &filename, const std::vector< std::string > &searchPath, Catalogue &catalogue, std::vector< std::string > &included, std::vector< Message > &messages)
 Parse job options file.
StatusCode parse (const std::string &filename, const std::string &searchPath, Catalogue &catalogue, std::vector< std::string > &included, std::vector< Message > &messages)
 Parse job options file.
StatusCode parse (const std::string &filename, Catalogue &catalogue, std::vector< std::string > &included, std::vector< Message > &messages)
 Parse job options file.

Typedef Documentation

typedef boost::spirit::position_iterator< std::string::const_iterator > Gaudi::Parsers::IteratorT

the actual type of position iterator

Definition at line 57 of file Parsers.icpp.

typedef AttributesClosureGrammar<IteratorT,boost::tuple<bool,std::string,std::vector<std::string> > > Gaudi::Parsers::ParserClosureT

Definition at line 432 of file ParserGrammar.h.

typedef AttributesClosureGrammar<boost::tuple<std::string,std::vector<std::string> > , boost::tuple<int> > Gaudi::Parsers::ValueClosureT

Definition at line 278 of file ParserGrammar.h.

Function Documentation

template<class T>
phoenix::actor<AssignBoolToStringImpl<T> > Gaudi::Parsers::AssignBoolToString ( T &  x  )  [inline]

Definition at line 86 of file ParserActions.h.

00086                                                                                                         {
00087       return AssignBoolToStringImpl<T> (x);
00088     }

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

create the position iterator from the inptut

Definition at line 60 of file Parsers.icpp.

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

StatusCode Gaudi::Parsers::parse ( const std::string &  filename,
Catalogue &  catalogue,
std::vector< std::string > &  included,
std::vector< Message > &  messages 
)

Parse job options file.

Returns:
StatusCode::SUCCESS if no errors
Parameters:
filename Path to options file
Catalogue of parser properties
included Already included files
List of parser messages
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2006-02-17

Definition at line 75 of file ParserUtils.cpp.

00078                                     {
00079   return parse
00080     (Gaudi::Parsers::Parser(catalogue,included),filename,msgs);
00081 }

StatusCode Gaudi::Parsers::parse ( const std::string &  filename,
const std::string &  searchPath,
Catalogue &  catalogue,
std::vector< std::string > &  included,
std::vector< Message > &  messages 
)

Parse job options file.

Returns:
StatusCode::SUCCESS if no errors
Parameters:
filename Path to options file
searchPath Directories for search include and units files
Catalogue of parser properties
included Already included files
List of parser messages
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2006-02-17

Definition at line 63 of file ParserUtils.cpp.

00068 {
00069   return parse
00070     ( Gaudi::Parsers::Parser (catalogue , included, searchPath ) , 
00071       filename ,  msgs ) ;  
00072 }

StatusCode Gaudi::Parsers::parse ( const std::string &  filename,
const std::vector< std::string > &  searchPath,
Catalogue &  catalogue,
std::vector< std::string > &  included,
std::vector< Message > &  messages 
)

Parse job options file.

Returns:
StatusCode::SUCCESS if no errors
Parameters:
filename Path to options file
searchPath Directories for search include and units files
Catalogue of parser properties
included Already included files
List of parser messages
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2006-02-17

Definition at line 51 of file ParserUtils.cpp.

00056 {
00057   return parse
00058     ( Gaudi::Parsers::Parser(catalogue, included, searchPath) , 
00059       filename , msgs ) ;  
00060 }

StatusCode Gaudi::Parsers::parse ( Parser  parser,
const std::string &  fileName,
std::vector< Message > &  msgs 
)

Parse job options fiel using the configured parser object.

Author:
Vanya BELYAEV ibelyaev@phsycis.syr.edu
Date:
2006-06-28

Definition at line 41 of file ParserUtils.cpp.

00044 {
00045   StatusCode res = parser.parse(fileName);
00046   msgs = parser.messages();
00047   return res;  
00048 }

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

Definition at line 45 of file ParsePairs.cpp.

00046     {
00047       return parse
00048         ( createIterator(input), 
00049           IteratorT(),
00050           PairGrammar < IntGrammar<int> , IntGrammar <int> >()[var(result)=arg1],
00051           SkipperGrammar()).full;
00052     }

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

Definition at line 35 of file ParsePairs.cpp.

00036     {
00037       return parse
00038         ( createIterator(input), 
00039           IteratorT(),
00040           PairGrammar < RealGrammar<double> , RealGrammar <double> >()
00041           [var(result)=arg1],
00042           SkipperGrammar()).full;
00043     }

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 ibelyaev@physics.syr.edu

Alexander MAZUROV Alexander.Mazurov@gmail.com

Date:
2007-09-17

Definition at line 127 of file ParseHistos.cpp.

00129 {
00130   MapGrammar<StringGrammar,Histo1DGrammar> g;
00131   const bool full = boost::spirit::parse
00132     ( createIterator(input), 
00133       IteratorT()     ,
00134       g[var(histos)=arg1],
00135       SkipperGrammar() ).full;
00136   //
00137   if ( !full ) { return StatusCode::FAILURE ; }                 // RETURN 
00138   //
00139   for ( std::map<std::string,Gaudi::Histo1DDef>::const_iterator 
00140           ih = histos.begin() ; histos.end() != ih ; ++ih ) 
00141   { if ( !ih->second.ok() ) { return StatusCode::FAILURE ; } }  // RETURN 
00142   //
00143   return StatusCode::SUCCESS ;                                  // RETURN 
00144 }

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 ibelyaev@physics.syr.edu

Alexander MAZUROV Alexander.Mazurov@gmail.com

Date:
2007-09-17

Definition at line 103 of file ParseHistos.cpp.

00105 {
00106   Histo1DGrammar g;
00107   const bool full =
00108     boost::spirit::parse
00109     ( createIterator(input), 
00110       IteratorT(), 
00111       g[var(histo)=arg1],
00112       SkipperGrammar()).full;
00113   //
00114   return full && histo.ok() ? StatusCode::SUCCESS : StatusCode::FAILURE ;
00115 }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 156 of file ParseMaps.cpp.

00157     {
00158       return parse 
00159         ( input.c_str(),
00160           (
00161            ch_p('"' ) >> (+(anychar_p-ch_p('"' )))[assign_a(name)] >> ch_p('"' )
00162            |
00163            ch_p('\'') >> (+(anychar_p-ch_p('\'')))[assign_a(name)] >> ch_p('\'')
00164            )
00165           >> ":"
00166           >> (+anychar_p)[assign_a(value)], space_p).full;
00167     }

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 ibelyaev@physics.syr.edu

Alexander MAZUROV Alexander.Mazurov@gmail.com

Date:
2007-12-06

Definition at line 182 of file ParseMaps.cpp.

00184     {
00185       MapGrammar<IntGrammar<unsigned int>,StringGrammar> g;
00186       return parse
00187         ( createIterator(input), 
00188           IteratorT(),
00189           g[var(result)=arg1],
00190           SkipperGrammar()).full;
00191     }

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 ibelyaev@physics.syr.edu

Alexander MAZUROV Alexander.Mazurov@gmail.com

Date:
2007-12-06

Definition at line 170 of file ParseMaps.cpp.

00172     {
00173       MapGrammar<IntGrammar<int>,StringGrammar> g;
00174       return parse
00175         ( createIterator(input), 
00176           IteratorT(),
00177           g[var(result)=arg1],
00178           SkipperGrammar()).full;
00179     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 118 of file ParseMaps.cpp.

00120     {
00121       MapGrammar<StringGrammar,VectorGrammar<RealGrammar<double> > > g;
00122       return parse
00123         ( createIterator(input), 
00124           IteratorT(),
00125           g[var(result)=arg1],
00126           SkipperGrammar()).full;
00127     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 106 of file ParseMaps.cpp.

00108     {
00109       MapGrammar<StringGrammar,VectorGrammar<IntGrammar<int> > > g;
00110       return parse
00111         ( createIterator(input), 
00112           IteratorT(),
00113           g[var(result)=arg1],
00114           SkipperGrammar()).full;
00115     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 94 of file ParseMaps.cpp.

00096     {
00097       MapGrammar<StringGrammar,VectorGrammar<StringGrammar> > g;
00098       return parse
00099         ( createIterator(input), 
00100           IteratorT(),
00101           g[var(result)=arg1],
00102           SkipperGrammar()).full;
00103     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 58 of file ParseMaps.cpp.

00060     {
00061       MapGrammar<StringGrammar,RealGrammar<double> > g;
00062       return parse
00063         ( createIterator(input), 
00064           IteratorT(),
00065           g[var(result)=arg1],
00066           SkipperGrammar()).full;
00067     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 82 of file ParseMaps.cpp.

00084     {
00085       MapGrammar<StringGrammar,IntGrammar<int> > g;
00086       return parse
00087         ( createIterator(input), 
00088           IteratorT(),
00089           g[var(result)=arg1],
00090           SkipperGrammar()).full;
00091     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 70 of file ParseMaps.cpp.

00072     {
00073       MapGrammar<StringGrammar,StringGrammar> g;
00074       return parse
00075         ( createIterator(input), 
00076           IteratorT(),
00077           g[var(result)=arg1],
00078           SkipperGrammar()).full;
00079     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 46 of file ParseMaps.cpp.

00048     {
00049       MapGrammar< IntGrammar<int> , RealGrammar<double> > g;
00050       return parse
00051         ( createIterator(input), 
00052           IteratorT(),
00053           g[var(result)=arg1],
00054           SkipperGrammar()).full;
00055     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 34 of file ParseMaps.cpp.

00036     {
00037       MapGrammar< IntGrammar<int> , IntGrammar<int> > g;
00038       return parse
00039         ( createIterator(input)  , 
00040           IteratorT()            ,
00041           g[var(result)=arg1],
00042           SkipperGrammar()).full;
00043     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 48 of file ParseVectorsVector.cpp.

00050     {
00051       VectorGrammar< VectorGrammar< RealGrammar< double > > > g;
00052       return parse
00053         ( createIterator(input), 
00054           IteratorT(),
00055           g[var(result)=arg1],
00056           SkipperGrammar()).full;
00057     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 36 of file ParseVectorsVector.cpp.

00038     {
00039       VectorGrammar< VectorGrammar<StringGrammar> > g;
00040       return parse
00041         ( createIterator(input), 
00042           IteratorT(),
00043           g[var(result)=arg1],
00044           SkipperGrammar()).full ;
00045     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 72 of file ParseVectorsVector.cpp.

00074     {
00075       VectorGrammar<PairGrammar<IntGrammar<int>,IntGrammar<int> > > g;
00076       return parse
00077         ( createIterator(input), 
00078           IteratorT(),
00079           g[var(result)=arg1],
00080           SkipperGrammar()).full;
00081     }

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

parse 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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 60 of file ParseVectorsVector.cpp.

00062     {
00063       VectorGrammar<PairGrammar<RealGrammar<double>,RealGrammar<double> > > g;
00064       return parse
00065         ( createIterator(input), 
00066           IteratorT(),
00067           g[var(result)=arg1],
00068           SkipperGrammar()).full;
00069     }

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

parse 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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

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

parse 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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

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

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

See also:
Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::StringGrammar

Parameters:
result (output) vector with string elements
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 35 of file ParseVectorsString.cpp.

00037     {
00038       VectorGrammar<StringGrammar> g;
00039       return parse(
00040           createIterator(input), 
00041           IteratorT(),
00042           g[var(result)=arg1],
00043           SkipperGrammar()).full;
00044     }

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

See also:
parse( std::vector<double>& ,const std::string& );

Definition at line 43 of file ParseVectorsReal.cpp.

00045     { return parse_real_vector    ( result , input ) ; }

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

See also:
parse( std::vector<double>& ,const std::string& );

Definition at line 35 of file ParseVectorsReal.cpp.

00037     { return parse_real_vector    ( result , input ) ; }

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

parse the std::vector<double> value

See also:
Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::RealGrammar

Parameters:
result (output) vector with double elements
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 39 of file ParseVectorsReal.cpp.

00041     { return parse_real_vector    ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 63 of file ParseVectorsInteger.cpp.

00065     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 59 of file ParseVectorsInteger.cpp.

00061     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 55 of file ParseVectorsInteger.cpp.

00057     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 51 of file ParseVectorsInteger.cpp.

00053     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 47 of file ParseVectorsInteger.cpp.

00049     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 39 of file ParseVectorsInteger.cpp.

00041     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 35 of file ParseVectorsInteger.cpp.

00037     { return parse_integer_vector ( result , input ) ; }

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

parse the std::vector<int> value

See also:
Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::IntGrammar

Parameters:
result (output) vector with integer elements
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 43 of file ParseVectorsInteger.cpp.

00045     { return parse_integer_vector ( result , input ) ; }

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

See also:
parse( std::vector<char>& ,const std::string& );

Definition at line 43 of file ParseVectorsChar.cpp.

00045     { return parse_char_vector ( result , input ) ; }

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

See also:
parse( std::vector<char>& ,const std::string& );

Definition at line 39 of file ParseVectorsChar.cpp.

00041     { return parse_char_vector ( result , input ) ; }

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

parse the std::vector<char> value

See also:
Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::CharGrammar

Parameters:
result (output) vector with char elements
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 35 of file ParseVectorsChar.cpp.

00037     { return parse_char_vector ( result , input ) ; }

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

parse the std::vector<bool> value

See also:
Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::BoolGrammar

Parameters:
result (output) vector with boolean elements
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 35 of file ParseVectorsBool.cpp.

00037     {
00038       VectorGrammar<BoolGrammar> g;
00039       return parse(
00040             createIterator(input), 
00041             IteratorT(),
00042             g[var(result)=arg1],
00043             SkipperGrammar()).full;
00044     }

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

parse the std::string value

See also:
Gaudi::Parsers::StringGrammar
Parameters:
result (output) string result
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Attention:
always!!!

Definition at line 101 of file ParseAtomic.cpp.

00103     {
00104       StringGrammar g;
00105       if ( !parse(
00106               createIterator(input), 
00107               IteratorT(),
00108               g[var(result)=arg1]).full ){ result = input ; }
00110       return true ;
00111     }

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

See also:
Gaudi::Parsers::parser( double&, const std::string& )

Definition at line 97 of file ParseAtomic.cpp.

00099     { return parse_real ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( double&, const std::string& )

Definition at line 89 of file ParseAtomic.cpp.

00091     { return parse_real ( result , input ) ; }

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

parse the double value

See also:
Gaudi::Parsers::RealGrammar
Parameters:
result (output) double result
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 93 of file ParseAtomic.cpp.

00095     { return parse_real ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 75 of file ParseAtomic.cpp.

00077     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 71 of file ParseAtomic.cpp.

00073     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 67 of file ParseAtomic.cpp.

00069     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 63 of file ParseAtomic.cpp.

00065     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 59 of file ParseAtomic.cpp.

00061     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 51 of file ParseAtomic.cpp.

00053     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 47 of file ParseAtomic.cpp.

00049     { return parse_integer ( result , input ) ; }

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

parse the int value

See also:
Gaudi::Parsers::IntGrammar
Parameters:
result (output) integer result
input (input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-14

Definition at line 55 of file ParseAtomic.cpp.

00057     { return parse_integer ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser(char&,std::string&)

Definition at line 43 of file ParseAtomic.cpp.

00045     { return parse_char    ( result , input ) ; }

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

See also:
Gaudi::Parsers::parser(char&,std::string&)

Definition at line 39 of file ParseAtomic.cpp.

00041     { return parse_char    ( result , input ) ; }

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

parse 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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 35 of file ParseAtomic.cpp.

00037     { return parse_char    ( result , input ) ; }

StatusCode Gaudi::Parsers::parse ( bool &  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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 79 of file ParseAtomic.cpp.

00081     {
00082       BoolGrammar g;
00083       return parse( 
00084           createIterator(input), 
00085           IteratorT(),
00086           g[var(result)=arg1]).full;
00087     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 131 of file Parsers.icpp.

00132     {
00133       CharGrammar<CharT> g;
00134       return parse
00135         ( createIterator(input),
00136           IteratorT(),
00137           g[var(result)=arg1]).full;
00138     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 158 of file Parsers.icpp.

00159     {
00160       VectorGrammar<CharGrammar<CharT> > g;
00161       return parse
00162         ( createIterator(input),
00163           IteratorT(),
00164           g[var(result)=arg1],
00165           SkipperGrammar()).full;
00166     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 79 of file Parsers.icpp.

00080     {
00081       IntGrammar<IntegerT> g;
00082       return parse
00083         ( createIterator(input),
00084           IteratorT(),
00085           g[var(result)=arg1]).full;
00086     }

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 iteger-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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 106 of file Parsers.icpp.

00107     {
00108       VectorGrammar<IntGrammar<IntegerT> > g;
00109       return parse
00110         ( createIterator(input),
00111           IteratorT(),
00112           g[var(result)=arg1],
00113           SkipperGrammar()).full;
00114     }

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 Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 182 of file Parsers.icpp.

00183     {
00184       RealGrammar<RealT> g;
00185       return parse
00186         ( createIterator(input),
00187           IteratorT(),
00188           g[var(result)=arg1],
00189           SkipperGrammar()).full;
00190     }

template<typename RealT>
StatusCode Gaudi::Parsers::parse_real_vector ( std::vector< RealT > &  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::RealGrammar

Gaudi::Parsers::SkipperGrammar

Parameters:
result (output) parsing result
input (input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com

Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
2006-05-12

Definition at line 210 of file Parsers.icpp.

00211     {
00212       VectorGrammar< RealGrammar<RealT> > g;
00213       return parse
00214         ( createIterator(input),
00215           IteratorT(),
00216           g[var(result)=arg1],
00217           SkipperGrammar()).full;
00218     }

template<class T, typename IT>
phoenix::actor<PushBackRefImpl<T,IT> > Gaudi::Parsers::PushBack ( T &  x,
IT  it 
) [inline]

Definition at line 82 of file ParserActions.h.

00082                                                                               {
00083       return PushBackRefImpl<T,IT> (x,it);
00084     }

template<class T>
phoenix::actor<PushBackImpl<T> > Gaudi::Parsers::PushBack ( T &  x  )  [inline]

Definition at line 78 of file ParserActions.h.

00078                                                                   {
00079       return PushBackImpl<T> (x);
00080     }

Generated at Thu Jan 8 17:53:46 2009 for Gaudi Framework, version v20r4 by Doxygen version 1.5.6 written by Dimitri van Heesch, © 1997-2004