/search.css" rel="stylesheet" type="text/css"/> /search.js">
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

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

Namespaces

namespace  Utils

Classes

struct  _NoCaseCmp_
 case-insensitive comparison criteria for strings More...
class  Catalogue
 Catalogue of PropertyEntry. More...
class  PropertyEntry
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: More...
class  MapGrammar
 The valid represenation of map are: More...
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. 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...

Typedefs

typedef
boost::spirit::position_iterator
< std::string::const_iterator > 		IteratorT
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

bool parse (char &result, const string &input)
bool parse (unsigned char &result, const string &input)
bool parse (signed char &result, const string &input)
bool parse (short &result, const string &input)
bool parse (unsigned short &result, const string &input)
bool parse (int &result, const string &input)
bool parse (unsigned int &result, const string &input)
bool parse (long &result, const string &input)
bool parse (unsigned long &result, const string &input)
bool parse (long long &result, const string &input)
bool parse (unsigned long long &result, const string &input)
bool parse (bool &result, const string &input)
bool parse (float &result, const string &input)
bool parse (double &result, const string &input)
bool parse (long double &result, const string &input)
bool parse (string &result, const string &input)
bool parse (map< int, int > &result, const string &input)
bool parse (map< int, double > &result, const string &input)
bool parse (map< string, double > &result, const string &input)
bool parse (map< string, string > &result, const string &input)
bool parse (map< string, int > &result, const string &input)
bool parse (map< std::string, std::vector< std::string > > &result, const string &input)
bool parse (map< std::string, std::vector< int > > &result, const string &input)
bool parse (map< std::string, std::vector< double > > &result, const string &input)
bool parse (string &name, string &value, const string &input)
bool parse (map< int, std::string > &result, const string &input)
bool parse (map< unsigned int, std::string > &result, const string &input)
bool parse (pair< double, double > &result, const string &input)
bool parse (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)
bool parse (vector< bool > &result, const string &input)
bool parse (vector< char > &result, const string &input)
bool parse (vector< unsigned char > &result, const string &input)
bool parse (vector< signed char > &result, const string &input)
bool parse (vector< short > &result, const string &input)
bool parse (vector< unsigned short > &result, const string &input)
bool parse (vector< int > &result, const string &input)
bool parse (vector< unsigned int > &result, const string &input)
bool parse (vector< long > &result, const string &input)
bool parse (vector< unsigned long > &result, const string &input)
bool parse (vector< long long > &result, const string &input)
bool parse (vector< unsigned long long > &result, const string &input)
bool parse (vector< float > &result, const string &input)
bool parse (vector< double > &result, const string &input)
bool parse (vector< long double > &result, const string &input)
bool parse (vector< string > &result, const string &input)
bool parse (std::vector< std::vector< std::string > > &result, const std::string &input)
 parse the std::vector<std::vector<std::string> > value
bool parse (std::vector< std::vector< double > > &result, const std::string &input)
 parse the std::vector<std::vector<double> > value
bool parse (std::vector< std::pair< double, double > > &result, const string &input)
bool parse (std::vector< std::pair< int, int > > &result, const string &input)
bool parse (bool &result, const std::string &input)
 parse the bool value
bool parse (char &result, const std::string &input)
 parse the char value
bool parse (unsigned char &result, const std::string &input)
bool parse (signed char &result, const std::string &input)
bool parse (int &result, const std::string &input)
 parse the int value
bool parse (short &result, const std::string &input)
bool parse (unsigned short &result, const std::string &input)
bool parse (unsigned int &result, const std::string &input)
bool parse (long &result, const std::string &input)
bool parse (unsigned long &result, const std::string &input)
bool parse (long long &result, const std::string &input)
bool parse (unsigned long long &result, const std::string &input)
bool parse (double &result, const std::string &input)
 parse the double value
bool parse (float &result, const std::string &input)
bool parse (long double &result, const std::string &input)
bool parse (std::string &result, const std::string &input)
 parse the std::string value
bool parse (std::vector< bool > &result, const std::string &input)
 parse the std::vector<bool> value
bool parse (std::vector< char > &result, const std::string &input)
 parse the std::vector<char> value
bool parse (std::vector< unsigned char > &result, const std::string &input)
bool parse (std::vector< signed char > &result, const std::string &input)
bool parse (std::vector< int > &result, const std::string &input)
 parse the std::vector<int> value
