Inheritance diagram for pathStatusExpression::Grammar< Iterator >:

Public Member Functions
	Grammar (ShuntingYardAlgorithm *algorithm)

Private Attributes
qi::rule< Iterator >	afterOperator

ShuntingYardAlgorithm *	algorithm_

qi::rule< Iterator, ascii::space_type >	binaryOperand

qi::rule< Iterator >	binaryOperator

qi::rule< Iterator >	binaryOperatorTest

qi::rule< Iterator, ascii::space_type >	expression

qi::rule< Iterator >	pathName

qi::rule< Iterator >	unaryOperator

Detailed Description

template<typename Iterator>
class pathStatusExpression::Grammar< Iterator >

Definition at line 275 of file L1GTAlgoBlockProducer.cc.

Constructor & Destructor Documentation

◆ Grammar()

template<typename Iterator>

pathStatusExpression::Grammar< Iterator >::Grammar ( ShuntingYardAlgorithm * algorithm )

inline

Definition at line 277 of file L1GTAlgoBlockProducer.cc.

                                               : Grammar::base_type(expression), algorithm_(algorithm) {
       // setup functors that call into shunting algorithm while parsing the logical expression
       auto addPathName = std::bind(&ShuntingYardAlgorithm::addPathName, algorithm_, std::placeholders::_1);
       auto addOperatorNot = std::bind(&ShuntingYardAlgorithm::addOperatorNot, algorithm_);
       auto addOperatorAnd = std::bind(&ShuntingYardAlgorithm::addOperatorAnd, algorithm_);
       auto addOperatorOr = std::bind(&ShuntingYardAlgorithm::addOperatorOr, algorithm_);
       auto addBeginParenthesis = std::bind(&ShuntingYardAlgorithm::addBeginParenthesis, algorithm_);
       auto addEndParenthesis = std::bind(&ShuntingYardAlgorithm::addEndParenthesis, algorithm_);
 
       // Define the syntax allowed in the logical expressions
       pathName = !unaryOperator >> !binaryOperatorTest >> (+qi::char_("a-zA-Z0-9_"))[addPathName];
       binaryOperand = (qi::lit('(')[addBeginParenthesis] >> expression >> qi::lit(')')[addEndParenthesis]) |
                       (unaryOperator[addOperatorNot] >> binaryOperand) | pathName;
       afterOperator = ascii::space | &qi::lit('(') | &qi::eoi;
       unaryOperator = qi::lit("not") >> afterOperator;
       // The only difference in the next two is that one calls a functor and the other does not
       binaryOperatorTest = (qi::lit("and") >> afterOperator) | (qi::lit("or") >> afterOperator);
       binaryOperator =
           (qi::lit("and") >> afterOperator)[addOperatorAnd] | (qi::lit("or") >> afterOperator)[addOperatorOr];
       expression = binaryOperand % binaryOperator;
     }