Back to home page

EIC code displayed by LXR
 
 

    

Warning, file /include/Gaudi/Parsers/Grammars.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

0001 /***********************************************************************************\
0002 * (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
0003 *                                                                                   *
0004 * This software is distributed under the terms of the Apache version 2 licence,     *
0005 * copied verbatim in the file "LICENSE".                                            *
0006 *                                                                                   *
0007 * In applying this licence, CERN does not waive the privileges and immunities       *
0008 * granted to it by virtue of its status as an Intergovernmental Organization        *
0009 * or submit itself to any jurisdiction.                                             *
0010 \***********************************************************************************/
0011 #pragma once
0012 
0013 #ifdef __GNUC__
0014 #  pragma GCC system_header
0015 #endif
0016 // ============================================================================
0017 // Include files
0018 // ============================================================================
0019 // STD:
0020 //==============================================================================
0021 #include <list>
0022 #include <map>
0023 #include <set>
0024 #include <string>
0025 #include <tuple>
0026 #include <type_traits>
0027 #include <unordered_map>
0028 #include <unordered_set>
0029 #include <vector>
0030 //==============================================================================
0031 // Boost:
0032 //==============================================================================
0033 #include <boost/fusion/include/std_pair.hpp>
0034 #include <boost/fusion/include/unused.hpp>
0035 #if ( BOOST_VERSION >= 187000 ) && ( BOOST_VERSION < 188000 )
0036 #  define BOOST_ALLOW_DEPRECATED_HEADERS
0037 #endif
0038 #include <boost/spirit/include/qi.hpp>
0039 #undef BOOST_ALLOW_DEPRECATED_HEADERS
0040 
0041 #include <boost/phoenix/core.hpp>
0042 #include <boost/phoenix/operator.hpp>
0043 
0044 #include <boost/spirit/repository/include/qi_confix.hpp>
0045 //==============================================================================
0046 // Gaudi:
0047 //==============================================================================
0048 #include <GaudiKernel/HashMap.h>
0049 #include <GaudiKernel/HistoDef.h>
0050 #include <GaudiKernel/Point3DTypes.h>
0051 #include <GaudiKernel/Point4DTypes.h>
0052 #include <GaudiKernel/StringKey.h>
0053 #include <GaudiKernel/VectorMap.h>
0054 //==============================================================================
0055 namespace Gaudi {
0056   namespace Parsers {
0057     //==============================================================================
0058     // Namespace aliases:
0059     //==============================================================================
0060     namespace sp  = boost::spirit;
0061     namespace ph  = boost::phoenix;
0062     namespace qi  = sp::qi;
0063     namespace enc = sp::ascii;
0064     namespace rep = sp::repository;
0065     //==============================================================================
0066     // Grammars
0067     //==============================================================================
0068     typedef std::string::const_iterator DefaultIterator;
0069     typedef enc::space_type             DefaultSkipper;
0070     //==============================================================================
0071     template <typename Iterator, typename T, typename Skipper, class Enable = void>
0072     struct Grammar_ {
0073       /* READ THIS IF YOUR COMPILE BREAKS ON THE FOLLOWING LINE
0074        *
0075        * To users: You have to ask developers to implement parser for your type T
0076        * To developer: You have to implement and register Grammar for type T
0077        *
0078        */
0079       BOOST_MPL_ASSERT_MSG( false, GRAMMAR_FOR_TYPE_DOES_NOT_EXISTS, ( T ) );
0080     };
0081 
0082 #define REGISTER_GRAMMAR( ResultType, GrammarName )                                                                    \
0083   template <typename Iterator, typename Skipper>                                                                       \
0084   struct Grammar_<Iterator, ResultType, Skipper> {                                                                     \
0085     typedef GrammarName<Iterator, Skipper> Grammar;                                                                    \
0086   }
0087     //==============================================================================
0088     template <typename Iterator>
0089     struct SkipperGrammar : qi::grammar<Iterator> {
0090       SkipperGrammar() : SkipperGrammar::base_type( comments ) {
0091         comments = enc::space | rep::confix( "/*", "*/" )[*( qi::char_ - "*/" )] |
0092                    rep::confix( "//", ( sp::eol | sp::eoi ) )[*( qi::char_ - ( sp::eol | sp::eoi ) )];
0093       }
0094       qi::rule<Iterator> comments;
0095     };
0096     //==============================================================================
0097     template <typename Iterator, typename Skipper>
0098     struct StringGrammar : qi::grammar<Iterator, std::string(), qi::locals<char>, Skipper> {
0099       //------------------------------------------------------------------------------
0100       typedef std::string ResultT;
0101       //------------------------------------------------------------------------------
0102       StringGrammar() : StringGrammar::base_type( str ) {
0103         begin_quote = enc::char_( "\"'" );
0104         quote       = enc::char_( qi::_r1 );
0105 
0106         str = qi::lexeme[begin_quote[qi::_a = qi::_1] >
0107                          *( ( enc::char_( '\\' ) >> quote( qi::_a ) )[qi::_val += qi::_a] |
0108                             ( enc::char_( '\\' ) >> enc::char_( '\\' ) )[qi::_val += '\\'] |
0109                             ( enc::char_[qi::_val += qi::_1] - quote( qi::_a ) ) ) > quote( qi::_a )];
0110       }
0111       //------------------------------------------------------------------------------
0112       qi::rule<Iterator, std::string(), qi::locals<char>, Skipper> str;
0113       qi::rule<Iterator, char()>                                   begin_quote;
0114       qi::rule<Iterator, void( char )>                             quote;
0115       //------------------------------------------------------------------------------
0116     };
0117     REGISTER_GRAMMAR( std::string, StringGrammar );
0118     REGISTER_GRAMMAR( Gaudi::StringKey, StringGrammar );
0119     //==============================================================================
0120     template <typename Iterator, typename Skipper>
0121     struct CharGrammar : qi::grammar<Iterator, char(), Skipper> {
0122       typedef char ResultT;
0123       CharGrammar() : CharGrammar::base_type( ch ) {
0124         ch = qi::int_parser<char>() | '\'' >> ( qi::char_ - '\'' ) >> '\'';
0125       }
0126       qi::rule<Iterator, char(), Skipper> ch;
0127     };
0128     REGISTER_GRAMMAR( char, CharGrammar );
0129     //==============================================================================
0130     template <typename Iterator, typename Skipper>
0131     struct BoolGrammar : qi::grammar<Iterator, bool(), Skipper> {
0132       typedef bool ResultT;
0133       BoolGrammar() : BoolGrammar::base_type( boolean_literal ) {
0134         boolean_literal = ( qi::lit( "true" ) | "True" | "TRUE" | "1" )[qi::_val = true] |
0135                           ( qi::lit( "false" ) | "False" | "FALSE" | "0" )[qi::_val = false];
0136       }
0137       qi::rule<Iterator, bool(), Skipper> boolean_literal;
0138     };
0139     REGISTER_GRAMMAR( bool, BoolGrammar );
0140     //==============================================================================
0141     template <typename Iterator, typename RT, typename Skipper>
0142     struct IntGrammar : qi::grammar<Iterator, RT(), Skipper> {
0143       typedef RT ResultT;
0144       IntGrammar() : IntGrammar::base_type( integer ) {
0145         integer = qi::int_parser<RT>()[qi::_val = qi::_1] >> -qi::no_case[qi::char_( 'L' )];
0146       }
0147       qi::rule<Iterator, RT(), Skipper> integer;
0148     };
0149     // ----------------------------------------------------------------------------
0150     // Register IntGrammar:
0151     // ----------------------------------------------------------------------------
0152     template <typename Iterator, std::integral T, typename Skipper>
0153     struct Grammar_<Iterator, T, Skipper> {
0154       typedef IntGrammar<Iterator, T, Skipper> Grammar;
0155     };
0156     //==============================================================================
0157     template <typename Iterator, typename RT, typename Skipper>
0158     struct RealGrammar : qi::grammar<Iterator, RT(), Skipper> {
0159       typedef RT ResultT;
0160       RealGrammar() : RealGrammar::base_type( real ) { real = qi::real_parser<RT>(); }
0161       qi::rule<Iterator, RT(), Skipper> real;
0162     };
0163     // ----------------------------------------------------------------------------
0164     // Register RealGrammar:
0165     // ----------------------------------------------------------------------------
0166     template <typename Iterator, std::floating_point T, typename Skipper>
0167     struct Grammar_<Iterator, T, Skipper> {
0168       typedef RealGrammar<Iterator, T, Skipper> Grammar;
0169     };
0170     //==============================================================================
0171     // Grammar for std::tuples
0172     //==============================================================================
0173     template <typename T>
0174     struct tuple_remove_first_type {};
0175 
0176     template <typename T>
0177     struct tuple_get_first_type {};
0178 
0179     template <typename T, typename... Ts>
0180     struct tuple_remove_first_type<std::tuple<T, Ts...>> {
0181       typedef std::tuple<Ts...> type;
0182     };
0183 
0184     template <typename T, typename... Ts>
0185     struct tuple_get_first_type<std::tuple<T, Ts...>> {
0186       typedef T type;
0187     };
0188 
0189     // ----------------------------------------------------------------------------
0190 
0191     template <typename Iterator, typename TupleT, std::size_t N, typename Skipper>
0192     struct TupleInnerGrammar
0193         : qi::grammar<Iterator, TupleT(), qi::locals<typename tuple_get_first_type<TupleT>::type>, Skipper> {
0194       //---------------------------------------------------------------------------
0195       typedef TupleT                                         ResultT;
0196       typedef typename tuple_remove_first_type<TupleT>::type TailT;
0197       typedef typename tuple_get_first_type<TupleT>::type    HeadT;
0198       //---------------------------------------------------------------------------
0199       struct Operations {
0200         //----------------------------------------------------------------------
0201 
0202         void operator()( ResultT& res, HeadT& head, TailT& tail ) const {
0203           res = std::tuple_cat( std::tuple<HeadT>( head ), tail );
0204         }
0205         //----------------------------------------------------------------------
0206       };
0207       //---------------------------------------------------------------------------
0208       TupleInnerGrammar() : TupleInnerGrammar::base_type( tup ) {
0209         tup = grHead[qi::_a = qi::_1] >> ',' >> grLast[op( qi::_val, qi::_a, qi::_1 )];
0210       }
0211 
0212       TupleInnerGrammar<Iterator, TailT, N - 1, Skipper>   grLast;
0213       typename Grammar_<Iterator, HeadT, Skipper>::Grammar grHead;
0214 
0215       qi::rule<Iterator, ResultT(), qi::locals<HeadT>, Skipper> tup;
0216       ph::function<Operations>                                  op;
0217     };
0218 
0219     template <typename Iterator, typename TupleT, typename Skipper>
0220     struct TupleInnerGrammar<Iterator, TupleT, 1, Skipper> : qi::grammar<Iterator, TupleT(), Skipper> {
0221       //---------------------------------------------------------------------------
0222       typedef TupleT ResultT;
0223       // typedef typename ResultT::value_type Tuple1T;
0224       //---------------------------------------------------------------------------
0225       struct Operations {
0226         //---------------------------------------------------------------------
0227         void operator()( ResultT& res, const std::tuple_element_t<0, ResultT>& val ) const {
0228           res                = ResultT();
0229           std::get<0>( res ) = val;
0230         }
0231         //----------------------------------------------------------------------
0232       };
0233       //---------------------------------------------------------------------------
0234       TupleInnerGrammar() : TupleInnerGrammar::base_type( tup ) { tup = grFirst[op( qi::_val, qi::_1 )]; }
0235 
0236       typename Grammar_<Iterator, std::tuple_element_t<0, ResultT>, Skipper>::Grammar grFirst;
0237 
0238       qi::rule<Iterator, ResultT(), Skipper> tup;
0239       ph::function<Operations>               op;
0240     };
0241 
0242     // ----------------------------------------------------------------------------
0243     template <typename Iterator, typename TupleT, std::size_t N, typename Skipper>
0244     struct TupleGrammar : qi::grammar<Iterator, TupleT(), qi::locals<char>, Skipper> {
0245       typedef TupleT ResultT;
0246       TupleGrammar() : TupleGrammar::base_type( tup ) {
0247         begin = enc::char_( '[' )[qi::_val = ']'] | enc::char_( '(' )[qi::_val = ')'];
0248         end   = *( enc::char_( ',' ) ) >> enc::char_( qi::_r1 );
0249 
0250         tup = begin[qi::_a = qi::_1] >> grTuple[qi::_val = qi::_1] >> end( qi::_a );
0251       }
0252 
0253       qi::rule<Iterator, char()>                               begin;
0254       qi::rule<Iterator, void( char )>                         end;
0255       qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> tup;
0256       TupleInnerGrammar<Iterator, TupleT, N, Skipper>          grTuple;
0257     };
0258 
0259     // -----------------------------------------------------------------------------
0260     // Register TupleGrammar for std::tuple:
0261     // ----------------------------------------------------------------------------
0262     template <typename Iterator, typename Skipper, typename... Args>
0263     struct Grammar_<Iterator, std::tuple<Args...>, Skipper> {
0264       typedef TupleGrammar<Iterator, std::tuple<Args...>, sizeof...( Args ), Skipper> Grammar;
0265     };
0266     //==============================================================================
0267     template <typename Iterator, typename VectorT, typename Skipper>
0268     struct VectorGrammar : qi::grammar<Iterator, VectorT(), qi::locals<char>, Skipper> {
0269       //------------------------------------------------------------------------------
0270       typedef VectorT ResultT;
0271       //------------------------------------------------------------------------------
0272       VectorGrammar() : VectorGrammar::base_type( vec ) {
0273         begin =
0274             enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'] | enc::char_( '(' )[qi::_val = ')'];
0275         end  = *( enc::char_( ',' ) ) >> enc::char_( qi::_r1 );
0276         list = elementGrammar % ',';
0277         vec  = begin[qi::_a = qi::_1] >> -list[qi::_val = qi::_1] >> end( qi::_a );
0278       }
0279       // ----------------------------------------------------------------------------
0280       typename Grammar_<Iterator, typename VectorT::value_type, Skipper>::Grammar elementGrammar;
0281       qi::rule<Iterator, char()>                                                  begin;
0282       qi::rule<Iterator, void( char )>                                            end;
0283 
0284       qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> vec;
0285       qi::rule<Iterator, ResultT(), Skipper>                   list;
0286       // ----------------------------------------------------------------------------
0287     };
0288     // ----------------------------------------------------------------------------
0289     // Register VectorGrammar for std::vector:
0290     // ----------------------------------------------------------------------------
0291     template <typename Iterator, typename InnerT, typename AllocatorT, typename Skipper>
0292     struct Grammar_<Iterator, std::vector<InnerT, AllocatorT>, Skipper> {
0293       typedef VectorGrammar<Iterator, std::vector<InnerT, AllocatorT>, Skipper> Grammar;
0294     };
0295     // ----------------------------------------------------------------------------
0296     // Register VectorGrammar for std::list:
0297     // ----------------------------------------------------------------------------
0298     template <typename Iterator, typename InnerT, typename AllocatorT, typename Skipper>
0299     struct Grammar_<Iterator, std::list<InnerT, AllocatorT>, Skipper> {
0300       typedef VectorGrammar<Iterator, std::list<InnerT, AllocatorT>, Skipper> Grammar;
0301     };
0302     // ----------------------------------------------------------------------------
0303     // Register VectorGrammar for std::set:
0304     // ----------------------------------------------------------------------------
0305     template <typename Iterator, typename InnerT, typename CompareT, typename AllocatorT, typename Skipper>
0306     struct Grammar_<Iterator, std::set<InnerT, CompareT, AllocatorT>, Skipper> {
0307       typedef VectorGrammar<Iterator, std::set<InnerT, CompareT, AllocatorT>, Skipper> Grammar;
0308     };
0309 
0310     //==============================================================================
0311     template <typename Iterator, typename SetT, typename Skipper>
0312     struct SetGrammar : qi::grammar<Iterator, SetT(), qi::locals<char>, Skipper> {
0313       SetGrammar() : SetGrammar::base_type( set ) {
0314         // special handling of empty set as "{}" is always a dict
0315         set = qi::lit( "set()" ) | grVector;
0316       }
0317       VectorGrammar<Iterator, SetT, Skipper>                grVector;
0318       qi::rule<Iterator, SetT(), qi::locals<char>, Skipper> set;
0319     };
0320     // ----------------------------------------------------------------------------
0321     // Register SetGrammar for std::unordered_set:
0322     // ----------------------------------------------------------------------------
0323     template <typename Iterator, typename InnerT, typename HashT, typename CompareT, typename AllocatorT,
0324               typename Skipper>
0325     struct Grammar_<Iterator, std::unordered_set<InnerT, HashT, CompareT, AllocatorT>, Skipper> {
0326       typedef SetGrammar<Iterator, std::unordered_set<InnerT, HashT, CompareT, AllocatorT>, Skipper> Grammar;
0327     };
0328 
0329     //==============================================================================
0330     template <typename Iterator, typename PairT, typename Skipper>
0331     struct PairGrammar : qi::grammar<Iterator, PairT(), qi::locals<char>, Skipper> {
0332       //------------------------------------------------------------------------------
0333       typedef PairT                       ResultT;
0334       typedef typename PairT::first_type  first_type;
0335       typedef typename PairT::second_type second_type;
0336       //------------------------------------------------------------------------------
0337       struct first {};
0338       struct second {};
0339       //------------------------------------------------------------------------------
0340       PairGrammar() : PairGrammar( "," ) {}
0341       PairGrammar( const std::string& delimeter ) : PairGrammar::base_type( pair ) {
0342         begin   = enc::char_( '(' )[qi::_val = ')'] | enc::char_( '[' )[qi::_val = ']'];
0343         end     = qi::char_( qi::_r1 );
0344         pair    = begin[qi::_a = qi::_1] >> pair_in[qi::_val = qi::_1] >> end( qi::_a );
0345         pair_in = key >> qi::lit( delimeter ) >> value;
0346       }
0347       // ----------------------------------------------------------------------------
0348       typename Grammar_<Iterator, typename PairT::first_type, Skipper>::Grammar  key;
0349       typename Grammar_<Iterator, typename PairT::second_type, Skipper>::Grammar value;
0350       qi::rule<Iterator, char()>                                                 begin;
0351       qi::rule<Iterator, void( char )>                                           end;
0352       qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper>                   pair;
0353       qi::rule<Iterator, ResultT(), Skipper>                                     pair_in;
0354       // ph::function<Operations> op;
0355       // ----------------------------------------------------------------------------
0356     }; // END PairGrammar
0357     // ----------------------------------------------------------------------------
0358     // Register PairGrammar:
0359     // ----------------------------------------------------------------------------
0360     template <typename Iterator, typename KeyT, typename ValueT, typename Skipper>
0361     struct Grammar_<Iterator, std::pair<KeyT, ValueT>, Skipper> {
0362       typedef PairGrammar<Iterator, std::pair<KeyT, ValueT>, Skipper> Grammar;
0363     };
0364     // ============================================================================
0365     template <typename Iterator, typename MapT, typename Skipper>
0366     struct MapGrammar : qi::grammar<Iterator, MapT(), Skipper> {
0367       //------------------------------------------------------------------------------
0368       typedef MapT                       ResultT;
0369       typedef typename MapT::key_type    KeyT;
0370       typedef typename MapT::mapped_type MappedT;
0371       typedef std::pair<KeyT, MappedT>   PairT;
0372 
0373       typedef std::vector<PairT> VectorPairT;
0374       //------------------------------------------------------------------------------
0375       struct tag_key {};
0376       struct tag_mapped {};
0377       struct Operations {
0378         //----------------------------------------------------------------------
0379         void operator()( ResultT& res, const VectorPairT& vec ) const {
0380           for ( auto cur = vec.begin(); cur != vec.end(); ++cur ) { res.insert( *cur ); }
0381         }
0382         void operator()( PairT& res, const KeyT& key, tag_key ) const { res.first = key; }
0383         void operator()( PairT& res, const MappedT& value, tag_mapped ) const { res.second = value; }
0384         //----------------------------------------------------------------------
0385       };
0386       //------------------------------------------------------------------------------
0387       MapGrammar() : MapGrammar::base_type( map ) {
0388         pair = key[op( qi::_val, qi::_1, tag_key() )] > ( qi::lit( ':' ) | '=' ) >
0389                value[op( qi::_val, qi::_1, tag_mapped() )];
0390         list = -( pair % enc::char_( ',' ) );
0391         map  = ( ( '[' >> list >> ']' ) | ( '{' >> list >> '}' ) | ( '[' >> list >> ',' >> ']' ) |
0392                 ( '{' >> list >> ',' >> '}' ) )[op( qi::_val, qi::_1 )];
0393       }
0394       // ----------------------------------------------------------------------------
0395       typename Grammar_<Iterator, typename MapT::key_type, Skipper>::Grammar    key;
0396       typename Grammar_<Iterator, typename MapT::mapped_type, Skipper>::Grammar value;
0397       qi::rule<Iterator, PairT(), Skipper>                                      pair;
0398       qi::rule<Iterator, VectorPairT(), Skipper>                                list;
0399       qi::rule<Iterator, ResultT(), Skipper>                                    map;
0400       ph::function<Operations>                                                  op;
0401       // ----------------------------------------------------------------------------
0402     };
0403     // ----------------------------------------------------------------------------
0404     // Register MapGrammar for std::map:
0405     // ----------------------------------------------------------------------------
0406     template <typename Iterator, typename KeyT, typename ValueT, typename KeyCompareT, typename AllocatorT,
0407               typename Skipper>
0408     struct Grammar_<Iterator, std::map<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> {
0409       typedef MapGrammar<Iterator, std::map<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> Grammar;
0410     };
0411     // ----------------------------------------------------------------------------
0412     // Register MapGrammar for std::unordered_map:
0413     // ----------------------------------------------------------------------------
0414     template <typename Iterator, typename KeyT, typename ValueT, typename HashT, typename KeyCompareT,
0415               typename AllocatorT, typename Skipper>
0416     struct Grammar_<Iterator, std::unordered_map<KeyT, ValueT, HashT, KeyCompareT, AllocatorT>, Skipper> {
0417       typedef MapGrammar<Iterator, std::unordered_map<KeyT, ValueT, HashT, KeyCompareT, AllocatorT>, Skipper> Grammar;
0418     };
0419     // ----------------------------------------------------------------------------
0420     // Register MapGrammar for GaudiUtils::VectorMap:
0421     // ----------------------------------------------------------------------------
0422     template <typename Iterator, typename KeyT, typename ValueT, typename KeyCompareT, typename AllocatorT,
0423               typename Skipper>
0424     struct Grammar_<Iterator, GaudiUtils::VectorMap<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> {
0425       typedef MapGrammar<Iterator, GaudiUtils::VectorMap<KeyT, ValueT, KeyCompareT, AllocatorT>, Skipper> Grammar;
0426     };
0427     // ============================================================================
0428     template <typename Iterator, typename PointT, typename Skipper>
0429     struct Pnt3DGrammar : qi::grammar<Iterator, PointT(), Skipper> {
0430       typedef PointT                  ResultT;
0431       typedef typename PointT::Scalar Scalar;
0432       // ----------------------------------------------------------------------------
0433       struct Operations {
0434         void operator()( ResultT& res, const Scalar& scalar, const char xyz ) const {
0435           switch ( xyz ) {
0436           case 'x':
0437             res.SetX( scalar );
0438             break;
0439           case 'y':
0440             res.SetY( scalar );
0441             break;
0442           case 'z':
0443             res.SetZ( scalar );
0444             break;
0445           default:
0446             break;
0447           }
0448         }
0449       }; //  Operations
0450          // ----------------------------------------------------------------------------
0451       Pnt3DGrammar() : Pnt3DGrammar::base_type( point ) {
0452         point = list | ( '(' >> list >> ')' ) | ( '[' >> list >> ']' );
0453         list  = -( enc::no_case[qi::lit( "x" ) | qi::lit( "px" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'x' )] >>
0454                ',' >> -( enc::no_case[qi::lit( "y" ) | qi::lit( "py" )] >> ':' ) >>
0455                scalar[op( qi::_val, qi::_1, 'y' )] >> ',' >>
0456                -( enc::no_case[qi::lit( "z" ) | qi::lit( "pz" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'z' )];
0457       }
0458       // ----------------------------------------------------------------------------
0459       qi::rule<Iterator, ResultT(), Skipper>                point, list;
0460       typename Grammar_<Iterator, Scalar, Skipper>::Grammar scalar;
0461       ph::function<Operations>                              op;
0462       // ----------------------------------------------------------------------------
0463     }; //   Pnt3DGrammar
0464     // ----------------------------------------------------------------------------
0465     // Register Pnt3DGrammar for ROOT::Math::PositionVector3D:
0466     // ----------------------------------------------------------------------------
0467     template <typename Iterator, typename T1, typename T2, typename Skipper>
0468     struct Grammar_<Iterator, ROOT::Math::PositionVector3D<T1, T2>, Skipper> {
0469       typedef Pnt3DGrammar<Iterator, ROOT::Math::PositionVector3D<T1, T2>, Skipper> Grammar;
0470     };
0471     // ----------------------------------------------------------------------------
0472     // Register Pnt3DGrammar for ROOT::Math::DisplacementVector3D:
0473     // ----------------------------------------------------------------------------
0474     template <typename Iterator, typename T1, typename T2, typename Skipper>
0475     struct Grammar_<Iterator, ROOT::Math::DisplacementVector3D<T1, T2>, Skipper> {
0476       typedef Pnt3DGrammar<Iterator, ROOT::Math::DisplacementVector3D<T1, T2>, Skipper> Grammar;
0477     };
0478     // ============================================================================
0479     template <typename Iterator, typename PointT, typename Skipper>
0480     struct Pnt4DGrammar : qi::grammar<Iterator, PointT(), Skipper> {
0481       typedef PointT                  ResultT;
0482       typedef typename PointT::Scalar ScalarT;
0483       //-----------------------------------------------------------------------------
0484       struct Operations {
0485 
0486         void operator()( ResultT& res, const ScalarT& scalar, const char xyz ) const {
0487           switch ( xyz ) {
0488           case 'x':
0489             res.SetPx( scalar );
0490             break;
0491           case 'y':
0492             res.SetPy( scalar );
0493             break;
0494           case 'z':
0495             res.SetPz( scalar );
0496             break;
0497           case 'e':
0498             res.SetE( scalar );
0499             break;
0500           default:
0501             break;
0502           }
0503         }
0504         void operator()( ResultT& res, const ResultT& xyz ) const {
0505           res.SetPx( xyz.Px() );
0506           res.SetPy( xyz.Py() );
0507           res.SetPz( xyz.Pz() );
0508         }
0509       }; //   Operations
0510          // ----------------------------------------------------------------------------
0511       Pnt4DGrammar() : Pnt4DGrammar::base_type( point4d ) {
0512         point4d = list4d | ( '(' >> list4d >> ')' ) | ( '[' >> list4d >> ']' );
0513         list4d  = ( point3d[op( qi::_val, qi::_1 )] >> enc::char_( ";," ) >> e[op( qi::_val, qi::_1, 'e' )] ) |
0514                  ( e[op( qi::_val, qi::_1, 'e' )] >> enc::char_( ";," ) >> point3d[op( qi::_val, qi::_1 )] );
0515         e = -( enc::no_case[enc::char_( "te" )] >> ':' ) >> scalar[qi::_val = qi::_1];
0516 
0517         point3d = list3d | ( '(' >> list3d >> ')' ) | ( '[' >> list3d >> ']' );
0518         list3d  = -( enc::no_case[qi::lit( "x" ) | qi::lit( "px" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'x' )] >>
0519                  ',' >> -( enc::no_case[qi::lit( "y" ) | qi::lit( "py" )] >> ':' ) >>
0520                  scalar[op( qi::_val, qi::_1, 'y' )] >> ',' >>
0521                  -( enc::no_case[qi::lit( "z" ) | qi::lit( "pz" )] >> ':' ) >> scalar[op( qi::_val, qi::_1, 'z' )];
0522       }
0523       // ----------------------------------------------------------------------------
0524       qi::rule<Iterator, ResultT(), Skipper>                 point3d, point4d, list3d, list4d;
0525       qi::rule<Iterator, ScalarT(), Skipper>                 e;
0526       typename Grammar_<Iterator, ScalarT, Skipper>::Grammar scalar;
0527       ph::function<Operations>                               op;
0528       // ----------------------------------------------------------------------------
0529     }; //   Pnt4DGrammar
0530     // ----------------------------------------------------------------------------
0531     // Register Pnt4DGrammar for ROOT::Math::LorentzVector:
0532     // ----------------------------------------------------------------------------
0533     template <typename Iterator, typename T1, typename Skipper>
0534     struct Grammar_<Iterator, ROOT::Math::LorentzVector<T1>, Skipper> {
0535       typedef Pnt4DGrammar<Iterator, ROOT::Math::LorentzVector<T1>, Skipper> Grammar;
0536     };
0537     // ============================================================================
0538     template <typename Iterator, typename Skipper>
0539     struct Histo1DGrammar : qi::grammar<Iterator, Gaudi::Histo1DDef(), qi::locals<char>, Skipper> {
0540       typedef Gaudi::Histo1DDef ResultT;
0541       // ----------------------------------------------------------------------------
0542       struct Operations {
0543         void operator()( ResultT& res, const std::string& title ) const { res.setTitle( title ); }
0544         void operator()( ResultT& res, const double& val, const char lh ) const {
0545           switch ( lh ) {
0546           case 'l':
0547             res.setLowEdge( val );
0548             break;
0549           case 'h':
0550             res.setHighEdge( val );
0551             break;
0552           default:
0553             break;
0554           }
0555         }
0556         void operator()( ResultT& res, int val ) const { res.setBins( val ); }
0557         void operator()( ResultT& res ) const {}
0558       }; //   Operations
0559          // ----------------------------------------------------------------------------
0560       Histo1DGrammar() : Histo1DGrammar::base_type( hist ) {
0561         val1 = title[op( qi::_val, qi::_1 )] >> ',' >> qi::double_[op( qi::_val, qi::_1, 'l' )] >> ',' >>
0562                qi::double_[op( qi::_val, qi::_1, 'h' )] >> -( ',' >> qi::int_[op( qi::_val, qi::_1 )] );
0563         val2 = qi::double_[op( qi::_val, qi::_1, 'l' )] >> ',' >> qi::double_[op( qi::_val, qi::_1, 'h' )] >> ',' >>
0564                title[op( qi::_val, qi::_1 )] >> -( ',' >> qi::int_[op( qi::_val, qi::_1 )] );
0565         val3 = qi::double_[op( qi::_val, qi::_1, 'l' )] >> ',' >> qi::double_[op( qi::_val, qi::_1, 'h' )] >>
0566                -( ',' >> title[op( qi::_val, qi::_1 )] ) >> -( ',' >> qi::int_[op( qi::_val, qi::_1 )] );
0567         begin = enc::char_( '[' )[qi::_val = ']'] | enc::char_( '(' )[qi::_val = ')'];
0568         end   = enc::char_( qi::_r1 );
0569         hist  = begin[qi::_a = qi::_1] >> ( val1 | val2 | val3 )[qi::_val = qi::_1] >> end( qi::_a );
0570       }
0571       // ----------------------------------------------------------------------------
0572       qi::rule<Iterator, ResultT(), qi::locals<char>, Skipper> hist;
0573       qi::rule<Iterator, ResultT(), Skipper>                   val1, val2, val3;
0574       qi::rule<Iterator, char()>                               begin;
0575       qi::rule<Iterator, void( char )>                         end;
0576       StringGrammar<Iterator, Skipper>                         title;
0577       ph::function<Operations>                                 op;
0578       // ----------------------------------------------------------------------------
0579     }; //   Histo1DGrammar
0580     // ----------------------------------------------------------------------------
0581     REGISTER_GRAMMAR( Gaudi::Histo1DDef, Histo1DGrammar );
0582     // ============================================================================
0583     template <typename Iterator, typename Skipper>
0584     struct KeyValueGrammar : qi::grammar<Iterator, std::pair<std::string, std::string>(), Skipper> {
0585       //------------------------------------------------------------------------------
0586       typedef std::pair<std::string, std::string> ResultT;
0587       //------------------------------------------------------------------------------
0588       struct first {};
0589       struct second {};
0590 
0591       KeyValueGrammar() : KeyValueGrammar::base_type( pair ) {
0592         //------------------------------------------------------------------------------
0593         pair = gstring >> ":" >> +enc::char_;
0594       }
0595       // ----------------------------------------------------------------------------
0596       StringGrammar<Iterator, Skipper>       gstring;
0597       qi::rule<Iterator, ResultT(), Skipper> pair;
0598       // ----------------------------------------------------------------------------
0599     }; // END KeyValueGrammar
0600     // We don't register KeyalueGrammar because it's a special parser
0601     // ============================================================================
0602   } // namespace Parsers
0603 } // namespace Gaudi
[ 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!