The Gaudi Framework  master (42b00024)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Grammars.h
Go to the documentation of this file.
1 /***********************************************************************************\
2 * (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
3 * *
4 * This software is distributed under the terms of the Apache version 2 licence, *
5 * copied verbatim in the file "LICENSE". *
6 * *
7 * In applying this licence, CERN does not waive the privileges and immunities *
8 * granted to it by virtue of its status as an Intergovernmental Organization *
9 * or submit itself to any jurisdiction. *
10 \***********************************************************************************/
11 
12 // cppcheck-suppress-file useInitializationList; for consistency
13 
14 #pragma once
15 
16 #ifdef __GNUC__
17 # pragma GCC system_header
18 #endif
19 // ============================================================================
20 // Include files
21 // ============================================================================
22 // STD:
23 //==============================================================================
24 #include <list>
25 #include <map>
26 #include <set>
27 #include <string>
28 #include <tuple>
29 #include <type_traits>
30 #include <unordered_map>
31 #include <unordered_set>
32 #include <vector>
33 //==============================================================================
34 // Boost:
35 //==============================================================================
36 #include <boost/fusion/include/std_pair.hpp>
37 #include <boost/fusion/include/unused.hpp>
38 #if ( BOOST_VERSION >= 187000 ) && ( BOOST_VERSION < 188000 )
39 # define BOOST_ALLOW_DEPRECATED_HEADERS
40 #endif
41 #include <boost/spirit/include/qi.hpp>
42 #undef BOOST_ALLOW_DEPRECATED_HEADERS
43 
44 #include <boost/phoenix/core.hpp>
45 #include <boost/phoenix/operator.hpp>
46 
47 #include <boost/spirit/repository/include/qi_confix.hpp>
48 //==============================================================================
49 // Gaudi:
50 //==============================================================================
51 #include <GaudiKernel/HashMap.h>
52 #include <GaudiKernel/HistoDef.h>
55 #include <GaudiKernel/StringKey.h>
56 #include <GaudiKernel/VectorMap.h>
57 //==============================================================================
58 namespace Gaudi {
59  namespace Parsers {
60  //==============================================================================
61  // Namespace aliases:
62  //==============================================================================
63  namespace sp = boost::spirit;
64  namespace ph = boost::phoenix;
65  namespace qi = sp::qi;
66  namespace enc = sp::ascii;
67  namespace rep = sp::repository;
68  //==============================================================================
69  // Grammars
70  //==============================================================================
71  typedef std::string::const_iterator DefaultIterator;
72  typedef enc::space_type DefaultSkipper;
73  //==============================================================================
74  template <typename Iterator, typename T, typename Skipper, class Enable = void>
75  struct Grammar_ {
76  /* READ THIS IF YOUR COMPILE BREAKS ON THE FOLLOWING LINE
77  *
78  * To users: You have to ask developers to implement parser for your type T
79  * To developer: You have to implement and register Grammar for type T
80  *
81  */
82  BOOST_MPL_ASSERT_MSG( false, GRAMMAR_FOR_TYPE_DOES_NOT_EXISTS, ( T ) );
83  };
84 
85 #define REGISTER_GRAMMAR( ResultType, GrammarName ) \
86  template <typename Iterator, typename Skipper> \
87  struct Grammar_<Iterator, ResultType, Skipper> { \
88  typedef GrammarName<Iterator, Skipper> Grammar; \
89  }
90  //==============================================================================
91  template <typename Iterator>
92  struct SkipperGrammar : qi::grammar<Iterator> {
94  comments = enc::space | rep::confix( "/*", "*/" )[*( qi::char_ - "*/" )] |
95  rep::confix( "//", ( sp::eol | sp::eoi ) )[*( qi::char_ - ( sp::eol | sp::eoi ) )];
96  }
97  qi::rule<Iterator> comments;
98  };
99  //==============================================================================
100  template <typename Iterator, typename Skipper>
101  struct StringGrammar : qi::grammar<Iterator, std::string(), qi::locals<char>, Skipper> {
102  //------------------------------------------------------------------------------
103  typedef std::string ResultT;
104  //------------------------------------------------------------------------------
105  StringGrammar() : StringGrammar::base_type( str ) {
106  begin_quote = enc::char_( "\"'" );
107  quote = enc::char_( qi::_r1 );
108 
109  str = qi::lexeme[begin_quote[qi::_a = qi::_1] >
110  *( ( enc::char_( '\\' ) >> quote( qi::_a ) )[qi::_val += qi::_a] |
111  ( enc::char_( '\\' ) >> enc::char_( '\\' ) )[qi::_val += '\\'] |
112  ( enc::char_[qi::_val += qi::_1] - quote( qi::_a ) ) ) > quote( qi::_a )];
113  }
114  //------------------------------------------------------------------------------
115  qi::rule<Iterator, std::string(), qi::locals<char>, Skipper> str;
116  qi::rule<Iterator, char()> begin_quote;
117  qi::rule<Iterator, void( char )> quote;
118  //------------------------------------------------------------------------------
119  };
122  //==============================================================================
123  template <typename Iterator, typename Skipper>
124  struct CharGrammar : qi::grammar<Iterator, char(), Skipper> {
125  typedef char ResultT;
126  CharGrammar() : CharGrammar::base_type( ch ) {
127  ch = qi::int_parser<char>() | '\'' >> ( qi::char_ - '\'' ) >> '\'';
128  }
129  qi::rule<Iterator, char(), Skipper> ch;
130  };
132  //==============================================================================
133  template <typename Iterator, typename Skipper>
134  struct BoolGrammar : qi::grammar<Iterator, bool(), Skipper> {
135  typedef bool ResultT;
137  boolean_literal = ( qi::lit( "true" ) | "True" | "TRUE" | "1" )[qi::_val = true] |
138  ( qi::lit( "false" ) | "False" | "FALSE" | "0" )[qi::_val = false];
139  }
140  qi::rule<Iterator, bool(), Skipper> boolean_literal;
141  };
143  //==============================================================================
144  template <typename Iterator, typename RT, typename Skipper>
145  struct IntGrammar : qi::grammar<Iterator, RT(), Skipper> {
146  typedef RT ResultT;
147  IntGrammar() : IntGrammar::base_type( integer ) {
148  integer = qi::int_parser<RT>()[qi::_val = qi::_1] >> -qi::no_case[qi::char_( 'L' )];
149  }
150  qi::rule<Iterator, RT(), Skipper> integer;
151  };
152  // ----------------------------------------------------------------------------
153  // Register IntGrammar:
154  // ----------------------------------------------------------------------------
155  template <typename Iterator, std::integral T, typename Skipper>
156  struct Grammar_<Iterator, T, Skipper> {
158  };
159  //==============================================================================
160  template <typename Iterator, typename RT, typename Skipper>
161  struct RealGrammar : qi::grammar<Iterator, RT(), Skipper> {
162  typedef RT ResultT;
163  RealGrammar() : RealGrammar::base_type( real ) { real = qi::real_parser<RT>(); }
164  qi::rule<Iterator, RT(), Skipper> real;
165  };
166  // ----------------------------------------------------------------------------
167  // Register RealGrammar:
168  // ----------------------------------------------------------------------------
169  template <typename Iterator, std::floating_point T, typename Skipper>
170  struct Grammar_<Iterator, T, Skipper> {
172  };
173  //==============================================================================
174  // Grammar for std::tuples
175  //==============================================================================
176  template <typename T>
178 
179  template <typename T>
181 
182  template <typename T, typename... Ts>
183  struct tuple_remove_first_type<std::tuple<T, Ts...>> {
184  typedef std::tuple<Ts...> type;
185  };
186 
187  template <typename T, typename... Ts>
188  struct tuple_get_first_type<std::tuple<T, Ts...>> {
189  typedef T type;
190  };
191 
192  // ----------------------------------------------------------------------------
193 
194  template <typename Iterator, typename TupleT, std::size_t N, typename Skipper>
196  : qi::grammar<Iterator, TupleT(), qi::locals<typename tuple_get_first_type<TupleT>::type>, Skipper> {
197  //---------------------------------------------------------------------------
198  typedef TupleT ResultT;
201  //---------------------------------------------------------------------------
202  struct Operations {
203  //----------------------------------------------------------------------
204 
205  void operator()( ResultT& res, HeadT& head, TailT& tail ) const {
206  res = std::tuple_cat( std::tuple<HeadT>( head ), tail );
207  }
208  //----------------------------------------------------------------------
209  };
210  //---------------------------------------------------------------------------
212  tup = grHead[qi::_a = qi::_1] >> ',' >> grLast[op( qi::_val, qi::_a, qi::_1 )];
213  }
214 
217 
218  qi::rule<Iterator, ResultT(), qi::locals<HeadT>, Skipper> tup;
219  ph::function<Operations> op;
220  };
221 
222  template <typename Iterator, typename TupleT, typename Skipper>
223  struct TupleInnerGrammar<Iterator, TupleT, 1, Skipper> : qi::grammar<Iterator, TupleT(), Skipper> {
224  //---------------------------------------------------------------------------
225  typedef TupleT ResultT;
226  // typedef typename ResultT::value_type Tuple1T;
227  //---------------------------------------------------------------------------
228  struct Operations {
229  //---------------------------------------------------------------------
230  void operator()( ResultT& res, const std::tuple_element_t<0, ResultT>& val ) const {
231  res = ResultT();
232  std::get<0>( res ) = val;
233  }
234  //----------------------------------------------------------------------
235  };
236  //---------------------------------------------------------------------------
237  TupleInnerGrammar() : TupleInnerGrammar::base_type( tup ) { tup = grFirst[op( qi::_val, qi::_1 )]; }
238 
240 
241  qi::rule<Iterator, ResultT(), Skipper> tup;
242  ph::function<Operations> op;
243  };
244 
245  // ----------------------------------------------------------------------------
246  template <typename Iterator, typename TupleT, std::size_t N, typename Skipper>
247  struct TupleGrammar : qi::grammar<Iterator, TupleT(), qi::locals<char>, Skipper> {
248  typedef TupleT ResultT;
249  TupleGrammar() : TupleGrammar::base_type( tup ) {
250  begin = enc::char_( '[' )[qi::_val = ']'] | enc::char_( '(' )[qi::_val = ')'];
251  end = *( enc::char_( ',' ) ) >> enc::char_( qi::_r1 );
252 
253  tup = begin[qi::_a = qi::_1] >> grTuple[qi::_val = qi::_1] >> end( qi::_a );
254  }
255 
256  qi::rule<Iterator, char()> begin;
257  qi::rule<Iterator, void( char )> end;
258  qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> tup;
260  };
261 
262  // -----------------------------------------------------------------------------
263  // Register TupleGrammar for std::tuple:
264  // ----------------------------------------------------------------------------
265  template <typename Iterator, typename Skipper, typename... Args>
266  struct Grammar_<Iterator, std::tuple<Args...>, Skipper> {
267  typedef TupleGrammar<Iterator, std::tuple<Args...>, sizeof...( Args ), Skipper> Grammar;
268  };
269  //==============================================================================
270  template <typename Iterator, typename VectorT, typename Skipper>
271  struct VectorGrammar : qi::grammar<Iterator, VectorT(), qi::locals<char>, Skipper> {
272  //------------------------------------------------------------------------------
273  typedef VectorT ResultT;
274  //------------------------------------------------------------------------------
275  VectorGrammar() : VectorGrammar::base_type( vec ) {
276  begin =
277  enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
278  end = *( enc::char_( ',' ) ) >> enc::char_( qi::_r1 );
279  list = elementGrammar % ',';
280  vec = begin[qi::_a = qi::_1] >> -list[qi::_val = qi::_1] >> end( qi::_a );
281  }
282  // ----------------------------------------------------------------------------
284  qi::rule<Iterator, char()> begin;
285  qi::rule<Iterator, void( char )> end;
286 
287  qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> vec;
288  qi::rule<Iterator, ResultT(), Skipper> list;
289  // ----------------------------------------------------------------------------
290  };
291  // ----------------------------------------------------------------------------
292  // Register VectorGrammar for std::vector:
293  // ----------------------------------------------------------------------------
294  template <typename Iterator, typename InnerT, typename AllocatorT, typename Skipper>
295  struct Grammar_<Iterator, std::vector<InnerT, AllocatorT>, Skipper> {
297  };
298  // ----------------------------------------------------------------------------
299  // Register VectorGrammar for std::list:
300  // ----------------------------------------------------------------------------
301  template <typename Iterator, typename InnerT, typename AllocatorT, typename Skipper>
302  struct Grammar_<Iterator, std::list<InnerT, AllocatorT>, Skipper> {
304  };
305  // ----------------------------------------------------------------------------
306  // Register VectorGrammar for std::set:
307  // ----------------------------------------------------------------------------
308  template <typename Iterator, typename InnerT, typename CompareT, typename AllocatorT, typename Skipper>
309  struct Grammar_<Iterator, std::set<InnerT, CompareT, AllocatorT>, Skipper> {
311  };
312 
313  //==============================================================================
314  template <typename Iterator, typename SetT, typename Skipper>
315  struct SetGrammar : qi::grammar<Iterator, SetT(), qi::locals<char>, Skipper> {
316  SetGrammar() : SetGrammar::base_type( set ) {
317  // special handling of empty set as "{}" is always a dict
318  set = qi::lit( "set()" ) | grVector;
319  }
321  qi::rule<Iterator, SetT(), qi::locals<char>, Skipper> set;
322  };
323  // ----------------------------------------------------------------------------
324  // Register SetGrammar for std::unordered_set:
325  // ----------------------------------------------------------------------------
326  template <typename Iterator, typename InnerT, typename HashT, typename CompareT, typename AllocatorT,
327  typename Skipper>
328  struct Grammar_<Iterator, std::unordered_set<InnerT, HashT, CompareT, AllocatorT>, Skipper> {
330  };
331 
332  //==============================================================================
333  template <typename Iterator, typename PairT, typename Skipper>
334  struct PairGrammar : qi::grammar<Iterator, PairT(), qi::locals<char>, Skipper> {
335  //------------------------------------------------------------------------------
336  typedef PairT ResultT;
337  typedef typename PairT::first_type first_type;
338  typedef typename PairT::second_type second_type;
339  //------------------------------------------------------------------------------
340  struct first {};
341  struct second {};
342  //------------------------------------------------------------------------------
343  PairGrammar() : PairGrammar( "," ) {}
344  PairGrammar( const std::string& delimeter ) : PairGrammar::base_type( pair ) {
345  begin = enc::char_( '(' )[qi::_val = ')'] | enc::char_( '[' )[qi::_val = ']'];
346  end = qi::char_( qi::_r1 );
347  pair = begin[qi::_a = qi::_1] >> pair_in[qi::_val = qi::_1] >> end( qi::_a );
348  pair_in = key >> qi::lit( delimeter ) >> value;
349  }
350  // ----------------------------------------------------------------------------
353  qi::rule<Iterator, char()> begin;
354  qi::rule<Iterator, void( char )> end;
355  qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> pair;
357  // ph::function<Operations> op;
358  // ----------------------------------------------------------------------------
359  }; // END PairGrammar
360  // ----------------------------------------------------------------------------
361  // Register PairGrammar:
362  // ----------------------------------------------------------------------------
363  template <typename Iterator, typename KeyT, typename ValueT, typename Skipper>
364  struct Grammar_<Iterator, std::pair<KeyT, ValueT>, Skipper> {
366  };
367  // ============================================================================
368  template <typename Iterator, typename MapT, typename Skipper>
369  struct MapGrammar : qi::grammar<Iterator, MapT(), Skipper> {
370  //------------------------------------------------------------------------------
371  typedef MapT ResultT;
372  typedef typename MapT::key_type KeyT;
373  typedef typename MapT::mapped_type MappedT;
374  typedef std::pair<KeyT, MappedT> PairT;
375 
376  typedef std::vector<PairT> VectorPairT;
377  //------------------------------------------------------------------------------
378  struct tag_key {};
379  struct tag_mapped {};
380  struct Operations {
381  //----------------------------------------------------------------------
382  void operator()( ResultT& res, const VectorPairT& vec ) const {
383  for ( auto cur = vec.begin(); cur != vec.end(); ++cur ) { res.insert( *cur ); }
384  }
385  void operator()( PairT& res, const KeyT& key, tag_key ) const { res.first = key; }
386  void operator()( PairT& res, const MappedT& value, tag_mapped ) const { res.second = value; }
387  //----------------------------------------------------------------------
388  };
389  //------------------------------------------------------------------------------
390  MapGrammar() : MapGrammar::base_type( map ) {
391  pair = key[op( qi::_val, qi::_1, tag_key() )] > ( qi::lit( ':' ) | '=' ) >
392  value[op( qi::_val, qi::_1, tag_mapped() )];
393  list = -( pair % enc::char_( ',' ) );
394  map = ( ( '[' >> list >> ']' ) | ( '{' >> list >> '}' ) | ( '[' >> list >> ',' >> ']' ) |
395  ( '{' >> list >> ',' >> '}' ) )[op( qi::_val, qi::_1 )];
396  }
397  // ----------------------------------------------------------------------------
400  qi::rule<Iterator, PairT(), Skipper> pair;
402  qi::rule<Iterator, ResultT(), Skipper> map;
403  ph::function<Operations> op;
404  // ----------------------------------------------------------------------------
405  };
406  // ----------------------------------------------------------------------------
407  // Register MapGrammar for std::map:
408  // ----------------------------------------------------------------------------
409  template <typename Iterator, typename KeyT, typename ValueT, typename KeyCompareT, typename AllocatorT,
410  typename Skipper>
411  struct Grammar_<Iterator, std::map<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> {
413  };
414  // ----------------------------------------------------------------------------
415  // Register MapGrammar for std::unordered_map:
416  // ----------------------------------------------------------------------------
417  template <typename Iterator, typename KeyT, typename ValueT, typename HashT, typename KeyCompareT,
418  typename AllocatorT, typename Skipper>
419  struct Grammar_<Iterator, std::unordered_map<KeyT, ValueT, HashT, KeyCompareT, AllocatorT>, Skipper> {
421  };
422  // ----------------------------------------------------------------------------
423  // Register MapGrammar for GaudiUtils::VectorMap:
424  // ----------------------------------------------------------------------------
425  template <typename Iterator, typename KeyT, typename ValueT, typename KeyCompareT, typename AllocatorT,
426  typename Skipper>
427  struct Grammar_<Iterator, GaudiUtils::VectorMap<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> {
429  };
430  // ============================================================================
431  template <typename Iterator, typename PointT, typename Skipper>
432  struct Pnt3DGrammar : qi::grammar<Iterator, PointT(), Skipper> {
433  typedef PointT ResultT;
434  typedef typename PointT::Scalar Scalar;
435  // ----------------------------------------------------------------------------
436  struct Operations {
437  void operator()( ResultT& res, const Scalar& scalar, const char xyz ) const {
438  switch ( xyz ) {
439  case 'x':
440  res.SetX( scalar );
441  break;
442  case 'y':
443  res.SetY( scalar );
444  break;
445  case 'z':
446  res.SetZ( scalar );
447  break;
448  default:
449  break;
450  }
451  }
452  }; // Operations
453  // ----------------------------------------------------------------------------
454  Pnt3DGrammar() : Pnt3DGrammar::base_type( point ) {
455  point = list | ( '(' >> list >> ')' ) | ( '[' >> list >> ']' );
456  list = -( enc::no_case[qi::lit( "x" ) | qi::lit( "px" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'x' )] >>
457  ',' >> -( enc::no_case[qi::lit( "y" ) | qi::lit( "py" )] >> ':' ) >>
458  scalar[op( qi::_val, qi::_1, 'y' )] >> ',' >>
459  -( enc::no_case[qi::lit( "z" ) | qi::lit( "pz" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'z' )];
460  }
461  // ----------------------------------------------------------------------------
464  ph::function<Operations> op;
465  // ----------------------------------------------------------------------------
466  }; // Pnt3DGrammar
467  // ----------------------------------------------------------------------------
468  // Register Pnt3DGrammar for ROOT::Math::PositionVector3D:
469  // ----------------------------------------------------------------------------
470  template <typename Iterator, typename T1, typename T2, typename Skipper>
471  struct Grammar_<Iterator, ROOT::Math::PositionVector3D<T1, T2>, Skipper> {
473  };
474  // ----------------------------------------------------------------------------
475  // Register Pnt3DGrammar for ROOT::Math::DisplacementVector3D:
476  // ----------------------------------------------------------------------------
477  template <typename Iterator, typename T1, typename T2, typename Skipper>
478  struct Grammar_<Iterator, ROOT::Math::DisplacementVector3D<T1, T2>, Skipper> {
480  };
481  // ============================================================================
482  template <typename Iterator, typename PointT, typename Skipper>
483  struct Pnt4DGrammar : qi::grammar<Iterator, PointT(), Skipper> {
484  typedef PointT ResultT;
485  typedef typename PointT::Scalar ScalarT;
486  //-----------------------------------------------------------------------------
487  struct Operations {
488 
489  void operator()( ResultT& res, const ScalarT& scalar, const char xyz ) const {
490  switch ( xyz ) {
491  case 'x':
492  res.SetPx( scalar );
493  break;
494  case 'y':
495  res.SetPy( scalar );
496  break;
497  case 'z':
498  res.SetPz( scalar );
499  break;
500  case 'e':
501  res.SetE( scalar );
502  break;
503  default:
504  break;
505  }
506  }
507  void operator()( ResultT& res, const ResultT& xyz ) const {
508  res.SetPx( xyz.Px() );
509  res.SetPy( xyz.Py() );
510  res.SetPz( xyz.Pz() );
511  }
512  }; // Operations
513  // ----------------------------------------------------------------------------
514  Pnt4DGrammar() : Pnt4DGrammar::base_type( point4d ) {
515  point4d = list4d | ( '(' >> list4d >> ')' ) | ( '[' >> list4d >> ']' );
516  list4d = ( point3d[op( qi::_val, qi::_1 )] >> enc::char_( ";," ) >> e[op( qi::_val, qi::_1, 'e' )] ) |
517  ( e[op( qi::_val, qi::_1, 'e' )] >> enc::char_( ";," ) >> point3d[op( qi::_val, qi::_1 )] );
518  e = -( enc::no_case[enc::char_( "te" )] >> ':' ) >> scalar[qi::_val = qi::_1];
519 
520  point3d = list3d | ( '(' >> list3d >> ')' ) | ( '[' >> list3d >> ']' );
521  list3d = -( enc::no_case[qi::lit( "x" ) | qi::lit( "px" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'x' )] >>
522  ',' >> -( enc::no_case[qi::lit( "y" ) | qi::lit( "py" )] >> ':' ) >>
523  scalar[op( qi::_val, qi::_1, 'y' )] >> ',' >>
524  -( enc::no_case[qi::lit( "z" ) | qi::lit( "pz" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'z' )];
525  }
526  // ----------------------------------------------------------------------------
528  qi::rule<Iterator, ScalarT(), Skipper> e;
530  ph::function<Operations> op;
531  // ----------------------------------------------------------------------------
532  }; // Pnt4DGrammar
533  // ----------------------------------------------------------------------------
534  // Register Pnt4DGrammar for ROOT::Math::LorentzVector:
535  // ----------------------------------------------------------------------------
536  template <typename Iterator, typename T1, typename Skipper>
537  struct Grammar_<Iterator, ROOT::Math::LorentzVector<T1>, Skipper> {
539  };
540  // ============================================================================
541  template <typename Iterator, typename Skipper>
542  struct Histo1DGrammar : qi::grammar<Iterator, Gaudi::Histo1DDef(), qi::locals<char>, Skipper> {
544  // ----------------------------------------------------------------------------
545  struct Operations {
546  void operator()( ResultT& res, const std::string& title ) const { res.setTitle( title ); }
547  void operator()( ResultT& res, const double& val, const char lh ) const {
548  switch ( lh ) {
549  case 'l':
550  res.setLowEdge( val );
551  break;
552  case 'h':
553  res.setHighEdge( val );
554  break;
555  default:
556  break;
557  }
558  }
559  void operator()( ResultT& res, int val ) const { res.setBins( val ); }
560  void operator()( ResultT& res ) const {}
561  }; // Operations
562  // ----------------------------------------------------------------------------
563  Histo1DGrammar() : Histo1DGrammar::base_type( hist ) {
564  val1 = title[op( qi::_val, qi::_1 )] >> ',' >> qi::double_[op( qi::_val, qi::_1, 'l' )] >> ',' >>
565  qi::double_[op( qi::_val, qi::_1, 'h' )] >> -( ',' >> qi::int_[op( qi::_val, qi::_1 )] );
566  val2 = qi::double_[op( qi::_val, qi::_1, 'l' )] >> ',' >> qi::double_[op( qi::_val, qi::_1, 'h' )] >> ',' >>
567  title[op( qi::_val, qi::_1 )] >> -( ',' >> qi::int_[op( qi::_val, qi::_1 )] );
568  val3 = qi::double_[op( qi::_val, qi::_1, 'l' )] >> ',' >> qi::double_[op( qi::_val, qi::_1, 'h' )] >>
569  -( ',' >> title[op( qi::_val, qi::_1 )] ) >> -( ',' >> qi::int_[op( qi::_val, qi::_1 )] );
570  begin = enc::char_( '[' )[qi::_val = ']'] | enc::char_( '(' )[qi::_val = ')'];
571  end = enc::char_( qi::_r1 );
572  hist = begin[qi::_a = qi::_1] >> ( val1 | val2 | val3 )[qi::_val = qi::_1] >> end( qi::_a );
573  }
574  // ----------------------------------------------------------------------------
575  qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> hist;
577  qi::rule<Iterator, char()> begin;
578  qi::rule<Iterator, void( char )> end;
580  ph::function<Operations> op;
581  // ----------------------------------------------------------------------------
582  }; // Histo1DGrammar
583  // ----------------------------------------------------------------------------
585  // ============================================================================
586  template <typename Iterator, typename Skipper>
587  struct KeyValueGrammar : qi::grammar<Iterator, std::pair<std::string, std::string>(), Skipper> {
588  //------------------------------------------------------------------------------
589  typedef std::pair<std::string, std::string> ResultT;
590  //------------------------------------------------------------------------------
591  struct first {};
592  struct second {};
593 
595  //------------------------------------------------------------------------------
596  pair = gstring >> ":" >> +enc::char_;
597  }
598  // ----------------------------------------------------------------------------
600  qi::rule<Iterator, ResultT(), Skipper> pair;
601  // ----------------------------------------------------------------------------
602  }; // END KeyValueGrammar
603  // We don't register KeyalueGrammar because it's a special parser
604  // ============================================================================
605  } // namespace Parsers
606 } // namespace Gaudi
Gaudi::Parsers::Histo1DGrammar::val3
qi::rule< Iterator, ResultT(), Skipper > val3
Definition: Grammars.h:576
Gaudi::Parsers::TupleGrammar::grTuple
TupleInnerGrammar< Iterator, TupleT, N, Skipper > grTuple
Definition: Grammars.h:259
Gaudi::Parsers::PairGrammar::PairGrammar
PairGrammar()
Definition: Grammars.h:343
Gaudi::Parsers::CharGrammar::ResultT
char ResultT
Definition: Grammars.h:125
Gaudi::Parsers::RealGrammar::RealGrammar
RealGrammar()
Definition: Grammars.h:163
Gaudi::Parsers::StringGrammar::begin_quote
qi::rule< Iterator, char()> begin_quote
Definition: Grammar.h:77
Gaudi::Parsers::MapGrammar::tag_key
Definition: Grammars.h:378
Gaudi::Parsers::IntGrammar
Definition: Grammars.h:145
Gaudi::Parsers::MapGrammar::Operations::operator()
void operator()(ResultT &res, const VectorPairT &vec) const
Definition: Grammars.h:382
Gaudi::Parsers::KeyValueGrammar
Definition: Grammars.h:587
Gaudi::Parsers::MapGrammar::Operations
Definition: Grammars.h:380
Gaudi::Parsers::MapGrammar::MapGrammar
MapGrammar()
Definition: Grammars.h:390
Gaudi::Parsers::PairGrammar::first
Definition: Grammars.h:340
Gaudi::Parsers::Histo1DGrammar::begin
qi::rule< Iterator, char()> begin
Definition: Grammars.h:577
IOTest.N
N
Definition: IOTest.py:112
Gaudi::Parsers::PairGrammar::second_type
PairT::second_type second_type
Definition: Grammars.h:338
Gaudi::Parsers::MapGrammar::Operations::operator()
void operator()(PairT &res, const KeyT &key, tag_key) const
Definition: Grammars.h:385
Gaudi::Parsers::BoolGrammar::BoolGrammar
BoolGrammar()
Definition: Grammars.h:136
Gaudi::Parsers::MapGrammar::list
qi::rule< Iterator, VectorPairT(), Skipper > list
Definition: Grammars.h:401
GaudiPartProp.decorators.std
std
Definition: decorators.py:32
Gaudi::Parsers::KeyValueGrammar::second
Definition: Grammars.h:592
Gaudi::Parsers::VectorGrammar
Definition: Grammars.h:271
Gaudi::Parsers::KeyValueGrammar::gstring
StringGrammar< Iterator, Skipper > gstring
Definition: Grammars.h:599
Gaudi::Parsers::Pnt4DGrammar::op
ph::function< Operations > op
Definition: Grammars.h:530
Gaudi::Histo1DDef::setLowEdge
void setLowEdge(double value)
set low edge
Definition: HistoDef.h:74
Gaudi::Parsers::TupleGrammar::tup
qi::rule< Iterator, ResultT(), qi::locals< char >, Skipper > tup
Definition: Grammars.h:258
Gaudi::Parsers::TupleGrammar::end
qi::rule< Iterator, void(char)> end
Definition: Grammars.h:257
Gaudi::Parsers::DefaultIterator
std::string::const_iterator DefaultIterator
Definition: Grammars.h:71
Gaudi::Parsers::Pnt3DGrammar::Operations
Definition: Grammars.h:436
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper >::Grammar
Pnt3DGrammar< Iterator, ROOT::Math::PositionVector3D< T1, T2 >, Skipper > Grammar
Definition: Grammars.h:472
Gaudi::Parsers::Grammar_< Iterator, T, Skipper >::Grammar
RealGrammar< Iterator, T, Skipper > Grammar
Definition: Grammars.h:171
Gaudi::Parsers::VectorGrammar::list
qi::rule< Iterator, ResultT(), Skipper > list
Definition: Grammars.h:288
Gaudi::Parsers::Pnt3DGrammar::Operations::operator()
void operator()(ResultT &res, const Scalar &scalar, const char xyz) const
Definition: Grammars.h:437
Gaudi::Parsers::PairGrammar::second
Definition: Grammars.h:341
Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::grFirst
Grammar_< Iterator, std::tuple_element_t< 0, ResultT >, Skipper >::Grammar grFirst
Definition: Grammars.h:239
Gaudi::Parsers::Pnt4DGrammar::Operations::operator()
void operator()(ResultT &res, const ResultT &xyz) const
Definition: Grammars.h:507
Gaudi::Parsers::Grammar_< Iterator, T, Skipper >::Grammar
IntGrammar< Iterator, T, Skipper > Grammar
Definition: Grammars.h:157
Gaudi::Parsers::DefaultSkipper
enc::space_type DefaultSkipper
Definition: Grammars.h:72
Gaudi::Parsers::PairGrammar::first_type
PairT::first_type first_type
Definition: Grammars.h:337
Gaudi::Parsers::KeyValueGrammar::pair
qi::rule< Iterator, ResultT(), Skipper > pair
Definition: Grammars.h:600
Gaudi::Parsers::Pnt4DGrammar::list4d
qi::rule< Iterator, ResultT(), Skipper > list4d
Definition: Grammars.h:527
Gaudi::Parsers::Pnt4DGrammar::e
qi::rule< Iterator, ScalarT(), Skipper > e
Definition: Grammars.h:528
Gaudi::Parsers::Histo1DGrammar::Histo1DGrammar
Histo1DGrammar()
Definition: Grammars.h:563
Gaudi::Parsers::Pnt4DGrammar::Pnt4DGrammar
Pnt4DGrammar()
Definition: Grammars.h:514
Gaudi::Parsers::Pnt3DGrammar
Definition: Grammars.h:432
Gaudi::Parsers::RealGrammar::ResultT
RT ResultT
Definition: Grammars.h:162
StringKey.h
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper >::Grammar
Pnt4DGrammar< Iterator, ROOT::Math::LorentzVector< T1 >, Skipper > Grammar
Definition: Grammars.h:538
Gaudi::Parsers::Histo1DGrammar::op
ph::function< Operations > op
Definition: Grammars.h:580
Gaudi::Parsers::Histo1DGrammar::title
StringGrammar< Iterator, Skipper > title
Definition: Grammars.h:579
Gaudi::Parsers::VectorGrammar::end
qi::rule< Iterator, void(char)> end
Definition: Grammars.h:285
Gaudi::Parsers::TupleInnerGrammar::op
ph::function< Operations > op
Definition: Grammars.h:219
Gaudi::Parsers::Grammar_< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper >::Grammar
VectorGrammar< Iterator, std::set< InnerT, CompareT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:310
Gaudi::Parsers::PairGrammar::pair_in
qi::rule< Iterator, ResultT(), Skipper > pair_in
Definition: Grammars.h:356
Gaudi::Parsers::MapGrammar::map
qi::rule< Iterator, ResultT(), Skipper > map
Definition: Grammars.h:402
Gaudi::Parsers::TupleInnerGrammar::TupleInnerGrammar
TupleInnerGrammar()
Definition: Grammars.h:211
Gaudi::Parsers::PairGrammar::value
Grammar_< Iterator, typename PairT::second_type, Skipper >::Grammar value
Definition: Grammars.h:352
Containers::map
struct GAUDI_API map
Parametrisation class for map-like implementation.
Definition: KeyedObjectManager.h:35
Gaudi::Parsers::MapGrammar::tag_mapped
Definition: Grammars.h:379
Gaudi::Parsers::StringGrammar::StringGrammar
StringGrammar()
Definition: Grammars.h:105
Gaudi::Parsers::SetGrammar::set
qi::rule< Iterator, SetT(), qi::locals< char >, Skipper > set
Definition: Grammars.h:321
Gaudi::Parsers::TupleGrammar::begin
qi::rule< Iterator, char()> begin
Definition: Grammars.h:256
Gaudi::Parsers::TupleGrammar
Definition: Grammars.h:247
Gaudi::Parsers::PairGrammar::ResultT
PairT ResultT
Definition: Grammars.h:336
Gaudi::Parsers::Pnt4DGrammar::ResultT
PointT ResultT
Definition: Grammars.h:484
Gaudi::Parsers::MapGrammar::MappedT
MapT::mapped_type MappedT
Definition: Grammars.h:373
HashMap.h
HistoDef.h
Gaudi::Parsers::tuple_remove_first_type
Definition: Grammars.h:177
Gaudi::Parsers::Pnt3DGrammar::list
qi::rule< Iterator, ResultT(), Skipper > list
Definition: Grammars.h:462
Gaudi::Parsers::KeyValueGrammar::first
Definition: Grammars.h:591
Gaudi::Parsers::Pnt4DGrammar::ScalarT
PointT::Scalar ScalarT
Definition: Grammars.h:485
Gaudi::Parsers::SkipperGrammar::SkipperGrammar
SkipperGrammar()
Definition: Grammars.h:93
compareOutputFiles.sp
sp
Definition: compareOutputFiles.py:506
Gaudi::Parsers::VectorGrammar::begin
qi::rule< Iterator, char()> begin
Definition: Grammars.h:284
Gaudi::Histo1DDef::setTitle
void setTitle(std::string value)
set the title
Definition: HistoDef.h:80
Gaudi::Parsers::Grammar_< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper >::Grammar
Pnt3DGrammar< Iterator, ROOT::Math::DisplacementVector3D< T1, T2 >, Skipper > Grammar
Definition: Grammars.h:479
Gaudi::StringKey
Definition: StringKey.h:44
Gaudi::Histo1DDef
Definition: HistoDef.h:41
Gaudi::Parsers::TupleInnerGrammar::Operations
Definition: Grammars.h:202
VectorMap.h
Gaudi::Parsers::CharGrammar::ch
qi::rule< Iterator, char(), Skipper > ch
Definition: Grammars.h:129
Gaudi::Parsers::Histo1DGrammar::end
qi::rule< Iterator, void(char)> end
Definition: Grammars.h:578
Gaudi::Parsers::TupleInnerGrammar::ResultT
TupleT ResultT
Definition: Grammars.h:198
Gaudi::Parsers::tuple_get_first_type
Definition: Grammars.h:180
Gaudi::Parsers::PairGrammar
Definition: Grammars.h:334
Gaudi::Parsers::tuple_remove_first_type< std::tuple< T, Ts... > >::type
std::tuple< Ts... > type
Definition: Grammars.h:184
Gaudi::Parsers::MapGrammar::Operations::operator()
void operator()(PairT &res, const MappedT &value, tag_mapped) const
Definition: Grammars.h:386
Gaudi::Parsers::IntGrammar::ResultT
RT ResultT
Definition: Grammars.h:146
Gaudi::Parsers::Pnt3DGrammar::scalar
Grammar_< Iterator, Scalar, Skipper >::Grammar scalar
Definition: Grammars.h:463
Gaudi::Histo1DDef::setHighEdge
void setHighEdge(double value)
set high edge
Definition: HistoDef.h:76
Gaudi::Parsers::RealGrammar::real
qi::rule< Iterator, Node(), Skipper > real
Definition: Grammar.h:123
Gaudi::Parsers::PairGrammar::key
Grammar_< Iterator, typename PairT::first_type, Skipper >::Grammar key
Definition: Grammars.h:351
Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::ResultT
TupleT ResultT
Definition: Grammars.h:225
Gaudi::Parsers::StringGrammar
Definition: Grammar.h:62
Gaudi::Parsers::MapGrammar::pair
qi::rule< Iterator, PairT(), Skipper > pair
Definition: Grammars.h:400
Gaudi::Parsers::TupleInnerGrammar::HeadT
tuple_get_first_type< TupleT >::type HeadT
Definition: Grammars.h:200
Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::TupleInnerGrammar
TupleInnerGrammar()
Definition: Grammars.h:237
Gaudi::Parsers::Pnt4DGrammar::Operations
Definition: Grammars.h:487
Gaudi::Parsers::Histo1DGrammar::Operations::operator()
void operator()(ResultT &res) const
Definition: Grammars.h:560
ROOT
Definition: IMagneticFieldSvc.h:19
Point3DTypes.h
Gaudi::Parsers::VectorGrammar::vec
qi::rule< Iterator, ResultT(), qi::locals< char >, Skipper > vec
Definition: Grammars.h:287
Gaudi::Parsers::MapGrammar::PairT
std::pair< KeyT, MappedT > PairT
Definition: Grammars.h:374
Gaudi::Parsers::StringGrammar::quote
qi::rule< Iterator, void(char)> quote
Definition: Grammar.h:78
Gaudi::Parsers::CharGrammar
Definition: Grammars.h:124
Gaudi::Parsers::Histo1DGrammar
Definition: Grammars.h:542
Gaudi::Parsers::Pnt4DGrammar::point3d
qi::rule< Iterator, ResultT(), Skipper > point3d
Definition: Grammars.h:527
Gaudi::Parsers::Histo1DGrammar::Operations::operator()
void operator()(ResultT &res, int val) const
Definition: Grammars.h:559
Gaudi::Parsers::PairGrammar::pair
qi::rule< Iterator, ResultT(), qi::locals< char >, Skipper > pair
Definition: Grammars.h:355
Gaudi::Parsers::PairGrammar::end
qi::rule< Iterator, void(char)> end
Definition: Grammars.h:354
Gaudi::Parsers::Histo1DGrammar::Operations::operator()
void operator()(ResultT &res, const std::string &title) const
Definition: Grammars.h:546
Gaudi::Parsers::SkipperGrammar::comments
qi::rule< Iterator > comments
Definition: Grammar.h:58
Gaudi::Parsers::TupleInnerGrammar::grLast
TupleInnerGrammar< Iterator, TailT, N - 1, Skipper > grLast
Definition: Grammars.h:215
Gaudi::Parsers::BoolGrammar
Definition: Grammar.h:102
Gaudi::Parsers::Grammar_< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >::Grammar
MapGrammar< Iterator, GaudiUtils::VectorMap< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:428
Gaudi::Parsers::SkipperGrammar
Definition: Grammar.h:53
Gaudi::Parsers::BoolGrammar::boolean_literal
qi::rule< Iterator, bool(), Skipper > boolean_literal
Definition: Grammars.h:140
Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::Operations::operator()
void operator()(ResultT &res, const std::tuple_element_t< 0, ResultT > &val) const
Definition: Grammars.h:230
Gaudi::Parsers::Pnt4DGrammar::point4d
qi::rule< Iterator, ResultT(), Skipper > point4d
Definition: Grammars.h:527
Gaudi::Parsers::Pnt3DGrammar::ResultT
PointT ResultT
Definition: Grammars.h:433
Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::tup
qi::rule< Iterator, ResultT(), Skipper > tup
Definition: Grammars.h:241
Gaudi::Parsers::MapGrammar::KeyT
MapT::key_type KeyT
Definition: Grammars.h:372
Gaudi::Parsers::Grammar_< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper >::Grammar
MapGrammar< Iterator, std::map< KeyT, ValueT, KeyCompareT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:412
Gaudi::Parsers::PairGrammar::PairGrammar
PairGrammar(const std::string &delimeter)
Definition: Grammars.h:344
Gaudi::Parsers::CharGrammar::CharGrammar
CharGrammar()
Definition: Grammars.h:126
Gaudi
This file provides a Grammar for the type Gaudi::Accumulators::Axis It allows to use that type from p...
Definition: __init__.py:1
Gaudi::Parsers::Pnt4DGrammar
Definition: Grammars.h:483
Gaudi::Parsers::BoolGrammar::ResultT
bool ResultT
Definition: Grammars.h:135
Gaudi::Parsers::Grammar_< Iterator, std::list< InnerT, AllocatorT >, Skipper >::Grammar
VectorGrammar< Iterator, std::list< InnerT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:303
Gaudi::Parsers::PairGrammar::begin
qi::rule< Iterator, char()> begin
Definition: Grammars.h:353
Gaudi::Parsers::TupleInnerGrammar::grHead
Grammar_< Iterator, HeadT, Skipper >::Grammar grHead
Definition: Grammars.h:216
Gaudi::Parsers::tuple_get_first_type< std::tuple< T, Ts... > >::type
T type
Definition: Grammars.h:189
Gaudi::Parsers::Histo1DGrammar::hist
qi::rule< Iterator, ResultT(), qi::locals< char >, Skipper > hist
Definition: Grammars.h:575
Gaudi::Parsers::KeyValueGrammar::KeyValueGrammar
KeyValueGrammar()
Definition: Grammars.h:594
Gaudi::Parsers::MapGrammar::key
Grammar_< Iterator, typename MapT::key_type, Skipper >::Grammar key
Definition: Grammars.h:398
Gaudi::Parsers::TupleInnerGrammar::tup
qi::rule< Iterator, ResultT(), qi::locals< HeadT >, Skipper > tup
Definition: Grammars.h:218
Gaudi::Parsers::Pnt3DGrammar::point
qi::rule< Iterator, ResultT(), Skipper > point
Definition: Grammars.h:462
Containers::vector
struct GAUDI_API vector
Parametrisation class for vector-like implementation.
Definition: KeyedObjectManager.h:39
Gaudi::Parsers::VectorGrammar::ResultT
VectorT ResultT
Definition: Grammars.h:273
Gaudi::Parsers::Histo1DGrammar::Operations::operator()
void operator()(ResultT &res, const double &val, const char lh) const
Definition: Grammars.h:547
Gaudi::Parsers::Skipper
SkipperGrammar< IteratorT > Skipper
Definition: Factory.h:36
Gaudi::Parsers::REGISTER_GRAMMAR
REGISTER_GRAMMAR(std::string, StringGrammar)
Gaudi::Parsers::Grammar_< Iterator, std::pair< KeyT, ValueT >, Skipper >::Grammar
PairGrammar< Iterator, std::pair< KeyT, ValueT >, Skipper > Grammar
Definition: Grammars.h:365
Gaudi::Parsers::MapGrammar::VectorPairT
std::vector< PairT > VectorPairT
Definition: Grammars.h:376
Gaudi::Parsers::Grammar_< Iterator, std::unordered_map< KeyT, ValueT, HashT, KeyCompareT, AllocatorT >, Skipper >::Grammar
MapGrammar< Iterator, std::unordered_map< KeyT, ValueT, HashT, KeyCompareT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:420
Gaudi::Parsers::Grammar_< Iterator, std::vector< InnerT, AllocatorT >, Skipper >::Grammar
VectorGrammar< Iterator, std::vector< InnerT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:296
Gaudi::Parsers::VectorGrammar::VectorGrammar
VectorGrammar()
Definition: Grammars.h:275
Gaudi::Parsers::StringGrammar::ResultT
std::string ResultT
Definition: Grammars.h:103
Gaudi::Parsers::Grammar_
Definition: Grammars.h:75
Gaudi::Parsers::Grammar_< Iterator, std::unordered_set< InnerT, HashT, CompareT, AllocatorT >, Skipper >::Grammar
SetGrammar< Iterator, std::unordered_set< InnerT, HashT, CompareT, AllocatorT >, Skipper > Grammar
Definition: Grammars.h:329
Gaudi::Parsers::Pnt3DGrammar::Scalar
PointT::Scalar Scalar
Definition: Grammars.h:434
Gaudi::Parsers::VectorGrammar::elementGrammar
Grammar_< Iterator, typename VectorT::value_type, Skipper >::Grammar elementGrammar
Definition: Grammars.h:283
Gaudi::Parsers::Histo1DGrammar::val1
qi::rule< Iterator, ResultT(), Skipper > val1
Definition: Grammars.h:576
Gaudi::Parsers::TupleGrammar::ResultT
TupleT ResultT
Definition: Grammars.h:248
Gaudi::Parsers::TupleInnerGrammar
Definition: Grammars.h:196
Point4DTypes.h
Gaudi::Parsers::MapGrammar::value
Grammar_< Iterator, typename MapT::mapped_type, Skipper >::Grammar value
Definition: Grammars.h:399
Gaudi::Parsers::MapGrammar::ResultT
MapT ResultT
Definition: Grammars.h:371
Gaudi::Parsers::TupleInnerGrammar::Operations::operator()
void operator()(ResultT &res, HeadT &head, TailT &tail) const
Definition: Grammars.h:205
Gaudi::Parsers::TupleGrammar::TupleGrammar
TupleGrammar()
Definition: Grammars.h:249
GaudiPartProp.Nodes.Scalar
Scalar
Definition: Nodes.py:294
Gaudi::Parsers::Histo1DGrammar::ResultT
Gaudi::Histo1DDef ResultT
Definition: Grammars.h:543
Gaudi::Parsers::RealGrammar::real
qi::rule< Iterator, RT(), Skipper > real
Definition: Grammars.h:164
Gaudi::Parsers::SetGrammar::grVector
VectorGrammar< Iterator, SetT, Skipper > grVector
Definition: Grammars.h:320
Gaudi::Parsers::Pnt3DGrammar::Pnt3DGrammar
Pnt3DGrammar()
Definition: Grammars.h:454
Gaudi::Parsers::IntGrammar::integer
qi::rule< Iterator, RT(), Skipper > integer
Definition: Grammars.h:150
Gaudi::Parsers::SetGrammar
Definition: Grammars.h:315
GaudiUtils
Definition: Allocator.h:72
Gaudi::Parsers::Pnt3DGrammar::op
ph::function< Operations > op
Definition: Grammars.h:464
Gaudi::Histo1DDef::setBins
void setBins(int value)
set number of bis
Definition: HistoDef.h:78
Gaudi::Parsers::Histo1DGrammar::val2
qi::rule< Iterator, ResultT(), Skipper > val2
Definition: Grammars.h:576
Gaudi::Parsers::IntGrammar::IntGrammar
IntGrammar()
Definition: Grammars.h:147
Gaudi::Parsers::Pnt4DGrammar::list3d
qi::rule< Iterator, ResultT(), Skipper > list3d
Definition: Grammars.h:527
Gaudi::Parsers::Pnt4DGrammar::Operations::operator()
void operator()(ResultT &res, const ScalarT &scalar, const char xyz) const
Definition: Grammars.h:489
Gaudi::Parsers::Pnt4DGrammar::scalar
Grammar_< Iterator, ScalarT, Skipper >::Grammar scalar
Definition: Grammars.h:529
Gaudi::Parsers::KeyValueGrammar::ResultT
std::pair< std::string, std::string > ResultT
Definition: Grammars.h:589
Gaudi::Parsers::TupleInnerGrammar< Iterator, TupleT, 1, Skipper >::op
ph::function< Operations > op
Definition: Grammars.h:242
Gaudi::Parsers::Grammar_::BOOST_MPL_ASSERT_MSG
BOOST_MPL_ASSERT_MSG(false, GRAMMAR_FOR_TYPE_DOES_NOT_EXISTS,(T))
Gaudi::Parsers::SetGrammar::SetGrammar
SetGrammar()
Definition: Grammars.h:316
Gaudi::Parsers::MapGrammar
Definition: Grammars.h:369
Gaudi::Parsers::RealGrammar
Definition: Grammar.h:114
Iterator
boost::spirit::classic::position_iterator2< ForwardIterator > Iterator
Definition: Iterator.h:28
Gaudi::Parsers::StringGrammar::str
qi::rule< Iterator, std::string(), qi::locals< char >, Skipper > str
Definition: Grammar.h:76
Gaudi::Parsers::MapGrammar::op
ph::function< Operations > op
Definition: Grammars.h:403
Gaudi::Parsers::Histo1DGrammar::Operations
Definition: Grammars.h:545
Gaudi::Parsers::TupleInnerGrammar::TailT
tuple_remove_first_type< TupleT >::type TailT
Definition: Grammars.h:199