#include <TriggerExpressionParser.h>

Inheritance diagram for triggerExpression::Parser< Iterator >:

Public Member Functions
	Parser ()

Private Types
typedef qi::rule< Iterator, std::string(), ascii::space_type >	name_rule

typedef qi::rule< Iterator, Evaluator *(), ascii::space_type >	rule

typedef qi::rule< Iterator, unused_type(), ascii::space_type >	void_rule

Private Attributes
rule	element

rule	expression

rule	operand

rule	parenthesis

rule	prescale

rule	token

name_rule	token_alca

name_rule	token_dqm

name_rule	token_dst

name_rule	token_hlt

name_rule	token_l1

name_rule	token_l1tech

name_rule	token_step

rule	unary

Detailed Description

template<typename Iterator>
class triggerExpression::Parser< Iterator >

Definition at line 24 of file TriggerExpressionParser.h.

Member Typedef Documentation

template<typename Iterator>

typedef qi::rule<Iterator, std::string(), ascii::space_type> triggerExpression::Parser< Iterator >::name_rule

private

Definition at line 70 of file TriggerExpressionParser.h.

template<typename Iterator>

typedef qi::rule<Iterator, Evaluator*(), ascii::space_type> triggerExpression::Parser< Iterator >::rule

private

Definition at line 71 of file TriggerExpressionParser.h.

template<typename Iterator>

typedef qi::rule<Iterator, unused_type(), ascii::space_type> triggerExpression::Parser< Iterator >::void_rule

private

Definition at line 69 of file TriggerExpressionParser.h.

Constructor & Destructor Documentation

template<typename Iterator>

triggerExpression::Parser< Iterator >::Parser ( )

inline

Definition at line 27 of file TriggerExpressionParser.h.

            : 
     Parser::base_type(expression)
   {
     token_hlt       %= qi::raw[qi::lexeme["HLT_"    >> +(qi::char_("a-zA-Z0-9_*?"))]];
     token_alca      %= qi::raw[qi::lexeme["AlCa_"   >> +(qi::char_("a-zA-Z0-9_*?"))]];
     token_dqm       %= qi::raw[qi::lexeme["DQM_"    >> +(qi::char_("a-zA-Z0-9_*?"))]];
     token_dst       %= qi::raw[qi::lexeme["DST_"    >> +(qi::char_("a-zA-Z0-9_*?"))]];
     token_step      %= qi::raw[qi::lexeme["generation_step"]];
     token_l1        %= qi::raw[qi::lexeme["L1_"     >> +(qi::char_("a-zA-Z0-9_*?"))]];
     token_l1tech    %= qi::raw[qi::lexeme["L1Tech_" >> +(qi::char_("a-zA-Z0-9_*?"))]];
 
     token            = ( token_hlt                      [qi::_val = new_<HLTReader>(qi::_1)]
                        | token_alca                     [qi::_val = new_<HLTReader>(qi::_1)]
                        | token_dqm                      [qi::_val = new_<HLTReader>(qi::_1)]
                        | token_dst                      [qi::_val = new_<HLTReader>(qi::_1)]
                        | token_step                     [qi::_val = new_<HLTReader>(qi::_1)]
                        | token_l1                       [qi::_val = new_<L1Reader>(qi::_1)]
                        | token_l1tech                   [qi::_val = new_<L1TechReader>(qi::_1)]
                        | qi::lit("TRUE")                [qi::_val = new_<Constant>(true)]
                        | qi::lit("FALSE")               [qi::_val = new_<Constant>(false)]
                        );
 
     parenthesis     %= ('(' >> expression >> ')');
 
     element         %= (token | parenthesis);
 
     prescale         = (element >> '/' >> qi::uint_)    [qi::_val = new_<Prescaler> (qi::_1, qi::_2)];
 
     operand         %= (prescale | element);
 
     unary            = ( operand                        [qi::_val = qi::_1]
                        | (qi::lit("NOT") >> operand)    [qi::_val = new_<OperatorNot> (qi::_1)]
                        );
 
     expression       = unary                            [qi::_val = qi::_1] 
                        >> *(
                               (qi::lit("AND") >> unary) [qi::_val = new_<OperatorAnd> (qi::_val, qi::_1)] 
                             | (qi::lit("OR")  >> unary) [qi::_val = new_<OperatorOr>  (qi::_val, qi::_1)] 
                        );
   }