Gaudi::Parsers Namespace Reference

Namespaces
	Utils

Classes
struct	BoolGrammar
class	Catalog
struct	CharGrammar
class	EdgeGrammar
struct	FileGrammar
struct	Grammar_
struct	Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >
struct	Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper >
struct	Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper >
struct	Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper >
struct	Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper >
struct	Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >
struct	Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper >
struct	Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper >
struct	Grammar_< Iterator, std::tuple< Args... >, Skipper >
struct	Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper >
struct	Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_floating_point< T > >::type >
struct	Grammar_< Iterator, T, Skipper, typename boost::enable_if< boost::is_integral< T > >::type >
class	H1Grammar
class	H2Grammar
struct	Histo1DGrammar
struct	IdentifierGrammar
class	IncludedFiles
struct	IntGrammar
struct	KeyValueGrammar
struct	MapGrammar
class	Messages
class	Node
class	NodeOperations
struct	PairGrammar
struct	Pnt3DGrammar
struct	Pnt4DGrammar
class	Position
class	PositionalPropertyValueException
class	PragmaOptions
class	Property
class	PropertyName
class	PropertyValue
class	PropertyValueException
struct	RealGrammar
struct	SkipperGrammar
struct	StringGrammar
struct	tuple_get_first_type
struct	tuple_get_first_type< std::tuple< T, Ts... > >
struct	tuple_remove_first_type
struct	tuple_remove_first_type< std::tuple< T, Ts... > >
struct	TupleGrammar
struct	TupleInnerGrammar
struct	TupleInnerGrammar< Iterator, TupleT, 1, Skipper >
class	Units
struct	UnitsGrammar
struct	VectorGrammar

Typedefs
typedef std::string::const_iterator	DefaultIterator
typedef enc::space_type	DefaultSkipper
typedef std::string::const_iterator	IteratorT
typedef SkipperGrammar< IteratorT >	Skipper

Functions
template<typename K , typename V >
StatusCode	parse (GaudiUtils::HashMap< K, V > &result, const std::string &input)
	Basic parser for the types of HashMap used in DODBasicMapper. More...
bool	ReadOptions (const std::string &filename, const std::string &search_path, Messages *messages, Catalog *catalog, Units *units, PragmaOptions *pragma, Node *root)
	Parse and analyze filename, save all messages and properties. More...
std::ostream &	operator<< (std::ostream &o, const Catalog &c)
	printout operator More...
bool	Parse (const std::string &filename, const std::string &search_path, IncludedFiles *included, Messages *messages, Node *root)
bool	Parse (const Position &from, const std::string &filename, const std::string &search_path, IncludedFiles *included, Messages *messages, Node *root)
bool	ParseUnits (const Position &from, const std::string &filename, const std::string &search_path, IncludedFiles *included, Messages *messages, Node *root)
template<class TYPE , std::size_t N>
StatusCode	parse (boost::array< TYPE, N > &result, const std::string &input)
	parse class boost::array from the string More...
StatusCode	parse (DataObjectHandleBase &, const std::string &)
StatusCode	parse (DataObjID &, const std::string &)
StatusCode	parse (DataObjIDColl &, const std::string &)
	REGISTER_GRAMMAR (std::string, StringGrammar)
	REGISTER_GRAMMAR (Gaudi::StringKey, StringGrammar)
	REGISTER_GRAMMAR (char, CharGrammar)
	REGISTER_GRAMMAR (bool, BoolGrammar)
	REGISTER_GRAMMAR (Gaudi::Histo1DDef, Histo1DGrammar)
GAUDI_API StatusCode	parse (std::vector< std::pair< double, double > > &result, const std::string &input)
	parse the bool value More...
GAUDI_API StatusCode	parse (std::vector< std::pair< int, int > > &result, const std::string &input)
	parse the std::vector<std::pair<int,int> > value More...
GAUDI_API StatusCode	parse (std::vector< std::vector< std::string > > &result, const std::string &input)
	parse the std::vector<std::vector<std::string> > value More...
GAUDI_API StatusCode	parse (std::vector< std::vector< double > > &result, const std::string &input)
	parse the std::vector<std::vector<double> > value More...
GAUDI_API StatusCode	parse (std::map< int, int > &result, const std::string &input)
	parse the std::map<int , int> value More...
