Inheritance diagram for edm::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 edm::pathStatusExpression::Grammar< Iterator >

Definition at line 302 of file PathStatusFilter.cc.

Constructor & Destructor Documentation

◆ Grammar()

template<typename Iterator>

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

inline

Definition at line 304 of file PathStatusFilter.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;
       }