#include <TriggerExpressionParser.h>

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)] 
                       );
  }