GAUDI_API StatusCode	parse (std::map< int, double > &result, const std::string &input)
	parse the std::map<int , double> value More...
GAUDI_API StatusCode	parse (std::map< std::string, std::string > &result, const std::string &input)
	parse the std::map<std::string , std::string> value More...
GAUDI_API StatusCode	parse (std::map< std::string, int > &result, const std::string &input)
	parse the std::map<std::string , int> value More...
GAUDI_API StatusCode	parse (std::map< std::string, double > &result, const std::string &input)
	parse the std::map<std::string , double> value More...
GAUDI_API StatusCode	parse (std::map< std::string, std::vector< std::string > > &result, const std::string &input)
	parse the std::map<std::string , std::vector<std::string> > value More...
GAUDI_API StatusCode	parse (std::map< std::string, std::vector< int > > &result, const std::string &input)
	parse the std::map<std::string , std::vector<int> > value More...
GAUDI_API StatusCode	parse (std::map< std::string, std::vector< double > > &result, const std::string &input)
	parse the std::map<std::string , std::vector<double> > value More...
GAUDI_API StatusCode	parse (std::map< int, std::string > &result, const std::string &input)
	parse the std::map<int,std::string> > objects More...
GAUDI_API StatusCode	parse (std::map< unsigned int, std::string > &result, const std::string &input)
	parse the std::map<unsigned int,std::string> > objects More...
GAUDI_API StatusCode	parse (std::map< std::string, unsigned int > &result, const std::string &input)
	parse the std::map<unsigned int,std::string> > objects More...
template<typename K , typename V , typename M >
GAUDI_API StatusCode	parse (GaudiUtils::Map< K, V, M > &result, const std::string &input)
	parse the GaudiUtils::Map<K, V, M> objects More...
GAUDI_API StatusCode	parse (std::string &name, std::string &value, const std::string &input)
	parse the pair expression (map-component) " 'name' :value" More...
GAUDI_API StatusCode	parse (Gaudi::Histo1DDef &histo, const std::string &input)
	helper function, needed for implementation of "Histogram Property" More...
GAUDI_API StatusCode	parse (std::map< std::string, Gaudi::Histo1DDef > &histos, const std::string &input)
	helper function, needed for implementation of "Histogram Property" More...
GAUDI_API StatusCode	parse (std::map< std::string, std::pair< double, double > > &params, const std::string &input)
	helper function, needed for implementation of map of pairs It is very useful construction for monitoring to represent the value and error or the allowed range for some parameter More...
template<class T , unsigned int N>
StatusCode	parse (T(&result)[N], const std::string &input)
	parser function for C-arrays More...
template<unsigned int N>
StatusCode	parse (char(&result)[N], const std::string &input)
	parser function for C-strings More...
template<typename ResultT >
StatusCode	parse_ (ResultT &result, const std::string &input)
template<>
StatusCode	parse_ (std::string &result, const std::string &input)
template<typename ResultT >
StatusCode	parse (ResultT &result, const std::string &input)
template<class TYPE , std::size_t N>
StatusCode	parse (std::array< TYPE, N > &result, const std::string &input)
	parse class std::array from the string More...
GAUDI_API StatusCode	parse (Gaudi::StringKey &result, const std::string &input)
	parse the key from the string More...
GAUDI_API StatusCode	parse (std::vector< Gaudi::StringKey > &result, const std::string &input)
	parse the vector of keys from the string More...
template<class SCALAR , unsigned int N>
StatusCode	parse (ROOT::Math::SVector< SCALAR, N > &result, const std::string &input)
	parse SVector More...
GAUDI_API StatusCode	parse (GaudiUtils::VectorMap< std::string, double > &result, const std::string &input)
	parse the key from the string More...
GAUDI_API StatusCode	parse (GaudiUtils::VectorMap< Gaudi::StringKey, double > &result, const std::string &input)
	parse the vector of keys from the string More...
GAUDI_API StatusCode	parse (Gaudi::XYZPoint &result, const std::string &input)
	parse 3D-point More...
GAUDI_API StatusCode	parse (Gaudi::XYZVector &result, const std::string &input)
	parse 3D-vector More...
GAUDI_API StatusCode	parse (Gaudi::LorentzVector &result, const std::string &input)
	parse LorentzVector More...
