Gaudi Framework, version v22r2
Home   Generated: Tue May 10 2011
Namespaces | Classes | Typedefs | Functions

Gaudi::Parsers Namespace Reference

Namespaces

namespace  Utils

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  Pnt3DGrammar
 The grammar for 3D-point. More...
class  Pnt4DGrammar
 The grammar for 4D-point. 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...

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

template<class TYPE , std::size_t N>
StatusCode parse (boost::array< TYPE, N > &result, const std::string &input)
 parse class boost::array from the string
GAUDI_API StatusCode parse (bool &result, const std::string &input)
 parse the bool value
GAUDI_API StatusCode parse (char &result, const std::string &input)
 parse the char value
GAUDI_API StatusCode parse (unsigned char &result, const std::string &input)
GAUDI_API StatusCode parse (signed char &result, const std::string &input)
GAUDI_API StatusCode parse (int &result, const std::string &input)
 parse the int value
GAUDI_API StatusCode parse (short &result, const std::string &input)
GAUDI_API StatusCode parse (unsigned short &result, const std::string &input)
GAUDI_API StatusCode parse (unsigned int &result, const std::string &input)
GAUDI_API StatusCode parse (long &result, const std::string &input)
GAUDI_API StatusCode parse (unsigned long &result, const std::string &input)
GAUDI_API StatusCode parse (long long &result, const std::string &input)
GAUDI_API StatusCode parse (unsigned long long &result, const std::string &input)
GAUDI_API StatusCode parse (double &result, const std::string &input)
 parse the double value
GAUDI_API StatusCode parse (float &result, const std::string &input)
GAUDI_API StatusCode parse (long double &result, const std::string &input)
GAUDI_API StatusCode parse (std::string &result, const std::string &input)
 parse the std::string value
GAUDI_API StatusCode parse (std::vector< bool > &result, const std::string &input)
 parse the std::vector<bool> value
GAUDI_API StatusCode parse (std::vector< char > &result, const std::string &input)
 parse the std::vector<char> value
GAUDI_API StatusCode parse (std::vector< unsigned char > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< signed char > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< int > &result, const std::string &input)
 parse the std::vector<int> value
GAUDI_API StatusCode parse (std::vector< short > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< unsigned short > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< unsigned int > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< long > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< unsigned long > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< long long > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< unsigned long long > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< double > &result, const std::string &input)
 parse the std::vector<double> value
GAUDI_API StatusCode parse (std::vector< float > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< long double > &result, const std::string &input)
GAUDI_API StatusCode parse (std::vector< std::string > &result, const std::string &input)
 parse the std::vector<std::string> value
GAUDI_API StatusCode parse (std::pair< double, double > &result, const std::string &input)
 parse the std::pair<double,double> value
GAUDI_API StatusCode parse (std::pair< int, int > &result, const std::string &input)
 parse the std::pair<int,int> value
GAUDI_API StatusCode parse (std::vector< std::pair< double, double > > &result, const std::string &input)
 parse the std::vector<std::pair<double,double> > value
GAUDI_API StatusCode parse (std::vector< std::pair< int, int > > &result, const std::string &input)
 parse the std::vector<std::pair<int,int> > value
GAUDI_API StatusCode parse (std::vector< std::vector< std::string > > &result, const std::string &input)
 parse the std::vector<std::vector<std::string> > value
GAUDI_API StatusCode parse (std::vector< std::vector< double > > &result, const std::string &input)
 parse the std::vector<std::vector<double> > value
GAUDI_API StatusCode parse (std::map< int, int > &result, const std::string &input)
 parse the std::map<int , int> value
GAUDI_API StatusCode parse (std::map< int, double > &result, const std::string &input)
 parse the std::map<int , double> value
GAUDI_API StatusCode parse (std::map< std::string, std::string > &result, const std::string &input)
 parse the std::map<std::string , std::string> value
GAUDI_API StatusCode parse (std::map< std::string, int > &result, const std::string &input)
 parse the std::map<std::string , int> value
GAUDI_API StatusCode parse (std::map< std::string, double > &result, const std::string &input)
 parse the std::map<std::string , double> value
