| # Gaudi Framework, version v20r3
Generated: 24 Nov 2008

# 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 (char &result, const string &input)
StatusCode | parse (unsigned char &result, const string &input)
StatusCode | parse (signed char &result, const string &input)
StatusCode | parse (short &result, const string &input)
StatusCode | parse (unsigned short &result, const string &input)
StatusCode | parse (int &result, const string &input)
StatusCode | parse (unsigned int &result, const string &input)
StatusCode | parse (long &result, const string &input)
StatusCode | parse (unsigned long &result, const string &input)
StatusCode | parse (long long &result, const string &input)
StatusCode | parse (unsigned long long &result, const string &input)
StatusCode | parse (bool &result, const string &input)
StatusCode | parse (float &result, const string &input)
StatusCode | parse (double &result, const string &input)
StatusCode | parse (long double &result, const string &input)
StatusCode | parse (string &result, const string &input)
StatusCode | parse (map< int, int > &result, const string &input)
StatusCode | parse (map< int, double > &result, const string &input)
StatusCode | parse (map< string, double > &result, const string &input)
StatusCode | parse (map< string, string > &result, const string &input)
StatusCode | parse (map< string, int > &result, const string &input)
StatusCode | parse (map< std::string, std::vector< std::string > > &result, const string &input)
StatusCode | parse (map< std::string, std::vector< int > > &result, const string &input)
StatusCode | parse (map< std::string, std::vector< double > > &result, const string &input)
StatusCode | parse (string &name, string &value, const string &input)
StatusCode | parse (map< int, std::string > &result, const string &input)
StatusCode | parse (map< unsigned int, std::string > &result, const string &input)
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
StatusCode | parse (vector< bool > &result, const string &input)
StatusCode | parse (vector< char > &result, const string &input)
StatusCode | parse (vector< unsigned char > &result, const string &input)
StatusCode | parse (vector< signed char > &result, const string &input)
StatusCode | parse (vector< short > &result, const string &input)
StatusCode | parse (vector< unsigned short > &result, const string &input)
StatusCode | parse (vector< int > &result, const string &input)
StatusCode | parse (vector< unsigned int > &result, const string &input)
StatusCode | parse (vector< long > &result, const string &input)
StatusCode | parse (vector< unsigned long > &result, const string &input)
StatusCode | parse (vector< long long > &result, const string &input)
StatusCode | parse (vector< unsigned long long > &result, const string &input)
StatusCode | parse (vector< float > &result, const string &input)
StatusCode | parse (vector< double > &result, const string &input)
StatusCode | parse (vector< long double > &result, const string &input)
StatusCode | parse (vector< string > &result, const string &input)
StatusCode | parse (std::vector< std::pair< double, double > > &result, const string &input)
StatusCode | parse (std::vector< std::pair< int, int > > &result, const string &input)
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 (Gaudi::Parsers::Parser parser, const std::string &fileName, std::vector< Gaudi::Parsers::Message > &msgs)
StatusCode | parse (const string &filename, const vector< string > &searchPath, Gaudi::Parsers::Catalogue &catalogue, std::vector< std::string > &included, vector< Gaudi::Parsers::Message > &msgs)
StatusCode | parse (const string &filename, const string &searchPath, Gaudi::Parsers::Catalogue &catalogue, std::vector< std::string > &included, vector< Gaudi::Parsers::Message > &msgs)
StatusCode | parse (const string &filename, Gaudi::Parsers::Catalogue &catalogue, std::vector< std::string > &included, vector< Gaudi::Parsers::Message > &msgs)
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

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

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

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

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

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 string & | filename,
|  | const string & | searchPath,
|  | Gaudi::Parsers::Catalogue & | catalogue,
|  | std::vector< std::string > & | included,
|  | vector< Gaudi::Parsers::Message > & | msgs |
| ) |  |  |

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 string & | filename,
|  | const vector< string > & | searchPath,
|  | Gaudi::Parsers::Catalogue & | catalogue,
|  | std::vector< std::string > & | included,
|  | vector< Gaudi::Parsers::Message > & | msgs |
| ) |  |  |

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 | ( | Gaudi::Parsers::Parser | parser,
|  | const std::string & | fileName,
|  | std::vector< Gaudi::Parsers::Message > & | msgs |
| ) |  |  |

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 | ( | std::vector< std::pair< int, int > > & | result,
|  | const string & | input |
| ) |  |  |

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 string & | input |
| ) |  |  |

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 | ( | vector< string > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | vector< long double > & | result,
|  | const string & | input |
| ) |  |  |