GAUDI_API StatusCode	parse (std::vector< Gaudi::XYZPoint > &result, const std::string &input)
	parse the vector of points More...
GAUDI_API StatusCode	parse (std::vector< Gaudi::XYZVector > &result, const std::string &input)
	parse the vector of vectors More...
GAUDI_API StatusCode	parse (std::vector< Gaudi::LorentzVector > &result, const std::string &input)
	parse the vector of vectors More...
template<typename T1 , typename T2 >
StatusCode	parse_ (ROOT::Math::PositionVector3D< T1, T2 > &result, const std::string &input)
GAUDI_API StatusCode	parse (TH1D &result, const std::string &input)
	parse ROOT histogram from text representation More...
GAUDI_API StatusCode	parse (TH2D &result, const std::string &input)
	parse ROOT histogram from text representation More...
GAUDI_API StatusCode	parse (TH1F &result, const std::string &input)
	parse ROOT histogram from text representation More...
GAUDI_API StatusCode	parse (TH2F &result, const std::string &input)
	parse ROOT histogram from text representation More...
GAUDI_API StatusCode	parse (AIDA::IHistogram1D &result, const std::string &input)
	parse AIDA histogram from text representation More...
GAUDI_API StatusCode	parse (AIDA::IHistogram2D &result, const std::string &input)
	parse AIDA histogram from text representation More...
GAUDI_API StatusCode	parse (TH1D *&result, const std::string &input)
	parse ROOT histogram from text representation More...
GAUDI_API StatusCode	parse (TH2D *&result, const std::string &input)
	parse ROOT histogram from text representation More...
	REGISTER_GRAMMAR (Edges, EdgeGrammar)
	REGISTER_GRAMMAR (H1, H1Grammar)
	REGISTER_GRAMMAR (H2, H2Grammar)

Typedef Documentation

typedef std::string::const_iterator Gaudi::Parsers::DefaultIterator

Definition at line 54 of file GrammarsV2.h.

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

Definition at line 55 of file GrammarsV2.h.

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

Definition at line 26 of file ParsersFactory.h.

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

Definition at line 28 of file ParsersFactory.h.

Function Documentation

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

inline

printout operator

Definition at line 56 of file Catalog.h.

                                                                {
   return c.fillStream(o);
 }

template<typename K , typename V >

StatusCode Gaudi::Parsers::parse	(	GaudiUtils::HashMap< K, V > &	result,
		const std::string &	input
	)

Basic parser for the types of HashMap used in DODBasicMapper.

Delegates to the parser of map<string,string>.

Definition at line 11 of file DODBasicMapper.cpp.

                                                                              {
      std::map<std::string, std::string> tmp;
      StatusCode sc = parse(tmp, input);
      if (sc.isSuccess()) {
        result.clear();
        result.insert(tmp.begin(), tmp.end());
      }
      return sc;
    }

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

Definition at line 125 of file Parser.cpp.

                                        {
    return Parse(Position(),  filename, search_path, included, messages,
            root);
}

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

Definition at line 132 of file Parser.cpp.

                                        {
    using Grammar = FileGrammar<Iterator,SkipperGrammar<Iterator>>;
    return ParseFile<Grammar>(from, filename, search_path, included,
            messages, root);
}

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

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 340 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  //
  auto h1 = _parse_1D<TH1D> ( input , name ) ;
  if ( h1 )
  {
    result.Reset() ;
    h1->Copy ( result )  ;                            // ASSIGN
    result.SetName ( name.c_str () ) ;
    return StatusCode::SUCCESS ;                           // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find('<') )
         ? Gaudi::Utils::Histos::fromXml ( result , input )
         : StatusCode::FAILURE ;
}

template<class SCALAR , unsigned int N>

StatusCode Gaudi::Parsers::parse	(	ROOT::Math::SVector< SCALAR, N > &	result,
		const std::string &	input
	)

parse SVector

Parameters

result	(output) the parsed vector
input	(input) the input string

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 45 of file SVectorAsProperty.h.

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

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 394 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  auto h2 = _parse_2D<TH2D> ( input , name ) ;
  if ( h2 )
  {
    result.Reset() ;
    h2->Copy ( result )  ;                            // ASSIGN
    result.SetName ( name.c_str () ) ;
    return StatusCode::SUCCESS ;                           // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find('<') )
         ? Gaudi::Utils::Histos::fromXml ( result , input )
         : StatusCode::FAILURE ;
}