GAUDI_API StatusCode parse (std::map< std::string, std::vector< std::string > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<std::string> > value
GAUDI_API StatusCode parse (std::map< std::string, std::vector< int > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<int> > value
GAUDI_API StatusCode parse (std::map< std::string, std::vector< double > > &result, const std::string &input)
 parse the std::map<std::string , std::vector<double> > value
GAUDI_API StatusCode parse (std::map< int, std::string > &result, const std::string &input)
 parse the std::map<int,std::string> > objects
GAUDI_API StatusCode parse (std::map< unsigned int, std::string > &result, const std::string &input)
 parse the std::map<unsigned int,std::string> > objects
GAUDI_API StatusCode parse (std::map< std::string, unsigned int > &result, const std::string &input)
 parse the std::map<unsigned int,std::string> > objects
GAUDI_API StatusCode parse (std::string &name, std::string &value, const std::string &input)
 parse the pair expression (map-component) " 'name' :value"
GAUDI_API StatusCode parse (Gaudi::Histo1DDef &histo, const std::string &input)
 helper function, needed for implementation of "Histogram Property"
GAUDI_API StatusCode parse (std::map< std::string, Gaudi::Histo1DDef > &histos, const std::string &input)
 helper function, needed for implementation of "Histogram Property"
GAUDI_API StatusCode parse (std::map< std::string, std::pair< double, double > > &params, const std::string &input)
 helper function, needed for implementation of map of pairs It is very useful construction for monitoring to represent the value and error or the allowed range for some parameter
template<class T , unsigned int N>
StatusCode parse (T(&result)[N], const std::string &input)
 parser function for C-arrays
template<unsigned int N>
StatusCode parse (char(&result)[N], const std::string &input)
 parser function for C-strings
IteratorT createIterator (const std::string &input)
 create the position iterator from the input
template<typename IntegerT >
StatusCode parse_integer (IntegerT &result, const string &input)
 helper function to "merge" the implementation of all parsers for integer-like quantities into one templated grammar
template<typename IntegerT >
StatusCode parse_integer_vector (std::vector< IntegerT > &result, const string &input)
 helper function to "merge" the implementation of all parsers for vector of integer-like quantities into the combination of templated grammars
template<typename CharT >
StatusCode parse_char (CharT &result, const string &input)
 helper function to "merge" the implementation of all parsers for "char-like" quantities into one templated grammar
template<typename CharT >
StatusCode parse_char_vector (std::vector< CharT > &result, const string &input)
 helper function to "merge" the implementation of all parsers for vector of 'char-like' quantities into the combination of templated grammars
template<typename RealT >
StatusCode parse_real (RealT &result, const string &input)
 helper function to "merge" the implementation of all parsers for "float-like" quantities into one templated grammar
template<typename RealT >
StatusCode parse_real_vector (std::vector< RealT > &result, const string &input)
 helper function to "merge" the implementation of all parsers for vector of 'char-like' quantities into the combination of templated grammars
GAUDI_API StatusCode parse (Gaudi::StringKey &result, const std::string &input)
 parse the key from the string
GAUDI_API StatusCode parse (std::vector< Gaudi::StringKey > &result, const std::string &input)
 parse the vector of keys from the string
template<class SCALAR , unsigned int N>
StatusCode parse (ROOT::Math::SVector< SCALAR, N > &result, const std::string &input)
 parse SVector
GAUDI_API StatusCode parse (Gaudi::XYZPoint &result, const std::string &input)
 parse 3D-point
GAUDI_API StatusCode parse (Gaudi::XYZVector &result, const std::string &input)
 parse 3D-vector
GAUDI_API StatusCode parse (Gaudi::LorentzVector &result, const std::string &input)
 parse LorentzVector
GAUDI_API StatusCode parse (std::vector< Gaudi::XYZPoint > &result, const std::string &input)
 parse the vector of points
GAUDI_API StatusCode parse (std::vector< Gaudi::XYZVector > &result, const std::string &input)
 parse the vector of vectors
GAUDI_API StatusCode parse (std::vector< Gaudi::LorentzVector > &result, const std::string &input)
 parse the vector of vectors
template<class T >
phoenix::actor< PushBackImpl< T > > PushBack (T &x)
template<class T , typename IT >
phoenix::actor
< PushBackRefImpl< T, IT > > 		PushBack (T &x, IT it)
template<class T >
phoenix::actor
< AssignBoolToStringImpl< T > > 		AssignBoolToString (T &x)
StatusCode parse (Parser parser, const std::string &fileName, std::vector< Message > &msgs)
 Parse job options fiel using the configured parser object.
StatusCode parse (const std::string &filename, const std::vector< std::string > &searchPath, Catalogue &catalogue, std::vector< std::string > &included, std::vector< Message > &messages)
 Parse job options file.
StatusCode parse (const std::string &filename, const std::string &searchPath, Catalogue &catalogue, std::vector< std::string > &included, std::vector< Message > &messages)
 Parse job options file.
StatusCode parse (const std::string &filename, Catalogue &catalogue, std::vector< std::string > &included, std::vector< Message > &messages)
 Parse job options file.

Typedef Documentation

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

the actual type of position iterator

Definition at line 64 of file Parsers.icpp.

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

Definition at line 441 of file ParserGrammar.h.

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

Definition at line 287 of file ParserGrammar.h.

Function Documentation

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

Definition at line 95 of file ParserActions.h.

                                                                                                        {
      return AssignBoolToStringImpl<T> (x);
    }
IteratorT Gaudi::Parsers::createIterator ( const std::string &  input ) [inline]

create the position iterator from the input

Definition at line 67 of file Parsers.icpp.

    { return IteratorT ( input.begin(), input.end() ) ; }
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:
filenamePath to options file
searchPathDirectories for search include and units files
Catalogueof parser properties
includedAlready included files
Listof parser messages
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2006-02-17

Definition at line 64 of file ParserUtils.cpp.

{
  return parse
    ( Gaudi::Parsers::Parser (catalogue , included, searchPath ) ,
      filename ,  msgs ) ;
}
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:
filenamePath to options file
searchPathDirectories for search include and units files
Catalogueof parser properties
includedAlready included files
Listof parser messages
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2006-02-17

Definition at line 52 of file ParserUtils.cpp.

{
  return parse
    ( Gaudi::Parsers::Parser(catalogue, included, searchPath) ,
      filename , msgs ) ;
}
StatusCode Gaudi::Parsers::parse ( Parser  parser,
const std::string &  fileName,
std::vector< Message > &  msgs 
)

Parse job options fiel using the configured parser object.

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

Definition at line 42 of file ParserUtils.cpp.

{
  StatusCode res = parser.parse(fileName);
  msgs = parser.messages();
  return res;
}
StatusCode Gaudi::Parsers::parse ( std::vector< std::pair< int, int > > &  result,
const std::string &  input 
)

parse the std::vector<std::pair<int,int> > value

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::PairGrammar
Gaudi::Parsers::IntGrammar
Parameters:
result(output) vector with pairs of int
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 72 of file ParseVectorsVector.cpp.

    {
      VectorGrammar<PairGrammar<IntGrammar<int>,IntGrammar<int> > > g;
      return parse
        ( createIterator(input), 
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
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:
filenamePath to options file
Catalogueof parser properties
includedAlready included files
Listof parser messages
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2006-02-17

Definition at line 76 of file ParserUtils.cpp.

                                    {
  return parse
    (Gaudi::Parsers::Parser(catalogue,included),filename,msgs);
}
StatusCode Gaudi::Parsers::parse ( bool &  result,
const std::string &  input 
)

parse the bool value

See also:
Gaudi::Parsers::BoolGrammar
Parameters:
result(output) boolean result
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 84 of file ParseAtomic.cpp.

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

parse the vector of vectors

Parameters:
resut(OUTPUT) the parser vector
input(INPIUT) the string to be parsed
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 224 of file ParseVct.cpp.

{
  result.clear() ;
  
  // the grammar 
  VectorGrammar < Pnt4DGrammar<RealGrammar<double>,Gaudi::LorentzVector> >  g ;
  
  if ( parse ( input.begin () , 
               input.end   () ,
               g[var(result)=arg1],SkipperGrammar()).full ) 
  { return StatusCode::SUCCESS ; }                                  // RETURN 
  //
  return StatusCode::FAILURE ;
}
StatusCode Gaudi::Parsers::parse ( std::vector< Gaudi::XYZVector > &  result,
const std::string &  input 
)

parse the vector of vectors

Parameters:
resut(OUTPUT) the parser vector
input(INPIUT) the string to be parsed
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 199 of file ParseVct.cpp.

{
  result.clear() ;
  
  // the grammar 
  VectorGrammar < Pnt3DGrammar<RealGrammar<double>,Gaudi::XYZVector> >  g ;
  
  if ( parse ( input.begin () , 
               input.end   () ,
               g[var(result)=arg1],SkipperGrammar()).full ) 
  { return StatusCode::SUCCESS ; }                                  // RETURN 
  //
  return StatusCode::FAILURE ;
}
StatusCode Gaudi::Parsers::parse ( std::vector< Gaudi::XYZPoint > &  result,
const std::string &  input 
)

parse the vector of points

Parameters:
resut(OUTPUT) the parser vector
input(INPIUT) the string to be parsed
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 175 of file ParseVct.cpp.

{
  result.clear() ;
  
  // the grammar 
  VectorGrammar < Pnt3DGrammar<RealGrammar<double>,Gaudi::XYZPoint> >  g ;
  
  if ( parse ( input.begin () , 
               input.end   () ,
               g[var(result)=arg1],SkipperGrammar()).full ) 
  { return StatusCode::SUCCESS ; }                                  // RETURN 
  //
  return StatusCode::FAILURE ;
}
StatusCode Gaudi::Parsers::parse ( Gaudi::LorentzVector &  result,
const std::string &  input 
)

parse LorentzVector

Valid representations of Lorenzt vector

  • a'la python tuple with 4 elements ("canonical")
  • a'la python list with 4 elements
  • python/list with inner representation of 3D-point/vector
  • tuple or list with named ordered fields
    " (1,2,3,4) "     
    " (1,2,3;4) "

    " [1,2,3,4] " 
    " [1,2,3;4] " 

    " [ x:1 ,2,3; e= 4] " 
    " [ pX : 1 , PY : 2, 3 , T= 4] " 

    " [ ( pX : 1 , PY : 2, 3 ) , 4] " 
    " [ ( pX : 1 , PY : 2, 3 ) ; 4] " 

    " [ 4 , ( pX : 1 , PY : 2, 3 ) ] " 
    " [ 4 ; ( pX : 1 , PY : 2, 3 ) ] " 

    " [ [ pX : 1 , PY : 2, 3 ] , 4] " 
    " [ [ pX : 1 , PY : 2, 3 ] ; 4] " 

    " [ 4 , [ pX : 1 , PY : 2, 3 ] ] " 
    " [ 4 ; [ pX : 1 , PY : 2, 3 ] ] " 

    " ( ( pX : 1 , PY : 2, 3 ) , 4 )" 
    " ( ( pX : 1 , PY : 2, 3 ) ; 4 )" 

    " ( 4 , ( pX : 1 , PY : 2, 3 ) )" 
    " ( 4 ; ( pX : 1 , PY : 2, 3 ) )" 

    " ( [ pX : 1 , PY : 2, 3 ] , 4 )" 
    " ( [ pX : 1 , PY : 2, 3 ] ; 4 )" 

    " ( 4 , [ pX : 1 , PY : 2, 3 ] )" 
    " ( 4 ; [ pX : 1 , PY : 2, 3 ] )"

Note that "eenrgy" element can be separated with semicolumn.

Valid keys for names fields:

    "x", "X" , "pX" , "Px" , "PX "
    "y", "Y" , "pY" , "Py" , "PY "
    "z", "Z" , "pZ" , "Pz" , "PZ "
    "t", "T" , "e"  , "E"
Attention:
Named fields must be ordered (x,y,z)
Parameters:
result(output) the parsed lorentz vector
input(input) the input string
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 127 of file ParseVct.cpp.

{
  // the grammar 
  Pnt4DGrammar<RealGrammar<double>,Gaudi::LorentzVector> g ;
  
  
  if ( parse ( input.begin () , 
               input.end   () ,
               g[var(result)=arg1],SkipperGrammar()).full ) 
  { return StatusCode::SUCCESS ; } // RETURN 
  
  // try map:
  MAP m ;
  StatusCode sc = parse ( m , input ) ;
  
  if ( sc.isFailure () ) { return sc                  ; } // RETURN 
  if ( 4 != m.size  () ) { return StatusCode::FAILURE ; } // REUTRN
  
  MAP::const_iterator x = find ( m , s_X ) ;
  MAP::const_iterator y = find ( m , s_Y ) ;
  MAP::const_iterator z = find ( m , s_Z ) ;
  MAP::const_iterator e = find ( m , s_E ) ;
  
  if ( m.end() == x || 
       m.end() == y || 
       m.end() == z || 
       m.end() == e ) { return StatusCode::FAILURE ; } // RETURN 
  
  result.SetXYZT ( x->second , 
                   y->second , 
                   z->second ,
                   e->second ) ;
  
  return StatusCode::SUCCESS ;

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

parse 3D-vector

Valid representations of 3D-vector:

  • a'la python tuple with 3 elements ("canonical")
  • a'la python list with 3 elements
  • tuple or list with named ordered fields
    " (1,2,3) " 
    " [1,2,3] " 
    " [ x : 1, 2, Z:3 ] " 
    " [ pX : 1 , PY : 2, 3] "

Valid keys for names fields:

    "x", "X" , "pX" , "Px" , "PX "
    "y", "Y" , "pY" , "Py" , "PY "
    "z", "Z" , "pZ" , "Pz" , "PZ "
Attention:
Named fields must be ordered (x,y,z)
Parameters:
result(output) the parsed vector
input(input) the input string
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 104 of file ParseVct.cpp.

{
  
  Gaudi::XYZPoint point ;
  
  StatusCode sc = parse ( point , input ) ;
  if ( sc.isFailure() ){ return sc ; }                               // RETURN 
  
  result = point ;
  return StatusCode::SUCCESS ;                                       // RETURN  
}
StatusCode Gaudi::Parsers::parse ( Gaudi::XYZPoint &  result,
const std::string &  input 
)

parse 3D-point

Valid representations of 3D-point:

  • a'la python tuple with 3 elements ("canonical")
  • a'la python list with 3 elements
  • tuple or list with named ordered fields
    " (1,2,3) " 
    " [1,2,3] " 
    " [ x : 1, 2, Z:3 ] " 
    " [ pX : 1 , PY : 2, 3] "

Valid keys for names fields:

    "x", "X" , "pX" , "Px" , "PX "
    "y", "Y" , "pY" , "Py" , "PY "
    "z", "Z" , "pZ" , "Pz" , "PZ "
Attention:
Named fields must be ordered (x,y,z)
Parameters:
result(output) the parsed point
input(input) the input string
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 61 of file ParseVct.cpp.

{
  // the grammar 
  Pnt3DGrammar<RealGrammar<double>,Gaudi::XYZPoint> g ;
  
  if ( parse ( input.begin () , 
               input.end   () ,
               g[var(result)=arg1],SkipperGrammar()).full ) 
  { return StatusCode::SUCCESS ; } // RETURN 
  
  // try map:
  MAP m ;
  StatusCode sc = parse ( m , input ) ;
  
  if ( sc.isFailure () ) { return sc                  ; } // RETURN 
  if ( 3 != m.size  () ) { return StatusCode::FAILURE ; } // REUTRN
  
  MAP::const_iterator x = find ( m , s_X ) ;
  MAP::const_iterator y = find ( m , s_Y ) ;
  MAP::const_iterator z = find ( m , s_Z ) ;
  
  if ( m.end() == x || 
       m.end() == y || 
       m.end() == z  ) { return StatusCode::FAILURE ; } // RETURN 
  
  result.SetXYZ ( x->second , 
                  y->second ,
                  z->second ) ;
  
  return StatusCode::SUCCESS ;
  
}
template<class SCALAR , unsigned int N>
StatusCode Gaudi::Parsers::parse ( ROOT::Math::SVector< SCALAR, N > &  result,
const std::string &  input 
)

parse SVector

Parameters:
result(output) the parsed vector
input(input) the input string
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-05

Definition at line 47 of file SVectorAsProperty.h.

    {
      std::vector<double> tmp ;
      StatusCode sc = parse ( tmp , input ) ;
      if ( sc.isFailure()  ) { return sc                  ; } // RETURN
      if ( N != tmp.size() ) { return StatusCode::FAILURE ; } // RETURN
#ifdef WIN32
// Disable warning
//    C4996: 'std::copy': Function call with parameters that may be unsafe
// The parameters are checked
#pragma warning(push)
#pragma warning(disable:4996)
#endif
      std::copy ( tmp.begin() , tmp.end() , result.begin() ) ;
#ifdef WIN32
#pragma warning(pop)
#endif
      return StatusCode::SUCCESS ;
    }
StatusCode Gaudi::Parsers::parse ( unsigned short &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 56 of file ParseAtomic.cpp.

    { return parse_integer ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( long double &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( double&, const std::string& )

Definition at line 102 of file ParseAtomic.cpp.

    { return parse_real ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< long double > &  result,
const std::string &  input 
)
See also:
parse( std::vector<double>& ,const std::string& );

Definition at line 48 of file ParseVectorsReal.cpp.

    { return parse_real_vector    ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( Gaudi::StringKey &  result,
const std::string &  input 
)

parse the key from the string

See also:
Gaudi::Parsers
Gaudi::Parsers::parse
Gaudi::StringKey
Attention:
: this function is needed to use it as property
Parameters:
result(OUTPUT) the parsing result
inputthe input string
Returns:
status code

Definition at line 79 of file StringKey.cpp.

{
  std::string _result ;
  StatusCode sc = parse ( _result , input ) ;
  result = Gaudi::StringKey ( _result ) ;
  return sc ;
}
StatusCode Gaudi::Parsers::parse ( std::vector< Gaudi::StringKey > &  result,
const std::string &  input 
)

parse the vector of keys from the string

See also:
Gaudi::Parsers
Gaudi::Parsers::parse
Gaudi::StringKey
Attention:
: this function is needed to use it as property
Parameters:
result(OUTPUT) the parsing result
inputthe input string
Returns:
status code

Definition at line 99 of file StringKey.cpp.

{
  result.clear() ;
  typedef std::vector<std::string> Strings ;
  Strings _result ;
  StatusCode sc = parse ( _result , input ) ;
  if ( sc.isFailure() ) { return sc ; }                              // RETURN 
  result.reserve ( _result.size() ) ;
  //
  std::copy ( _result.begin() , 
              _result.end  () , std::back_inserter ( result ) ) ;
  //
  return StatusCode::SUCCESS ;
}
StatusCode Gaudi::Parsers::parse ( std::vector< std::string > &  result,
const std::string &  input 
)

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

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::StringGrammar
Parameters:
result(output) vector with string elements
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 35 of file ParseVectorsString.cpp.

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

parse the std::string value

See also:
Gaudi::Parsers::StringGrammar
Parameters:
result(output) string result
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Attention:
always!!!
always!!!

Definition at line 106 of file ParseAtomic.cpp.

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

Definition at line 35 of file ParsePairs.cpp.

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

Definition at line 64 of file ParseVectorsInteger.cpp.

    { return parse_integer_vector ( result , input ) ; }
template<unsigned int N>
StatusCode Gaudi::Parsers::parse ( char(&)  result[N],
const std::string &  input 
)

parser function for C-strings

Parameters:
paramsC-string
inputthe string to be parsed
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-15

Definition at line 672 of file Parsers.h.

    {
      // clear the string
      std::fill_n ( result , N , ' ' ) ;
      // create the temporary string
      std::string tmp ;
      StatusCode sc = parse ( tmp , input ) ;
      if ( sc.isFailure()  ) { return sc                 ; }  //  RETURN
      if       ( N     == tmp.size() )
      { std::copy ( tmp.begin() , tmp.end() , result ) ; }
      else if  ( N + 2    == tmp.size()                 &&
                 ( '\''   == tmp[0] || '\"' == tmp[0] ) &&
                 ( tmp[0] == tmp[tmp.size()-1]          ))
      { std::copy ( tmp.begin() + 1 , tmp.end() -1 , result ) ; }
      else { return StatusCode::FAILURE ; }
      //
      return StatusCode::SUCCESS ;                            //  RETURN
    }
template<class T , unsigned int N>
StatusCode Gaudi::Parsers::parse ( T(&)  result[N],
const std::string &  input 
)

parser function for C-arrays

Parameters:
paramsC-array
inputthe string to be parsed
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-15

Definition at line 650 of file Parsers.h.

    {
      typedef std::vector<T> _Vct ;
      // create the temporary vector
      _Vct tmp ;
      StatusCode sc = parse ( tmp , input ) ;
      if ( sc.isFailure()  ) { return sc                  ; }  //  RETURN
      if ( N != tmp.size() ) { return StatusCode::FAILURE ; }  //  RETURN
      //
      std::copy ( tmp.begin() , tmp.end() , result ) ;
      //
      return StatusCode::SUCCESS ;                            //  RETURN
    }
StatusCode Gaudi::Parsers::parse ( std::map< std::string, std::pair< double, double > > &  params,
const std::string &  input 
)

helper function, needed for implementation of map of pairs It is very useful construction for monitoring to represent the value and error or the allowed range for some parameter

Parameters:
paramsthe map of pair
inputthe string to be parsed
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2009-05-19

Definition at line 223 of file ParseMaps.cpp.

    {
      typedef PairGrammar< RealGrammar<double> , RealGrammar <double> > PG ;
      MapGrammar < StringGrammar , PG > g ;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(params)=arg1],
          SkipperGrammar()).full;
    }
StatusCode Gaudi::Parsers::parse ( std::map< std::string, Gaudi::Histo1DDef > &  histos,
const std::string &  input 
)

helper function, needed for implementation of "Histogram Property"

Parameters:
histosthe map of the histogram descriptions (output)
inputthe 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.

{
  MapGrammar<StringGrammar,Histo1DGrammar> g;
  const bool full = boost::spirit::parse
    ( createIterator(input), 
      IteratorT()     ,
      g[var(histos)=arg1],
      SkipperGrammar() ).full;
  //
  if ( !full ) { return StatusCode::FAILURE ; }                 // RETURN 
  //
  for ( std::map<std::string,Gaudi::Histo1DDef>::const_iterator 
          ih = histos.begin() ; histos.end() != ih ; ++ih ) 
  { if ( !ih->second.ok() ) { return StatusCode::FAILURE ; } }  // RETURN 
  //
  return StatusCode::SUCCESS ;                                  // RETURN 
}
StatusCode Gaudi::Parsers::parse ( Gaudi::Histo1DDef &  histo,
const std::string &  input 
)

helper function, needed for implementation of "Histogram Property"

Parameters:
histothe histogram description (output)
inputthe 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.

{
  Histo1DGrammar g;
  const bool full =
    boost::spirit::parse
    ( createIterator(input), 
      IteratorT(), 
      g[var(histo)=arg1],
      SkipperGrammar()).full;
  //
  return full && histo.ok() ? StatusCode::SUCCESS : StatusCode::FAILURE ;
}
StatusCode Gaudi::Parsers::parse ( std::string &  name,
std::string &  value,
const std::string &  input 
)

parse the pair expression (map-component) " 'name' :value" 

  const std::string input = "'PackageName':GaudiKernel" ;
  std::string name  ;
  std::string value ;
  StatusCode sc = Gaudi::Parsers::parse ( name , value , input ) ;
  if ( sc.isFailure() ) { ... }
  std::cout <<  "\tParsed name  is " << name
            <<  "\tParsed value is " << value << std::endl
Parameters:
name(output) the parsed name of the component, defined as 'name' or "name" before the column symbol ":", the leading and trailing blans are omitted
value(output) the parsed value of the component, defined as everything after the column symbol ":" till the end of the string
input(input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 162 of file ParseMaps.cpp.

    {
      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;
    }
StatusCode Gaudi::Parsers::parse ( std::map< std::string, unsigned int > &  result,
const std::string &  input 
)

parse the std::map<unsigned int,std::string> > objects

See also:
Gaudi::Parsers::MapGrammar

Definition at line 200 of file ParseMaps.cpp.

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

parse the std::map<unsigned int,std::string> > objects

See also:
Gaudi::Parsers::MapGrammar
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2007-12-06

Definition at line 188 of file ParseMaps.cpp.

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

parse the std::map<int,std::string> > objects

See also:
Gaudi::Parsers::MapGrammar
Author:
Vanya BELYAEV ibelyaev@physics.syr.edu
Alexander MAZUROV Alexander.Mazurov@gmail.com
Date:
2007-12-06

Definition at line 176 of file ParseMaps.cpp.

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

parse the std::map<std::string , std::vector<double> > value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::StringGrammar
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::RealGrammar
Parameters:
result(output) map with string value and vector of doubles as value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 124 of file ParseMaps.cpp.

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

parse the std::map<std::string , std::vector<int> > value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::StringGrammar
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::IntGrammar
Parameters:
result(output) map with string value and vector of integers as value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 112 of file ParseMaps.cpp.

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

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

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::StringGrammar
Gaudi::Parsers::VectorGrammar
Parameters:
result(output) map with string value and vector of strings as value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 100 of file ParseMaps.cpp.

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

parse the std::map<std::string , double> value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::StringGrammar
Gaudi::Parsers::RealGrammar
Parameters:
result(output) map with string key and integer value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 64 of file ParseMaps.cpp.

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

parse the std::map<std::string , int> value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::StringGrammar
Gaudi::Parsers::IntGrammar
Parameters:
result(output) map with string key and integer value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 88 of file ParseMaps.cpp.

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

parse the std::map<std::string , std::string> value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::StringGrammar
Parameters:
result(output) map with string key and value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 76 of file ParseMaps.cpp.

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

parse the std::map<int , double> value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::IntGrammar
Gaudi::Parsers::RealGrammar
Parameters:
result(output) map with integer key and double value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 52 of file ParseMaps.cpp.

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

parse the std::map<int , int> value

See also:
Gaudi::Parsers::MapGrammar
Gaudi::Parsers::IntGrammar
Parameters:
result(output) map with integer key and double value
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 40 of file ParseMaps.cpp.

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

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

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

parse the std::vector<bool> value

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::BoolGrammar
Parameters:
result(output) vector with boolean elements
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 35 of file ParseVectorsBool.cpp.

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

Definition at line 45 of file ParsePairs.cpp.

    {
      return parse
        ( createIterator(input), 
          IteratorT(),
          PairGrammar < IntGrammar<int> , IntGrammar <int> >()[var(result)=arg1],
          SkipperGrammar()).full;
    }
StatusCode Gaudi::Parsers::parse ( unsigned char &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser(char&,std::string&)

Definition at line 44 of file ParseAtomic.cpp.

    { return parse_char    ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( unsigned int &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 64 of file ParseAtomic.cpp.

    { return parse_integer ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< std::pair< double, double > > &  result,
const std::string &  input 
)

parse the std::vector<std::pair<double,double> > value

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::PairGrammar
Gaudi::Parsers::RealGrammar
Parameters:
result(output) vector with pairs of doubles
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 60 of file ParseVectorsVector.cpp.

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

parse the std::vector<char> value

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::CharGrammar
Parameters:
result(output) vector with char elements
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 35 of file ParseVectorsChar.cpp.

    { return parse_char_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< float > &  result,
const std::string &  input 
)
See also:
parse( std::vector<double>& ,const std::string& );

Definition at line 40 of file ParseVectorsReal.cpp.

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

parse the std::vector<double> value

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::RealGrammar
Parameters:
result(output) vector with double elements
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 44 of file ParseVectorsReal.cpp.

    { return parse_real_vector    ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< unsigned long long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 68 of file ParseVectorsInteger.cpp.

    { return parse_integer_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( double &  result,
const std::string &  input 
)

parse the double value

See also:
Gaudi::Parsers::RealGrammar
Parameters:
result(output) double result
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 98 of file ParseAtomic.cpp.

    { return parse_real ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< unsigned long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 60 of file ParseVectorsInteger.cpp.

    { return parse_integer_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< long > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 56 of file ParseVectorsInteger.cpp.

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

Definition at line 52 of file ParseVectorsInteger.cpp.

    { return parse_integer_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< unsigned short > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 44 of file ParseVectorsInteger.cpp.

    { return parse_integer_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< short > &  result,
const std::string &  input 
)
See also:
parse( std::vector<int>& ,const std::string& );

Definition at line 40 of file ParseVectorsInteger.cpp.

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

parse the std::vector<int> value

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::IntGrammar
Parameters:
result(output) vector with integer elements
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 48 of file ParseVectorsInteger.cpp.

    { return parse_integer_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< signed char > &  result,
const std::string &  input 
)
See also:
parse( std::vector<char>& ,const std::string& );

Definition at line 43 of file ParseVectorsChar.cpp.

    { return parse_char_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( signed char &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser(char&,std::string&)

Definition at line 48 of file ParseAtomic.cpp.

    { return parse_char    ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 68 of file ParseAtomic.cpp.

    { return parse_integer ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( std::vector< unsigned char > &  result,
const std::string &  input 
)
See also:
parse( std::vector<char>& ,const std::string& );

Definition at line 39 of file ParseVectorsChar.cpp.

    { return parse_char_vector ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( unsigned long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 72 of file ParseAtomic.cpp.

    { return parse_integer ( result , input ) ; }
template<class TYPE , std::size_t N>
StatusCode Gaudi::Parsers::parse ( boost::array< TYPE, N > &  result,
const std::string &  input 
)

parse class boost::array from the string

Parameters:
result(OUTPUT) the actual result
input(INPUT) the input string
Returns:
status code
Author:
Vanya BELYAEV Ivan.Belyaev@nikhef.nl
Date:
2009-09-16

Definition at line 84 of file BoostArrayAsProperty.h.

    {
      typedef std::vector<TYPE> _Vct ;
      // create the temporaty vector
      _Vct tmp ; 
      // parse the string 
      StatusCode sc = parse ( tmp , input ) ; 
      if ( sc.isFailure () ) { return sc ; }                         // RETURN 
      if ( N != tmp.size() ) 
      { return StatusCode ( StatusCode::FAILURE , true ) ; }         // RETURN   
      // copy vector into array 
      std::copy ( tmp.begin() , tmp.end() , result.begin() ) ;
      //
      return StatusCode::SUCCESS ;
    }
StatusCode Gaudi::Parsers::parse ( float &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( double&, const std::string& )

Definition at line 94 of file ParseAtomic.cpp.

    { return parse_real ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( short &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 52 of file ParseAtomic.cpp.

    { return parse_integer ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( unsigned long long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 80 of file ParseAtomic.cpp.

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

parse the int value

See also:
Gaudi::Parsers::IntGrammar
Parameters:
result(output) integer result
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-14

Definition at line 60 of file ParseAtomic.cpp.

    { return parse_integer ( result , input ) ; }
StatusCode Gaudi::Parsers::parse ( long long &  result,
const std::string &  input 
)
See also:
Gaudi::Parsers::parser( int&, const std::string& )

Definition at line 76 of file ParseAtomic.cpp.

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

parse the char value

See also:
Gaudi::Parsers::CharGrammar
Parameters:
result(output) boolean result
input(input) the string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 40 of file ParseAtomic.cpp.

    { return parse_char    ( result , input ) ; }
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 138 of file Parsers.icpp.

    {
      CharGrammar<CharT> g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1]).full;
    }
template<typename CharT >
StatusCode Gaudi::Parsers::parse_char_vector ( std::vector< CharT > &  result,
const string &  input 
) [inline]

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

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::CharGrammar
Gaudi::Parsers::SkipperGrammar
Parameters:
result(output) parsing result
input(input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 165 of file Parsers.icpp.

    {
      VectorGrammar<CharGrammar<CharT> > g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
template<typename IntegerT >
StatusCode Gaudi::Parsers::parse_integer ( IntegerT &  result,
const string &  input 
) [inline]

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

See also:
Gaudi::Parsers::IntGrammar
Parameters:
result(output) parsing result
input(input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 86 of file Parsers.icpp.

    {
      IntGrammar<IntegerT> g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1]).full;
    }
template<typename IntegerT >
StatusCode Gaudi::Parsers::parse_integer_vector ( std::vector< IntegerT > &  result,
const string &  input 
) [inline]

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

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::IntGrammar
Gaudi::Parsers::SkipperGrammar
Parameters:
result(output) parsing result
input(input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 113 of file Parsers.icpp.

    {
      VectorGrammar<IntGrammar<IntegerT> > g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
template<typename RealT >
StatusCode Gaudi::Parsers::parse_real ( RealT &  result,
const string &  input 
) [inline]

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

See also:
Gaudi::Parsers::RealGrammar
Parameters:
result(output) parsing result
input(input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 189 of file Parsers.icpp.

    {
      RealGrammar<RealT> g;
      return parse
        ( createIterator(input),
          IteratorT(),
          g[var(result)=arg1],
          SkipperGrammar()).full;
    }
template<typename RealT >
StatusCode Gaudi::Parsers::parse_real_vector ( std::vector< RealT > &  result,
const string &  input 
)

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

See also:
Gaudi::Parsers::VectorGrammar
Gaudi::Parsers::RealGrammar
Gaudi::Parsers::SkipperGrammar
Parameters:
result(output) parsing result
input(input) string to be parsed
Returns:
status code
Author:
Alexander MAZUROV Alexander.Mazurov@gmail.com
Vanya BELYAEV ibelyaev@physics.syr.edu
Date:
2006-05-12

Definition at line 217 of file Parsers.icpp.

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

Definition at line 87 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 91 of file ParserActions.h.

                                                                              {
      return PushBackRefImpl<T,IT> (x,it);
    }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Generated at Tue May 10 2011 18:55:27 for Gaudi Framework, version v22r2 by Doxygen version 1.7.2 written by Dimitri van Heesch, © 1997-2004