bool parse (std::vector< short > &result, const std::string &input)
bool parse (std::vector< unsigned short > &result, const std::string &input)
bool parse (std::vector< unsigned int > &result, const std::string &input)
bool parse (std::vector< long > &result, const std::string &input)
bool parse (std::vector< unsigned long > &result, const std::string &input)
bool parse (std::vector< long long > &result, const std::string &input)
bool parse (std::vector< unsigned long long > &result, const std::string &input)
bool parse (std::vector< double > &result, const std::string &input)
 parse the std::vector<double> value
bool parse (std::vector< float > &result, const std::string &input)
bool parse (std::vector< long double > &result, const std::string &input)
bool parse (std::vector< std::string > &result, const std::string &input)
 parse the std::vector<std::string> value
bool parse (std::pair< double, double > &result, const std::string &input)
 parse the std::pair<double,double> value
bool parse (std::pair< int, int > &result, const std::string &input)
 parse the std::pair<int,int> value
bool parse (std::vector< std::pair< double, double > > &result, const std::string &input)
 parse the std::vector<std::pair<double,double> > value
bool parse (std::vector< std::pair< int, int > > &result, const std::string &input)
 parse the std::vector<std::pair<int,int> > value
bool parse (std::map< int, int > &result, const std::string &input)
 parse the std::map<int , int> value
bool parse (std::map< int, double > &result, const std::string &input)
 parse the std::map<int , double> value
bool parse (std::map< std::string, std::string > &result, const std::string &input)
 parse the std::map<std::string , std::string> value
bool parse (std::map< std::string, int > &result, const std::string &input)
 parse the std::map<std::string , int> value
bool parse (std::map< std::string, double > &result, const std::string &input)
 parse the std::map<std::string , double> value