template<typename ResultT >

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

inline

Definition at line 51 of file ParsersFactory.h.

                                                    {
      
      return parse_(result, input);
    }

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

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 367 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  //
  auto h1 = _parse_1D<TH1F> ( input , name ) ;
  if ( h1 )
  {
    result.Reset() ;
    h1->Copy ( result )  ;                            // ASSIGN
    result.SetName ( name.c_str () ) ;
    return StatusCode::SUCCESS ;                           // RETURN
  }
  //
  // XML-like text?
  return  ( std::string::npos != input.find('<') )
          ? Gaudi::Utils::Histos::fromXml ( result , input )
          :  StatusCode::FAILURE ;
}

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

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 420 of file HistoParsers.cpp.

{
  // 1) check the parsing
  std::string name ;
  auto h2 = _parse_2D<TH2F> ( input , name ) ;
  if ( h2 )
  {
    result.Reset() ;
    h2->Copy ( result )  ;                            // ASSIGN
    result.SetName ( name.c_str () ) ;
    return StatusCode::SUCCESS ;                           // RETURN
  }
  //
  // XML-like text?
  if ( std::string::npos != input.find('<') )
  { return Gaudi::Utils::Histos::fromXml ( result , input ) ; }
  //
  return StatusCode::FAILURE ;
}

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

parse 3D-point

Valid representations of 3D-point:

- a'la python tuple with 3 elements ("canonical")
- a'la python list with 3 elements 
- tuple or list with named ordered fields 

" (1,2,3) " 
" [1,2,3] " 
" [ x : 1, 2, Z:3 ] " 
" [ pX : 1 , PY : 2, 3] " 

Valid keys for names fields:

"x", "X" , "pX" , "Px" , "PX "
"y", "Y" , "pY" , "Py" , "PY "
"z", "Z" , "pZ" , "Pz" , "PZ "

Attention

Named fields must be ordered (x,y,z)

Parameters

result	(output) the parsed point
input	(input) the input string

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 49 of file ParsersVct.cpp.

                                             {
    return parse_(result, input);
  }

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

parse AIDA histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 501 of file HistoParsers.cpp.

{
  // 1) convert to ROOT
  auto root = Gaudi::Utils::Aida2ROOT::aida2root ( &result ) ;
  // 2) read ROOT histogram
  return root ? parse ( *root , input ) : StatusCode::FAILURE ; 
}

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

parse AIDA histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 516 of file HistoParsers.cpp.

{
  // 1) convert to ROOT
  auto root = Gaudi::Utils::Aida2ROOT::aida2root ( &result ) ;
  // 2) read ROOT histogram
  return root ? parse ( *root , input ) : StatusCode::FAILURE ; 
}

template<class TYPE , std::size_t N>

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

parse class std::array from the string

Parameters

result	(OUTPUT) the actual result
input	(INPUT) the input string

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-16

Definition at line 81 of file StdArrayAsProperty.h.

    {
      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 ;
    }

template<class TYPE , std::size_t N>

StatusCode Gaudi::Parsers::parse	(	boost::array< TYPE, N > &	result,
		const std::string &	input
	)

parse class boost::array from the string

Parameters

result	(OUTPUT) the actual result
input	(INPUT) the input string

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-16

