Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-09-21 08:24:22 

0001 //==========================================================================
0002 //  AIDA Detector description implementation 
0003 //--------------------------------------------------------------------------
0004 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
0005 // All rights reserved.
0006 //
0007 // For the licensing terms see $DD4hepINSTALL/LICENSE.
0008 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
0009 //
0010 // Author     : M.Frank
0011 //
0012 //==========================================================================
0013 #ifndef PARSERS_SPIRIT_GRAMMARSV2_H
0014 #define PARSERS_SPIRIT_GRAMMARSV2_H 1
0015 #ifdef __GNUC__
0016 #pragma GCC system_header
0017 #endif
0018 // ============================================================================
0019 // Include files
0020 // ============================================================================
0021 // STD:
0022 //==============================================================================
0023 #include <string>
0024 #include <vector>
0025 #include <list>
0026 #include <set>
0027 #include <map>
0028 //==============================================================================
0029 // Boost:
0030 //==============================================================================
0031 #include <boost/spirit/include/qi.hpp>
0032 #include <boost/fusion/include/unused.hpp>
0033 #include <boost/fusion/include/std_pair.hpp>
0034 
0035 // version is like X YYY ZZ (no spaces)
0036 #if BOOST_VERSION >= 107800
0037 
0038 #include <boost/phoenix/core.hpp>
0039 #include <boost/phoenix/operator.hpp>
0040 
0041 #else
0042 
0043 #include <boost/spirit/include/phoenix_core.hpp>
0044 #include <boost/spirit/include/phoenix_operator.hpp>
0045 
0046 #endif
0047 
0048 #include <boost/utility/enable_if.hpp>
0049 #include <boost/type_traits.hpp>
0050 
0051 #include <boost/spirit/repository/include/qi_confix.hpp>
0052 
0053 //==============================================================================
0054 namespace dd4hep {  namespace Parsers {
0055     //==============================================================================
0056     // Namespace aliases:
0057     //==============================================================================
0058     namespace sp    = boost::spirit;
0059     namespace ph    = boost::phoenix;
0060     namespace qi    = sp::qi;
0061     namespace enc   = sp::ascii;
0062     namespace rep  = sp::repository;
0063 
0064     template <typename T> T evaluate_string(const std::string& value);
0065 
0066     //==============================================================================
0067     // Grammars
0068     //==============================================================================
0069     typedef std::string::const_iterator DefaultIterator;
0070     typedef enc::space_type DefaultSkipper;
0071     //==============================================================================
0072     template <typename Iterator, typename T,  typename Skipper, class Enable=void>
0073     struct Grammar_ {
0074       /* READ THIS IF YOUR COMPILE BREAKS ON THE FOLLOWING LINE
0075        *
0076        * To users: You have to ask developers to implement parser for your type T
0077        * To developer: You have to implement and register Grammar for type T
0078        *
0079        */
0080       BOOST_MPL_ASSERT_MSG(false, GRAMMAR_FOR_TYPE_DOES_NOT_EXISTS, (T));
0081     };
0082 
0083 #define REGISTER_GRAMMAR(ResultType, GrammarName)     \
0084     template <typename Iterator, typename Skipper>    \
0085     struct Grammar_<Iterator, ResultType, Skipper>    \
0086     {                                                 \
0087       typedef GrammarName<Iterator, Skipper> Grammar; \
0088     }
0089     //==============================================================================
0090     template< typename Iterator> struct SkipperGrammar  : qi::grammar<Iterator>
0091     {
0092       SkipperGrammar() : SkipperGrammar::base_type(comments) {
0093         comments = enc::space | rep::confix("/*", "*/")[*(qi::char_ - "*/")]
0094           |
0095           rep::confix("//", (sp::eol | sp::eoi))[*(qi::char_ - (sp::eol|sp::eoi))];
0096       }
0097       qi::rule<Iterator> comments;
0098     };
0099     //==============================================================================
0100     template< typename Iterator, typename Skipper>
0101     struct StringGrammar : qi::grammar<Iterator, std::string(), qi::locals<char>,Skipper>
0102     {
0103       //------------------------------------------------------------------------------
0104       typedef std::string ResultT;
0105       //------------------------------------------------------------------------------
0106       StringGrammar() : StringGrammar::base_type( str ) {
0107         begin_quote   = enc::char_("\"'");
0108         quote     = enc::char_(qi::_r1);
0109 
0110         str = qi::lexeme[begin_quote[qi::_a = qi::_1]
0111                          > *( (enc::char_('\\') >> quote(qi::_a))[qi::_val += qi::_a]
0112                               | (enc::char_[qi::_val += qi::_1] - quote(qi::_a))) >
0113                          quote(qi::_a)];
0114       }
0115       //------------------------------------------------------------------------------
0116       qi::rule<Iterator, std::string(), qi::locals<char>, Skipper> str;
0117       qi::rule<Iterator, char()> begin_quote;
0118       qi::rule<Iterator, void(char)> quote;
0119       //------------------------------------------------------------------------------
0120     };
0121     REGISTER_GRAMMAR(std::string, StringGrammar);
0122     //==============================================================================
0123     template< typename Iterator, typename Skipper>
0124     struct CharGrammar : qi::grammar<Iterator, char(), Skipper>  {
0125       typedef char ResultT;
0126       CharGrammar() : CharGrammar::base_type( ch ) {
0127         ch = qi::int_parser<char>()
0128           |
0129           '\'' >> (qi::char_-'\'') >> '\'';
0130       }
0131       qi::rule<Iterator, char(), Skipper> ch;
0132     };
0133     REGISTER_GRAMMAR(char, CharGrammar);
0134     //==============================================================================
0135     template< typename Iterator, typename Skipper>
0136     struct BoolGrammar : qi::grammar<Iterator, bool(), Skipper>
0137     {
0138       typedef bool ResultT;
0139       BoolGrammar() : BoolGrammar::base_type( boolean_literal ) {
0140         boolean_literal =
0141           (qi::lit("true") | qi::lit("True") | qi::lit("TRUE") | "1")[qi::_val=true]
0142           |
0143       (qi::lit("false") | qi::lit("False") | qi::lit("FALSE") | "0")[qi::_val=false];
0144       }
0145       qi::rule<Iterator, bool(), Skipper> boolean_literal;
0146     };
0147     REGISTER_GRAMMAR(bool, BoolGrammar);
0148     //==============================================================================
0149     template< typename Iterator, typename RT , typename Skipper>
0150     struct IntGrammar : qi::grammar<Iterator, RT(), Skipper>      {
0151       typedef RT ResultT;
0152       IntGrammar() : IntGrammar::base_type( integer ) {
0153         integer = qi::int_parser<RT>()[qi::_val = qi::_1]
0154           >> -qi::no_case[qi::char_('L')];
0155       }
0156       qi::rule<Iterator, RT(), Skipper> integer;
0157     };
0158     // ----------------------------------------------------------------------------
0159     // Register IntGrammar:
0160     // ----------------------------------------------------------------------------
0161     template <typename Iterator, typename T, typename Skipper>
0162     struct Grammar_<Iterator, T,  Skipper,
0163                     typename boost::enable_if<boost::is_integral<T> >::type>
0164     {
0165       typedef IntGrammar<Iterator, T, Skipper> Grammar;
0166     };
0167     //==============================================================================
0168     template< typename Iterator, typename RT, typename Skipper>
0169     struct RealGrammar : qi::grammar<Iterator, RT(), Skipper>  {
0170       typedef RT ResultT;
0171       RealGrammar() : RealGrammar::base_type(real) {
0172         real = qi::real_parser<RT>();
0173       }
0174       qi::rule<Iterator, RT(), Skipper> real;
0175     };
0176     // ----------------------------------------------------------------------------
0177     // Register RealGrammar:
0178     // ----------------------------------------------------------------------------
0179     template <typename Iterator, typename T, typename Skipper >
0180     struct Grammar_<Iterator, T, Skipper,
0181                     typename boost::enable_if<boost::is_floating_point<T> >::type >   {
0182       typedef RealGrammar<Iterator, T, Skipper> Grammar;
0183     };
0184     //==============================================================================
0185     template< typename Iterator, typename VectorT, typename Skipper>
0186     struct VectorGrammar : qi::grammar<Iterator, VectorT(), qi::locals<char>,Skipper>
0187     {
0188       //------------------------------------------------------------------------------
0189       typedef VectorT ResultT;
0190       //------------------------------------------------------------------------------
0191       VectorGrammar() : VectorGrammar::base_type(vec) {
0192         begin = enc::char_('[')[qi::_val=']'] | enc::char_('{')[qi::_val='}']
0193           | enc::char_('(')[qi::_val=')'];
0194         end = enc::char_(qi::_r1);
0195         list = elementGrammar % ',';
0196         vec = begin[qi::_a = qi::_1] >> -list[qi::_val=qi::_1] >> end(qi::_a);
0197       }
0198       // ----------------------------------------------------------------------------
0199       typename
0200       Grammar_<Iterator, typename VectorT::value_type, Skipper>::Grammar
0201       elementGrammar;
0202       qi::rule<Iterator, char()> begin;
0203       qi::rule<Iterator, void(char)> end;
0204 
0205       qi::rule<Iterator, ResultT(), qi::locals<char>,Skipper> vec;
0206       qi::rule<Iterator, ResultT(), Skipper> list;
0207       // ----------------------------------------------------------------------------
0208     };
0209     // ----------------------------------------------------------------------------
0210     // Register VectorGrammar for std::vector:
0211     // ----------------------------------------------------------------------------
0212     template <typename Iterator,typename InnerT,typename AllocatorT,typename Skipper>
0213     struct Grammar_<Iterator, std::vector<InnerT, AllocatorT>, Skipper >    {
0214       typedef
0215       VectorGrammar<Iterator, std::vector<InnerT, AllocatorT>, Skipper>
0216       Grammar;
0217     };
0218     // ----------------------------------------------------------------------------
0219     // Register VectorGrammar for std::list:
0220     // ----------------------------------------------------------------------------
0221     template <typename Iterator, typename InnerT, typename AllocatorT,typename Skipper>
0222     struct Grammar_<Iterator, std::list<InnerT, AllocatorT>, Skipper >      {
0223       typedef
0224       VectorGrammar<Iterator, std::list<InnerT, AllocatorT>, Skipper>
0225       Grammar;
0226     };
0227     // ----------------------------------------------------------------------------
0228     // Register VectorGrammar for std::set:
0229     // ----------------------------------------------------------------------------
0230     template <typename Iterator, typename InnerT, typename CompareT, typename AllocatorT, typename Skipper>
0231     struct Grammar_<Iterator, std::set<InnerT, CompareT, AllocatorT>, Skipper >      {
0232       typedef
0233       VectorGrammar<Iterator, std::set<InnerT, CompareT, AllocatorT>, Skipper>
0234       Grammar;
0235     };
0236 #if defined(DD4HEP_HAVE_ALL_PARSERS)
0237     // ----------------------------------------------------------------------------
0238     // Register VectorGrammar for std::deque:
0239     // ----------------------------------------------------------------------------
0240     template <typename Iterator, typename InnerT, typename AllocatorT, typename Skipper>
0241     struct Grammar_<Iterator, std::deque<InnerT, AllocatorT>, Skipper >      {
0242       typedef
0243       VectorGrammar<Iterator, std::deque<InnerT, AllocatorT>, Skipper>
0244       Grammar;
0245     };
0246 #endif   //  DD4HEP_HAVE_ALL_PARSERS
0247 
0248     //==============================================================================
0249     template< typename Iterator, typename PairT, typename Skipper>
0250     struct PairGrammar :
0251     qi::grammar<Iterator,PairT(), qi::locals<char>, Skipper> {
0252       //------------------------------------------------------------------------------
0253       typedef PairT ResultT;
0254       typedef typename PairT::first_type first_type;
0255       typedef typename PairT::second_type second_type;
0256       //------------------------------------------------------------------------------
0257       PairGrammar() : PairGrammar::base_type(pair) {
0258         init(",");
0259       }
0260 
0261       PairGrammar(const std::string& delimeter) : PairGrammar::base_type(pair) {
0262         init(delimeter);
0263       }
0264       //------------------------------------------------------------------------------
0265       struct first {};
0266       struct second {};
0267       void init(const std::string& delimeter) {
0268         begin = enc::char_('(')[qi::_val=')']
0269           |
0270           enc::char_('[')[qi::_val=']'];
0271         end =  qi::char_(qi::_r1);
0272         pair = begin[qi::_a = qi::_1] >> pair_in[qi::_val = qi::_1] >> end(qi::_a);
0273         pair_in =  key >> qi::lit(delimeter) >> value;
0274       }
0275       // ----------------------------------------------------------------------------
0276       typename
0277       Grammar_<Iterator, typename PairT::first_type, Skipper>::Grammar key;
0278       typename
0279       Grammar_<Iterator, typename PairT::second_type, Skipper>::Grammar
0280       value;
0281       qi::rule<Iterator, char()> begin;
0282       qi::rule<Iterator, void(char)> end;
0283       qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> pair;
0284       qi::rule<Iterator, ResultT(), Skipper> pair_in;
0285       //ph::function<Operations> op;
0286       // ----------------------------------------------------------------------------
0287     }; // END PairGrammar
0288 
0289     // ----------------------------------------------------------------------------
0290     // Register PairGrammar:
0291     // ----------------------------------------------------------------------------
0292     template <typename Iterator, typename KeyT, typename ValueT,
0293               typename Skipper>
0294     struct Grammar_<Iterator, std::pair<KeyT, ValueT>, Skipper >
0295     {
0296       typedef PairGrammar<Iterator, std::pair<KeyT, ValueT>, Skipper> Grammar;
0297     };
0298 
0299     // ============================================================================
0300     template< typename Iterator, typename MapT, typename Skipper>
0301     struct MapGrammar : qi::grammar<Iterator,MapT(), Skipper>      {
0302       //------------------------------------------------------------------------------
0303       typedef MapT ResultT;
0304       typedef typename MapT::key_type KeyT;
0305       typedef typename MapT::mapped_type MappedT;
0306       typedef std::pair<KeyT, MappedT> PairT;
0307 
0308       typedef std::vector<PairT> VectorPairT;
0309       //------------------------------------------------------------------------------
0310       struct tag_key{};
0311       struct tag_mapped{};
0312       struct Operations   {
0313         template <typename A, typename B = boost::fusion::unused_type,
0314                   typename C = boost::fusion::unused_type,
0315                   typename D = boost::fusion::unused_type>
0316         struct result { typedef void type; };
0317         //----------------------------------------------------------------------
0318         void operator()(ResultT& res, const VectorPairT& vec) const{
0319           for(typename VectorPairT::const_iterator cur = vec.begin();
0320               cur != vec.end(); cur++){
0321             res.insert(*cur);
0322           }
0323         }
0324         void operator()(PairT& res, const KeyT& key, tag_key) const{
0325           res.first = key;
0326         }
0327         void operator()(PairT& res, const MappedT& value, tag_mapped) const{
0328           res.second = value;
0329         }
0330         //----------------------------------------------------------------------
0331       };
0332       //------------------------------------------------------------------------------
0333       MapGrammar() : MapGrammar::base_type(map) {
0334         pair = key[op(qi::_val,qi::_1, tag_key())] > (qi::lit(':') | '=')  >
0335           value[op(qi::_val,qi::_1, tag_mapped())];
0336         list = -(pair % enc::char_(','));
0337         map = (('['  >> list >> ']')
0338                | ('{'  >> list >> '}'))[op(qi::_val,qi::_1)];
0339       }
0340       // ----------------------------------------------------------------------------
0341       typename
0342       Grammar_<Iterator, typename MapT::key_type, Skipper>::Grammar key;
0343       typename
0344       Grammar_<Iterator, typename MapT::mapped_type, Skipper>::Grammar value;
0345       qi::rule<Iterator, PairT(), Skipper> pair;
0346       qi::rule<Iterator, VectorPairT(), Skipper> list;
0347       qi::rule<Iterator, ResultT(), Skipper> map;
0348       ph::function<Operations> op;
0349       // ----------------------------------------------------------------------------
0350     };
0351     // ----------------------------------------------------------------------------
0352     // Register MapGrammar for std::map:
0353     // ----------------------------------------------------------------------------
0354     template <typename Iterator, typename KeyT, typename ValueT,
0355               typename KeyCompareT, typename AllocatorT, typename Skipper>
0356     struct Grammar_<Iterator, std::map<KeyT, ValueT, KeyCompareT, AllocatorT>,
0357                     Skipper > {
0358       typedef MapGrammar<Iterator,
0359                          std::map<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> Grammar;
0360     };
0361 
0362     // ============================================================================
0363     template< typename Iterator, typename Skipper>
0364     struct KeyValueGrammar :
0365     qi::grammar<Iterator, std::pair<std::string, std::string>(), Skipper> {
0366       //------------------------------------------------------------------------------
0367       typedef std::pair<std::string, std::string> ResultT;
0368       //------------------------------------------------------------------------------
0369       struct first {};
0370       struct second {};
0371 
0372       KeyValueGrammar() : KeyValueGrammar::base_type(pair) {
0373         //------------------------------------------------------------------------------
0374         pair =  gstring >> ":" >> +enc::char_;
0375       }
0376       // ----------------------------------------------------------------------------
0377       StringGrammar<Iterator, Skipper> gstring;
0378       qi::rule<Iterator, ResultT(), Skipper> pair;
0379       // ----------------------------------------------------------------------------
0380     }; // END KeyValueGrammar
0381     // We don't register KeyalueGrammar because it's a special parser
0382     // ============================================================================
0383   }} //   dd4hep::Parsers
0384 
0385 
0386 //==============================================================================
0387 #ifndef DD4HEP_PARSERS_NO_ROOT
0388 #include "Math/Point3D.h"
0389 #include "Math/Vector3D.h"
0390 #include "Math/Vector4D.h"
0391 #include "Math/RotationZYX.h"
0392 
0393 namespace dd4hep {  namespace Parsers {
0394 
0395     // ============================================================================
0396     template< typename Iterator, typename PointT, typename Skipper>
0397     struct Pnt3DGrammar : qi::grammar<Iterator, PointT(), Skipper> {
0398       typedef PointT ResultT;
0399       typedef std::string Scalar;
0400       // ----------------------------------------------------------------------------
0401       struct Operations {
0402         template <typename A, typename B = boost::fusion::unused_type,
0403                   typename C = boost::fusion::unused_type,
0404                   typename D = boost::fusion::unused_type>
0405         struct result { typedef void type; };
0406         void operator()(ResultT& res, const Scalar& value,const char xyz) const{
0407           typename PointT::Scalar val = evaluate_string<typename PointT::Scalar>(value);
0408           switch(xyz)  {
0409           case 'x': res.SetX(val); break;
0410           case 'y': res.SetY(val); break;
0411           case 'z': res.SetZ(val); break;
0412           default: break;
0413           }
0414         }
0415       }; //  Operations
0416       // ----------------------------------------------------------------------------
0417       Pnt3DGrammar() : Pnt3DGrammar::base_type(point) {
0418         point = list | ('(' >> list >> ')') | ('[' >> list >> ']');
0419         list = -(enc::no_case[qi::lit("x") | qi::lit("px")]  >> ':')
0420           >> scalar[op(qi::_val,qi::_1,'x')] >>
0421           ',' >> -(enc::no_case[qi::lit("y") | qi::lit("py")] >> ':')
0422           >> scalar[op(qi::_val,qi::_1,'y')] >>
0423           ',' >> -(enc::no_case[qi::lit("z") | qi::lit("pz")] >> ':')
0424           >> scalar[op(qi::_val,qi::_1,'z')];
0425       }
0426       // ----------------------------------------------------------------------------
0427       qi::rule<Iterator, ResultT(), Skipper> point, list;
0428       typename Grammar_<Iterator, Scalar, Skipper>::Grammar scalar;
0429       ph::function<Operations> op;
0430       // ----------------------------------------------------------------------------
0431     }; //   Pnt3DGrammar
0432     // ----------------------------------------------------------------------------
0433     // Register Pnt3DGrammar for ROOT::Math::PositionVector3D:
0434     // ----------------------------------------------------------------------------
0435     template <typename Iterator, typename T1, typename T2, typename Skipper>
0436     struct Grammar_<Iterator, ROOT::Math::PositionVector3D<T1,T2>, Skipper>{
0437       typedef Pnt3DGrammar<Iterator, ROOT::Math::PositionVector3D<T1,T2>, Skipper> Grammar;
0438     };
0439     // ----------------------------------------------------------------------------
0440     // Register Pnt3DGrammar for ROOT::Math::DisplacementVector3D:
0441     // ----------------------------------------------------------------------------
0442     template <typename Iterator, typename T1, typename T2, typename Skipper>
0443     struct Grammar_<Iterator, ROOT::Math::DisplacementVector3D<T1,T2>, Skipper>{
0444       typedef Pnt3DGrammar<Iterator,ROOT::Math::DisplacementVector3D<T1,T2>, Skipper> Grammar;
0445     };
0446     // ============================================================================
0447     template< typename Iterator, typename PointT, typename Skipper>
0448     struct Pnt4DGrammar : qi::grammar<Iterator, PointT(), Skipper>   {
0449       typedef PointT ResultT;
0450       typedef std::string ScalarT;
0451       //-----------------------------------------------------------------------------
0452       struct Operations {
0453         template <typename A, typename B = boost::fusion::unused_type,
0454                   typename C = boost::fusion::unused_type,
0455                   typename D = boost::fusion::unused_type>
0456         struct result { typedef void type; };
0457 
0458         void operator()(ResultT& res, const ScalarT& value,const char xyz) const{
0459           typename PointT::Scalar val = evaluate_string<typename PointT::Scalar>(value);
0460           switch(xyz){
0461           case 'x': res.SetPx(val); break;
0462           case 'y': res.SetPy(val); break;
0463           case 'z': res.SetPz(val); break;
0464           case 'e': res.SetE(val);  break;
0465           default: break;
0466           }
0467         }
0468         void operator()(ResultT& res, const ResultT& xyz) const{
0469           res.SetPx(xyz.Px());
0470           res.SetPy(xyz.Py());
0471           res.SetPz(xyz.Pz());
0472         }
0473       }; //   Operations
0474       // ----------------------------------------------------------------------------
0475       Pnt4DGrammar() : Pnt4DGrammar::base_type(point4d) {
0476         point4d = list4d | ('(' >> list4d >> ')') | ('[' >> list4d >> ']');
0477         list4d = (point3d[op(qi::_val,qi::_1)] >> enc::char_(";,")
0478                   >> e[op(qi::_val, qi::_1, 'e')])
0479           |
0480           (e[op(qi::_val,qi::_1, 'e')] >> enc::char_(";,")
0481            >> point3d[op(qi::_val, qi::_1)]);
0482         e =  -(enc::no_case[enc::char_("te")]  >> ':')
0483           >> scalar[qi::_val = qi::_1];
0484 
0485         point3d = list3d | ('(' >> list3d >> ')') | ('[' >> list3d >> ']');
0486         list3d = -(enc::no_case[qi::lit("x") | qi::lit("px")]  >> ':')
0487           >> scalar[op(qi::_val, qi::_1,'x')] >>
0488           ',' >> -(enc::no_case[qi::lit("y") | qi::lit("py")] >> ':')
0489           >> scalar[op(qi::_val, qi::_1,'y')] >>
0490           ',' >> -(enc::no_case[qi::lit("z") | qi::lit("pz")] >> ':')
0491           >> scalar[op(qi::_val, qi::_1,'z')];
0492       }
0493       // ----------------------------------------------------------------------------
0494       qi::rule<Iterator, ResultT(), Skipper> point3d, point4d, list3d,
0495         list4d;
0496       qi::rule<Iterator, ScalarT(), Skipper> e;
0497       typename Grammar_<Iterator, ScalarT, Skipper>::Grammar scalar;
0498       ph::function<Operations> op;
0499       // ----------------------------------------------------------------------------
0500     }; //   Pnt4DGrammar
0501     // ----------------------------------------------------------------------------
0502     // Register Pnt4DGrammar for ROOT::Math::LorentzVector:
0503     // ----------------------------------------------------------------------------
0504     template <typename Iterator, typename T1, typename Skipper>
0505     struct Grammar_<Iterator, ROOT::Math::LorentzVector<T1>, Skipper >   {
0506       typedef Pnt4DGrammar<Iterator, ROOT::Math::LorentzVector<T1>, Skipper> Grammar;
0507     };
0508     // ============================================================================
0509     template< typename Iterator, typename PointT, typename Skipper>
0510     struct Rot3DGrammar : qi::grammar<Iterator, PointT(), Skipper> {
0511       typedef PointT ResultT;
0512       typedef std::string Scalar;
0513       // ----------------------------------------------------------------------------
0514       struct Operations {
0515         template <typename A, typename B = boost::fusion::unused_type,
0516                   typename C = boost::fusion::unused_type,
0517                   typename D = boost::fusion::unused_type>
0518         struct result { typedef void type; };
0519         void operator()(ResultT& res, const Scalar& value,const char xyz) const{
0520           typename PointT::Scalar val = evaluate_string<typename PointT::Scalar>(value);
0521           switch(xyz)  {
0522           case 'x': res.SetPsi(val); break;
0523           case 'y': res.SetPhi(val); break;
0524           case 'z': res.SetTheta(val); break;
0525           default: break;
0526           }
0527         }
0528       }; //  Operations
0529       // ----------------------------------------------------------------------------
0530       Rot3DGrammar() : Rot3DGrammar::base_type(point) {
0531         point = list | ('(' >> list >> ')') | ('[' >> list >> ']');
0532         list = -(enc::no_case[qi::lit("x")]  >> ':')
0533           >> scalar[op(qi::_val,qi::_1,'x')] >>
0534           ',' >> -(enc::no_case[qi::lit("y")] >> ':')
0535           >> scalar[op(qi::_val,qi::_1,'y')] >>
0536           ',' >> -(enc::no_case[qi::lit("z")] >> ':')
0537           >> scalar[op(qi::_val,qi::_1,'z')];
0538       }
0539       // ----------------------------------------------------------------------------
0540       qi::rule<Iterator, ResultT(), Skipper> point, list;
0541       typename Grammar_<Iterator, Scalar, Skipper>::Grammar scalar;
0542       ph::function<Operations> op;
0543       // ----------------------------------------------------------------------------
0544     }; //   Rot3DGrammar
0545     // ----------------------------------------------------------------------------
0546     // Register Rot3DGrammar for ROOT::Math::PositionVector3D:
0547     // ----------------------------------------------------------------------------
0548     template <typename Iterator, typename Skipper>
0549     struct Grammar_<Iterator, ROOT::Math::RotationZYX, Skipper>{
0550       typedef Rot3DGrammar<Iterator, ROOT::Math::RotationZYX, Skipper> Grammar;
0551     };
0552  
0553     // ============================================================================
0554   }} //   dd4hep::Parsers
0555 #endif
0556 //============================================================================
0557 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!