Definition at line 43 of file ParseVectorsReal.cpp.

    00045     { return parse_real_vector    ( result , input ) ; }

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

Definition at line 39 of file ParseVectorsReal.cpp.

    00041     { return parse_real_vector    ( result , input ) ; }

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

Definition at line 35 of file ParseVectorsReal.cpp.

    00037     { return parse_real_vector    ( result , input ) ; }

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

Definition at line 63 of file ParseVectorsInteger.cpp.

    00065     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 59 of file ParseVectorsInteger.cpp.

    00061     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 55 of file ParseVectorsInteger.cpp.

    00057     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 51 of file ParseVectorsInteger.cpp.

    00053     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 47 of file ParseVectorsInteger.cpp.

    00049     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 43 of file ParseVectorsInteger.cpp.

    00045     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 39 of file ParseVectorsInteger.cpp.

    00041     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 35 of file ParseVectorsInteger.cpp.

    00037     { return parse_integer_vector ( result , input ) ; }

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

Definition at line 43 of file ParseVectorsChar.cpp.

    00045     { return parse_char_vector ( result , input ) ; }

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

Definition at line 39 of file ParseVectorsChar.cpp.

    00041     { return parse_char_vector ( result , input ) ; }

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

Definition at line 35 of file ParseVectorsChar.cpp.

    00037     { return parse_char_vector ( result , input ) ; }

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

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 | ( | 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 | ( | map< unsigned int, std::string > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< int, std::string > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | string & | name,
|  | string & | value,
|  | const string & | input |
| ) |  |  |

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 | ( | map< std::string, std::vector< double > > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< std::string, std::vector< int > > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< std::string, std::vector< std::string > > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< string, int > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< string, string > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< string, double > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< int, double > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | map< int, int > & | result,
|  | const string & | input |
| ) |  |  |

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 | ( | string & | result,
|  | const string & | input |
| ) |  |  |

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 string & | input |
| ) |  |  |

Definition at line 97 of file ParseAtomic.cpp.

    00099     { return parse_real ( result , input ) ; }

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

Definition at line 93 of file ParseAtomic.cpp.

    00095     { return parse_real ( result , input ) ; }

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

Definition at line 89 of file ParseAtomic.cpp.

    00091     { return parse_real ( result , input ) ; }

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

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     }

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

Definition at line 75 of file ParseAtomic.cpp.

    00077     { return parse_integer ( result , input ) ; }

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

Definition at line 71 of file ParseAtomic.cpp.

    00073     { return parse_integer ( result , input ) ; }

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

Definition at line 67 of file ParseAtomic.cpp.

    00069     { return parse_integer ( result , input ) ; }

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

Definition at line 63 of file ParseAtomic.cpp.

    00065     { return parse_integer ( result , input ) ; }

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

Definition at line 59 of file ParseAtomic.cpp.

    00061     { return parse_integer ( result , input ) ; }

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

Definition at line 55 of file ParseAtomic.cpp.

    00057     { return parse_integer ( result , input ) ; }

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

Definition at line 51 of file ParseAtomic.cpp.

    00053     { return parse_integer ( result , input ) ; }

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

Definition at line 47 of file ParseAtomic.cpp.

    00049     { return parse_integer ( result , input ) ; }

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

Definition at line 43 of file ParseAtomic.cpp.

    00045     { return parse_char    ( result , input ) ; }

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

Definition at line 39 of file ParseAtomic.cpp.

    00041     { return parse_char    ( result , input ) ; }

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

Definition at line 35 of file ParseAtomic.cpp.

    00037     { return parse_char    ( result , input ) ; }

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

helper function, needed for implementation of "Histogram Property"

Parameters:

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

Returns:
  status code

Author:
  Vanya BELYAEV 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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     }