Definition at line 82 of file BoostArrayAsProperty.h.

    {
      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	(	TH1D *&	result,
		const std::string &	input
	)

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 447 of file HistoParsers.cpp.

{
  if ( result ) { return parse ( *result , input ) ; } // RETURN

  // 1) check the parsing
  std::string name ;
  auto h1 = _parse_1D<TH1D>  ( input , name ) ;
  if ( h1 )
  {
    result = h1.release() ;
    result->SetName ( name.c_str() ) ;
    return StatusCode::SUCCESS ;                           // RETURN
  }
  //
  // XML-like text?
  return  ( std::string::npos != input.find('<') )
          ? Gaudi::Utils::Histos::fromXml ( result , input )
          : StatusCode::FAILURE ;
}

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

Definition at line 14 of file DataObjectHandleProperty.cpp.

    {
      std::string prop;
      auto sc = Gaudi::Parsers::parse( prop, s );
      if ( sc ) v.setKey( DataObjID( s ) );
      return sc;
    }

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

parse ROOT histogram from text representation

Parameters

result	(OUTPUT) the histogram
input	(INPUT) the input to be parsed

Returns

status code

Definition at line 474 of file HistoParsers.cpp.

{
  if ( result ) { return parse ( *result , input ) ; } // RETURN

  // 1) check the parsing
  std::string name ;
  auto h2 = _parse_2D<TH2D>  ( input , name ) ;
  if ( h2 )
  {
    result = h2.release() ;
    result->SetName ( name.c_str() ) ;
    return StatusCode::SUCCESS ;                           // RETURN
  }
  //
  // XML-like text?
  return ( std::string::npos != input.find('<') ) 
         ? Gaudi::Utils::Histos::fromXml ( result , input )
         : StatusCode::FAILURE ;
}

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

parse 3D-vector

Valid representations of 3D-vector:

- a'la python tuple with 3 elements ("canonical")
- a'la python list with 3 elements 
- tuple or list with named ordered fields 

" (1,2,3) " 
" [1,2,3] " 
" [ x : 1, 2, Z:3 ] " 
" [ pX : 1 , PY : 2, 3] " 

Valid keys for names fields:

"x", "X" , "pX" , "Px" , "PX "
"y", "Y" , "pY" , "Py" , "PY "
"z", "Z" , "pZ" , "Pz" , "PZ "

Attention

Named fields must be ordered (x,y,z)

Parameters

result	(output) the parsed vector
input	(input) the input string

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 63 of file ParsersVct.cpp.

  {

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

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

Definition at line 19 of file DataObjIDProperty.cpp.

                                            {
      // default values
      StatusCode sc(StatusCode::FAILURE);
      std::string prop;
      sc = Gaudi::Parsers::parse(prop, s);

      if (sc.isSuccess()) {
        //split the string in 1 or 2 words:
        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
        boost::char_separator<char> sep("(), ");
        tokenizer tokens(prop, sep);
        int nToks(distance(tokens.begin(), tokens.end()));
        auto it = tokens.begin();

        if (nToks == 1) {
          // Gaudi style /path/to/object
          std::string k = *it;
          boost::erase_all(k,"'");
          v = DataObjID( k );

        } else if (nToks == 2) {
          // ATLAS style (clid, 'key') or ('ClassName', 'key')
          CLID c(0);
          std::string cn(*it);
          DataObjID id;

          try {
            c = std::stoi(*it);
          } catch (const std::invalid_argument& /*e*/)  {
            // not a number
            boost::erase_all(cn,"'");
            c = 0;
          }

          ++it;
          std::string k = *it;
          boost::erase_all(k,"'");
          ++it;

          if ( c != 0) {
            v = DataObjID(c,k);
          } else {
            v = DataObjID(cn,k);
          }
        } else {
          std::cerr << "Unable to instantiate a DataObjID from a Property " << s
                    << " :: Format is bad" << std::endl;
          sc = StatusCode::FAILURE;
          return sc;
        }

      }
      return sc;
    }

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

Definition at line 77 of file DataObjIDProperty.cpp.

                                                  {
      // default values
      StatusCode sc(StatusCode::FAILURE);
      std::string prop;
      sc = Gaudi::Parsers::parse(prop, s);

      if (sc.isSuccess()) {

        // Reset Collection
        v.clear();

        bool isGaudi(true);

        // Gaudi style [ '/path/to/data', '/other/data' ] or
        // ATLAS style [ ('ClassName', 'key') , (ClassID, 'key2') ]
        if (s.find("(") != std::string::npos) {
          isGaudi = false;
        }

        // split the string in 1 or 2 words:
        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
        boost::char_separator<char> sep("[](), ");
        tokenizer tokens(prop, sep);
        auto it = tokens.begin();

        CLID c(0);
        std::string cn;

        while (it != tokens.end()) {

          if (isGaudi) {

            std::string k = *it;
            boost::erase_all(k, "'");
            v.emplace( DataObjID( k ) );
            ++it;

          } else {

            try {
              c = std::stoi(*it);
            } catch (const std::invalid_argument& /*e*/)  {
              // class name, not ClassID
              cn = *it;
              boost::erase_all(cn,"'");
              c = 0;
            }

            ++it;
            std::string k = *it;
            boost::erase_all(k,"'");
            ++it;

            if ( c != 0) {
              v.emplace( DataObjID(c,k) );
            } else {
              v.emplace( DataObjID(cn,k) );
            }
          }
        }
      }
      return sc;
    }

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

parse LorentzVector

Valid representations of Lorenzt vector

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

" (1,2,3,4) "     
" (1,2,3;4) "

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

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

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

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

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

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

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

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

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

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

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

Valid keys for names fields:

"x", "X" , "pX" , "Px" , "PX "
"y", "Y" , "pY" , "Py" , "PY "
"z", "Z" , "pZ" , "Pz" , "PZ "
"t", "T" , "e"  , "E" 

Attention

Named fields must be ordered (x,y,z)

Parameters

result	(output) the parsed lorentz vector
input	(input) the input string

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 74 of file ParsersVct.cpp.

                                                                       {
    return parse_(result, input);
  }

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

parse the vector of points

Parameters

resut	(OUTPUT) the parser vector
input	(INPIUT) the string to be parsed

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 87 of file ParsersVct.cpp.

  {
    result.clear() ;
    return parse_(result, input);
  }

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

parse the vector of vectors

Parameters

resut	(OUTPUT) the parser vector
input	(INPIUT) the string to be parsed

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 102 of file ParsersVct.cpp.

  {
    result.clear() ;
    return parse_(result, input);
  }

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

parse the vector of vectors

Parameters

resut	(OUTPUT) the parser vector
input	(INPIUT) the string to be parsed

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-05

Definition at line 119 of file ParsersVct.cpp.

  {
    return parse_(result, input);
  }

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

parse the bool value

See also

Gaudi::Parsers::BoolGrammar

Parameters

result	(output) boolean result
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-12parse the char value

See also

Gaudi::Parsers::CharGrammar

Parameters

result	(output) boolean result
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-12

See also

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

Gaudi::Parsers::parser(char&,std::string&) parse the int value

Gaudi::Parsers::IntGrammar

Parameters

result	(output) integer result
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

See also

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

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

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

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

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

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

Gaudi::Parsers::parser( int&, const std::string& ) parse the double value

Gaudi::Parsers::RealGrammar

Parameters

result	(output) double result
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

See also

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

Gaudi::Parsers::parser( double&, const std::string& ) parse the std::string value

Gaudi::Parsers::StringGrammar

Parameters

result	(output) string result
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14parse the std::pair<double,double> value

See also

Gaudi::Parsers::PairGrammar

Gaudi::Parsers::RealGrammar

Parameters

result	(output) pair of doubles
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14parse the std::pair<int,int> value

See also

Gaudi::Parsers::PairGrammar

Gaudi::Parsers::IntGrammar

Parameters

result	(output) pair of integers
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14parse the std::vector<std::pair<double,double> > value

See also

Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::PairGrammar

Gaudi::Parsers::RealGrammar

Parameters

result	(output) vector with pairs of doubles
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 11 of file ParsersStandardMisc1.cpp.

                                                                                                  {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::PairGrammar

Gaudi::Parsers::IntGrammar

Parameters

result	(output) vector with pairs of int
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 15 of file ParsersStandardMisc1.cpp.

                                                                                            {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::StringGrammar

Parameters

result	(output) vector with vectors of strings
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 19 of file ParsersStandardMisc1.cpp.

                                                                                               {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::RealGrammar

Parameters

result	(output) vector with vectors of doubles
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 3 of file ParsersStandardMisc2.cpp.

                                                                                            {
    return Gaudi::Parsers::parse_(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
input	the input string

Returns

status code

Definition at line 80 of file StringKey.cpp.

{
  std::string _result ;
  StatusCode sc = parse ( _result , input ) ;
  result = Gaudi::StringKey ( _result ) ;
  return sc ;
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::IntGrammar

Parameters

result	(output) map with integer key and double value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 7 of file ParsersStandardMisc2.cpp.

                                                                               {
    return Gaudi::Parsers::parse_(result, input);
}

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

parse the vector of keys from the string

See also

Gaudi::Parsers

Gaudi::Parsers::parse

Gaudi::StringKey

Attention

: this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns

status code

Definition at line 100 of file StringKey.cpp.

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::IntGrammar

Gaudi::Parsers::RealGrammar

Parameters

result	(output) map with integer key and double value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 11 of file ParsersStandardMisc2.cpp.

                                                                                  {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::StringGrammar

Parameters

result	(output) map with string key and value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 15 of file ParsersStandardMisc2.cpp.

                                                                                           {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::StringGrammar

Gaudi::Parsers::IntGrammar

Parameters

result	(output) map with string key and integer value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 3 of file ParsersStandardMisc3.cpp.

                                                                                     {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::StringGrammar

Gaudi::Parsers::RealGrammar

Parameters

result	(output) map with string key and integer value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 11 of file ParsersStandardMisc3.cpp.

                                                                                        {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::StringGrammar

Gaudi::Parsers::VectorGrammar

Parameters

result	(output) map with string value and vector of strings as value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 15 of file ParsersStandardMisc3.cpp.

                                                                                                       {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::StringGrammar

Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::IntGrammar

Parameters

result	(output) map with string value and vector of integers as value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 3 of file ParsersStandardMisc4.cpp.

                                                                                                 {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Gaudi::Parsers::StringGrammar

Gaudi::Parsers::VectorGrammar

Gaudi::Parsers::RealGrammar

Parameters

result	(output) map with string value and vector of doubles as value
input	(input) the string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-14

Definition at line 7 of file ParsersStandardMisc4.cpp.

                                                                                                    {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Author

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date

2007-12-06

Definition at line 11 of file ParsersStandardMisc4.cpp.

                                                                                     {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Author

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date

2007-12-06

Definition at line 3 of file ParsersStandardMisc5.cpp.

                                                                                              {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

See also

Gaudi::Parsers::MapGrammar

Definition at line 7 of file ParsersStandardMisc3.cpp.

                                                                                              {
    return Gaudi::Parsers::parse_(result, input);
}

template<typename K , typename V , typename M >

GAUDI_API StatusCode Gaudi::Parsers::parse	(	GaudiUtils::Map< K, V, M > &	result,
		const std::string &	input
	)

parse the GaudiUtils::Map<K, V, M> objects

See also

Gaudi::Parsers::MapGrammar

Definition at line 454 of file Parsers.h.

                                         {
      return parse((M&)result, input);
    }

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

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

const std::string input = "'PackageName':GaudiKernel" ;
std::string name  ;
std::string value ;
StatusCode sc = Gaudi::Parsers::parse ( name , value , input ) ;
if ( sc.isFailure() ) { ... }
std::cout <<  "\tParsed name  is " << name
          <<  "\tParsed value is " << value << std::endl

Parameters

name	(output) the parsed name of the component, defined as 'name' or "name" before the column symbol ":", the leading and trailing blans are omitted
value	(output) the parsed value of the component, defined as everything after the column symbol ":" till the end of the string
input	(input) string to be parsed

Returns

status code

Author

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Date

2006-05-12

Definition at line 7 of file ParsersStandardMisc5.cpp.

                             {
  Skipper skipper;
  KeyValueGrammar<IteratorT, Skipper> g;
  KeyValueGrammar<IteratorT, Skipper>::ResultT result;
  auto iter = input.begin();
  bool parse_result = qi::phrase_parse(iter, input.end(), g, skipper,
      result) && (iter==input.end());
  if (parse_result) {
    name = result.first;
    value = result.second;
  }
  return parse_result;
}

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

helper function, needed for implementation of "Histogram Property"

Parameters

histo	the histogram description (output)
input	the string to be parsed

Returns

status code

Author

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date

2007-09-17

Definition at line 8 of file ParsersHistograms.cpp.

                                {
    return Gaudi::Parsers::parse_(result, input);
}

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

helper function, needed for implementation of "Histogram Property"

Parameters

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

Returns

status code

Author

Vanya BELYAEV ibely.nosp@m.aev@.nosp@m.physi.nosp@m.cs.s.nosp@m.yr.ed.nosp@m.u

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date

2007-09-17

Definition at line 13 of file ParsersHistograms.cpp.

                                {
    return Gaudi::Parsers::parse_(result, input);
}

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

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

Parameters

params	the map of pair
input	the string to be parsed

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Alexander MAZUROV Alexa.nosp@m.nder.nosp@m..Mazu.nosp@m.rov@.nosp@m.gmail.nosp@m..com

Date

2009-05-19

Definition at line 22 of file ParsersStandardMisc5.cpp.

                                                                                                          {
    return Gaudi::Parsers::parse_(result, input);
}

template<class T , unsigned int N>

StatusCode Gaudi::Parsers::parse	(	T(&)	result[N],
		const std::string &	input
	)

parser function for C-arrays

Parameters

params	C-array
input	the string to be parsed

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-15

Definition at line 537 of file Parsers.h.

    {
      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
    }

template<unsigned int N>

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

parser function for C-strings

Parameters

params	C-string
input	the string to be parsed

Returns

status code

Author

Vanya BELYAEV Ivan..nosp@m.Bely.nosp@m.aev@n.nosp@m.ikhe.nosp@m.f.nl

Date

2009-09-15

Definition at line 559 of file Parsers.h.

    {
      // 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
    }

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

parse the key from the string

See also

Gaudi::Parsers

Gaudi::Parsers::parse

Gaudi::VectorMap

Attention

: this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns

status code

Definition at line 10 of file ParsersCollections.cpp.

                                {
    return Gaudi::Parsers::parse_(result, input);
}

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

parse the vector of keys from the string

See also

Gaudi::Parsers

Gaudi::Parsers::parse

Gaudi::VectorMap

Gaudi::StringKey

Attention

: this function is needed to use it as property

Parameters

result	(OUTPUT) the parsing result
input	the input string

Returns

status code

Definition at line 16 of file ParsersCollections.cpp.

                                {
    return Gaudi::Parsers::parse_(result, input);
}

template<typename ResultT >

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

inline

Definition at line 31 of file ParsersFactory.h.

                                                   {
      Skipper skipper;
      typename Grammar_<IteratorT, ResultT, Skipper>::Grammar g;
      IteratorT iter = input.begin(), end = input.end();
      return qi::phrase_parse( iter, end, g, skipper , result) && (iter==end);
    }

template<typename T1 , typename T2 >

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

inline

Definition at line 37 of file ParsersVct.cpp.

                                                                         {
    Skipper skipper;
    typename Grammar_<IteratorT, ROOT::Math::PositionVector3D<T1,T2>, Skipper >::Grammar g;
    IteratorT iter = input.begin(), end = input.end();
    if (qi::phrase_parse( iter, end, g, skipper, result)){
      return StatusCode::SUCCESS;
    }
    //@attention always
    return true;
  }

template<>

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

inline

Definition at line 39 of file ParsersFactory.h.

                                                     {
      Skipper skipper;
      Grammar_<IteratorT, std::string, Skipper>::Grammar g;
      IteratorT iter = input.begin(), end = input.end();
      if (!(qi::phrase_parse( iter, end, g, skipper, result) && (iter==end))){
        result = input;
      }
      //@attention always
      return true;
    }

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

Definition at line 142 of file Parser.cpp.

                                        {
    using Grammar = UnitsGrammar<Iterator,SkipperGrammar<Iterator>>;
    return ParseFile<Grammar>(from, filename, search_path, included,
            messages, root);
}

bool Gaudi::Parsers::ReadOptions	(	const std::string &	filename,
		const std::string &	search_path,
		Messages *	messages,
		Catalog *	catalog,
		Units *	units,
		PragmaOptions *	pragma,
		Node *	root
	)

Parse and analyze filename, save all messages and properties.

Also output AST tree (http://en.wikipedia.org/wiki/Abstract_syntax_tree). Returns true if there were no errors during analysis.

Definition at line 416 of file Analyzer.cpp.

                                                         {
  // Extract Path
  IncludedFiles included;
  bool result = Parse(filename, search_path, &included, messages, root);
  if (!result) return false;

  bool result1 = Analyze(root, search_path, &included, messages, catalog, units,
      pragma);
  bool result2 = Unreference(*catalog, messages);
  return result1 && result2;
}

Gaudi::Parsers::REGISTER_GRAMMAR	(	Edges	,
		EdgeGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	std::string	,
		StringGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	Gaudi::StringKey	,
		StringGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	char	,
		CharGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	bool	,
		BoolGrammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	H1	,
		H1Grammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	H2	,
		H2Grammar
	)

Gaudi::Parsers::REGISTER_GRAMMAR	(	Gaudi::Histo1DDef	,
		Histo1DGrammar
	)