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