#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

Private Attributes
rule	element

rule	expression

rule	operand

rule	parenthesis

rule	prescale

rule	token

name_rule	token_l1algo

name_rule	token_path

rule	unary

Detailed Description

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

Definition at line 23 of file TriggerExpressionParser.h.

Member Typedef Documentation

◆ name_rule

template<typename Iterator>

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

private

Definition at line 48 of file TriggerExpressionParser.h.

◆ rule

template<typename Iterator>

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

private

Definition at line 49 of file TriggerExpressionParser.h.

Constructor & Destructor Documentation

◆ Parser()

template<typename Iterator>

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

inline

Definition at line 25 of file TriggerExpressionParser.h.

              : Parser::base_type(expression) {
       token_l1algo %= qi::raw[qi::lexeme["L1_" >> +(qi::char_("a-zA-Z0-9_*?"))]];
       token_path %= qi::raw[qi::lexeme[+(qi::char_("a-zA-Z0-9_*?"))]];
  
       token = (qi::lit("TRUE")[qi::_val = new_<Constant>(true)] | qi::lit("FALSE")[qi::_val = new_<Constant>(false)] |
                token_l1algo[qi::_val = new_<L1uGTReader>(qi::_1)] | token_path[qi::_val = new_<PathReader>(qi::_1)]);
  
       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)]);
     }