bool 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
bool parse (std::map< std::string, std::vector< int > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<int> > value
bool parse (std::map< std::string, std::vector< double > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<double> > value
bool parse (std::map< int, std::string > &result, const std::string &input)
 parse the std::map<int,std::string> > objects
bool parse (std::map< unsigned int, std::string > &result, const std::string &input)
 parse the std::map<unsigned int,std::string> > objects
bool parse (std::string &name, std::string &value, const std::string &input)
 parse the pair expression (map-component) " 'name' :value"

Typedef Documentation

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

Definition at line 36 of file ParserGrammar.h.

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

Definition at line 185 of file ParserGrammar.h.

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

Definition at line 339 of file ParserGrammar.h.

Function Documentation

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

Definition at line 35 of file ParseAtomic.cc.

    { return parse_char    ( result , input ) ; }
bool Gaudi::Parsers::parse ( unsigned char &  result,
const string &  input 
)

Definition at line 39 of file ParseAtomic.cc.

    { return parse_char    ( result , input ) ; }
bool Gaudi::Parsers::parse ( signed char &  result,
const string &  input 
)

Definition at line 43 of file ParseAtomic.cc.

    { return parse_char    ( result , input ) ; }
bool Gaudi::Parsers::parse ( short &  result,
const string &  input 
)

Definition at line 47 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( unsigned short &  result,
const string &  input 
)

Definition at line 51 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( int &  result,
const string &  input 
)

Definition at line 55 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( unsigned int &  result,
const string &  input 
)

Definition at line 59 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( long &  result,
const string &  input 
)

Definition at line 63 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( unsigned long &  result,
const string &  input 
)

Definition at line 67 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( long long &  result,
const string &  input 
)

Definition at line 71 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( unsigned long long &  result,
const string &  input 
)

Definition at line 75 of file ParseAtomic.cc.

    { return parse_integer ( result , input ) ; }
bool Gaudi::Parsers::parse ( bool &  result,
const string &  input 
)

Definition at line 79 of file ParseAtomic.cc.

    {
      BoolGrammar g;
      return parse( 
          createIterator(input), 
          IteratorT(),
          g[var(result)=arg1]).full;
    }
bool Gaudi::Parsers::parse ( float &  result,
const string &  input 
)

Definition at line 89 of file ParseAtomic.cc.

    { return parse_real ( result , input ) ; }
bool Gaudi::Parsers::parse ( double &  result,
const string &  input 
)

Definition at line 93 of file ParseAtomic.cc.

    { return parse_real ( result , input ) ; }
bool Gaudi::Parsers::parse ( long double &  result,
const string &  input 
)

Definition at line 97 of file ParseAtomic.cc.

    { return parse_real ( result , input ) ; }
bool Gaudi::Parsers::parse ( string &  result,
const string &  input 
)

Attention:
always!!!

Definition at line 101 of file ParseAtomic.cc.

    {
      StringGrammar g;
      if ( !parse(
              createIterator(input), 
              IteratorT(),
              g[var(result)=arg1]).full ){ result = input ; }
      return true ;
    }
bool Gaudi::Parsers::parse ( map< int, int > &  result,
const string &  input 
)

Definition at line 34 of file ParseMaps.cc.

    {
      MapGrammar< IntGrammar<int> , IntGrammar<int> > g;
      return parse
        ( createIterator(input)  , 
          IteratorT()            ,
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< int, double > &  result,
const string &  input 
)

Definition at line 46 of file ParseMaps.cc.

    {
      MapGrammar< IntGrammar<int> , RealGrammar<double> > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< string, double > &  result,
const string &  input 
)

Definition at line 58 of file ParseMaps.cc.

    {
      MapGrammar<StringGrammar,RealGrammar<double> > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< string, string > &  result,
const string &  input 
)

Definition at line 70 of file ParseMaps.cc.

    {
      MapGrammar<StringGrammar,StringGrammar> g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< string, int > &  result,
const string &  input 
)

Definition at line 82 of file ParseMaps.cc.

    {
      MapGrammar<StringGrammar,IntGrammar<int> > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< std::string, std::vector< std::string > > &  result,
const string &  input 
)

Definition at line 94 of file ParseMaps.cc.

    {
      MapGrammar<StringGrammar,VectorGrammar<StringGrammar> > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< std::string, std::vector< int > > &  result,
const string &  input 
)

Definition at line 106 of file ParseMaps.cc.

    {
      MapGrammar<StringGrammar,VectorGrammar<IntGrammar<int> > > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< std::string, std::vector< double > > &  result,
const string &  input 
)

Definition at line 118 of file ParseMaps.cc.

    {
      MapGrammar<StringGrammar,VectorGrammar<RealGrammar<double> > > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( string &  name,
string &  value,
const string &  input 
)

Definition at line 156 of file ParseMaps.cc.

    {
      return parse 
        ( input.c_str(),
          (
           ch_p('"' ) >> (+(anychar_p-ch_p('"' )))[assign_a(name)] >> ch_p('"' )
           |
           ch_p('\'') >> (+(anychar_p-ch_p('\'')))[assign_a(name)] >> ch_p('\'')
           )
          >> ":"
          >> (+anychar_p)[assign_a(value)], space_p).full;
    }
bool Gaudi::Parsers::parse ( map< int, std::string > &  result,
const string &  input 
)

Definition at line 170 of file ParseMaps.cc.

    {
      MapGrammar<IntGrammar<int>,StringGrammar> g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( map< unsigned int, std::string > &  result,
const string &  input 
)

Definition at line 182 of file ParseMaps.cc.

    {
      MapGrammar<IntGrammar<unsigned int>,StringGrammar> g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( pair< double, double > &  result,
const string &  input 
)

Definition at line 35 of file ParsePairs.cc.

    {
      return parse
        ( createIterator(input), 
          IteratorT(),
          PairGrammar < RealGrammar<double> , RealGrammar <double> >()
          [var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( pair< int, int > &  result,
const string &  input 
)

Definition at line 45 of file ParsePairs.cc.

    {
      return parse
        ( createIterator(input), 
          IteratorT(),
          PairGrammar < IntGrammar<int> , IntGrammar <int> >()[var(result)=arg1],
          SkipperGrammar()).full;
    }
template<class T >
phoenix::actor<PushBackImpl<T> > Gaudi::Parsers::PushBack ( T &  x) [inline]

Definition at line 78 of file ParserActions.h.

                                                                  {
      return PushBackImpl<T> (x);
    }
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.

                                                                              {
      return PushBackRefImpl<T,IT> (x,it);
    }
template<class T >
phoenix::actor<AssignBoolToStringImpl<T> > Gaudi::Parsers::AssignBoolToString ( T &  x) [inline]

Definition at line 86 of file ParserActions.h.

                                                                                                        {
      return AssignBoolToStringImpl<T> (x);
    }
bool Gaudi::Parsers::parse ( vector< bool > &  result,
const string &  input 
)

Definition at line 35 of file ParseVectorsBool.cc.

    {
      VectorGrammar<BoolGrammar> g;
      return parse(
            createIterator(input), 
            IteratorT(),
            g[var(result)=arg1],
            SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( vector< char > &  result,
const string &  input 
)

Definition at line 35 of file ParseVectorsChar.cc.

    { return parse_char_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< unsigned char > &  result,
const string &  input 
)

Definition at line 39 of file ParseVectorsChar.cc.

    { return parse_char_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< signed char > &  result,
const string &  input 
)

Definition at line 43 of file ParseVectorsChar.cc.

    { return parse_char_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< short > &  result,
const string &  input 
)

Definition at line 35 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< unsigned short > &  result,
const string &  input 
)

Definition at line 39 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< int > &  result,
const string &  input 
)

Definition at line 43 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< unsigned int > &  result,
const string &  input 
)

Definition at line 47 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< long > &  result,
const string &  input 
)

Definition at line 51 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< unsigned long > &  result,
const string &  input 
)

Definition at line 55 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< long long > &  result,
const string &  input 
)

Definition at line 59 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< unsigned long long > &  result,
const string &  input 
)

Definition at line 63 of file ParseVectorsInteger.cc.

    { return parse_integer_vector ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< float > &  result,
const string &  input 
)

Definition at line 35 of file ParseVectorsReal.cc.

    { return parse_real_vector    ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< double > &  result,
const string &  input 
)

Definition at line 39 of file ParseVectorsReal.cc.

    { return parse_real_vector    ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< long double > &  result,
const string &  input 
)

Definition at line 43 of file ParseVectorsReal.cc.

    { return parse_real_vector    ( result , input ) ; }
bool Gaudi::Parsers::parse ( vector< string > &  result,
const string &  input 
)

Definition at line 35 of file ParseVectorsString.cc.

    {
      VectorGrammar<StringGrammar> g;
      return parse(
          createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool 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.cc.

    {
      VectorGrammar< VectorGrammar<StringGrammar> > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full ;
    }
bool 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.cc.

    {
      VectorGrammar< VectorGrammar< RealGrammar< double > > > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( std::vector< std::pair< double, double > > &  result,
const string &  input 
)

Definition at line 60 of file ParseVectorsVector.cc.

    {
      VectorGrammar<PairGrammar<RealGrammar<double>,RealGrammar<double> > > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool Gaudi::Parsers::parse ( std::vector< std::pair< int, int > > &  result,
const string &  input 
)

Definition at line 72 of file ParseVectorsVector.cc.

    {
      VectorGrammar<PairGrammar<IntGrammar<int>,IntGrammar<int> > > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
bool 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
bool 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
bool Gaudi::Parsers::parse ( unsigned char &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser(char&,std::string&)
bool Gaudi::Parsers::parse ( signed char &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser(char&,std::string&)
bool 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
bool Gaudi::Parsers::parse ( short &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool Gaudi::Parsers::parse ( unsigned short &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool Gaudi::Parsers::parse ( unsigned int &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool Gaudi::Parsers::parse ( long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool Gaudi::Parsers::parse ( unsigned long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool Gaudi::Parsers::parse ( long long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool Gaudi::Parsers::parse ( unsigned long long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )
bool 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
bool Gaudi::Parsers::parse ( float &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( double&, const std::string& )
bool Gaudi::Parsers::parse ( long double &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( double&, const std::string& )
bool 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
bool 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
bool 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
bool Gaudi::Parsers::parse ( std::vector< unsigned char > &  result,
const std::string &  input 
)
See also:
parse( std::vector<char>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< signed char > &  result,
const std::string &  input 
)
See also:
parse( std::vector<char>& ,const std::string& );
bool 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
bool Gaudi::Parsers::parse ( std::vector< short > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< unsigned short > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< unsigned int > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< unsigned long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< long long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< unsigned long long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );
bool 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
bool Gaudi::Parsers::parse ( std::vector< float > &  result,
const std::string &  input 
)
See also:
parse( std::vector<double>& ,const std::string& );
bool Gaudi::Parsers::parse ( std::vector< long double > &  result,
const std::string &  input 
)
See also:
parse( std::vector<double>& ,const std::string& );
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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
bool 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 ;
  bool 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
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |
Generated on Fri May 16 2014 09:50:18 for LafKernel by doxygen 1.7.4