TriggerExpressionParser.h

Go to the documentation of this file.

#ifndef HLTrigger_HLTfilters_TriggerExpressionParser_h
#define HLTrigger_HLTfilters_TriggerExpressionParser_h
 
// Note: this requires Boost 1.41 or higher, for Spirit 2.1 or higher
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
 
#include "HLTrigger/HLTcore/interface/TriggerExpressionPathReader.h"
#include "HLTrigger/HLTcore/interface/TriggerExpressionL1uGTReader.h"
#include "HLTrigger/HLTcore/interface/TriggerExpressionOperators.h"
#include "HLTrigger/HLTcore/interface/TriggerExpressionPrescaler.h"
#include "HLTrigger/HLTcore/interface/TriggerExpressionConstant.h"
 
namespace triggerExpression {
 
  namespace qi = boost::spirit::qi;
  namespace ascii = boost::spirit::ascii;
 
  using boost::phoenix::new_;
  using boost::spirit::unused_type;
 
  template <typename Iterator>
  class Parser : public qi::grammar<Iterator, Evaluator *(), ascii::space_type> {
  public:
    Parser() : 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)]);
    }
 
  private:
    typedef qi::rule<Iterator, std::string(), ascii::space_type> name_rule;
    typedef qi::rule<Iterator, Evaluator *(), ascii::space_type> rule;
 
    name_rule token_l1algo;
    name_rule token_path;
 
    rule token;
    rule parenthesis;
    rule element;
    rule prescale;
    rule operand;
    rule unary;
    rule expression;
  };
 
  // generic interface for string-like objects
  template <class T>
  Evaluator *parse(const T &text) {
    typedef typename T::const_iterator Iterator;
    Parser<Iterator> parser;
    Evaluator *evaluator = nullptr;
 
    Iterator begin = text.begin();
    Iterator end = text.end();
 
    // the interface of qi::phrase_parse has changed between Boost 1.40 (Spirit 2.0) and Boost 1.41 (Spirit 2.1)
    bool result = qi::phrase_parse(begin, end, parser, ascii::space, evaluator);
 
    if (not result or begin != end) {
      delete evaluator;
      return nullptr;
    }
 
    return evaluator;
  }
 
  // overloaded interface for null-terminated strings
  inline Evaluator *parse(const char *text) {
    Parser<const char *> parser;
    Evaluator *evaluator = nullptr;
 
    const char *begin = text;
    const char *end = text + strlen(text);
 
    // the interface of qi::phrase_parse has changed between Boost 1.40 (Spirit 2.0) and Boost 1.41 (Spirit 2.1)
    bool result = qi::phrase_parse(begin, end, parser, ascii::space, evaluator);
 
    if (not result or begin != end) {
      delete evaluator;
      return nullptr;
    }
 
    return evaluator;
  }
 
}  // namespace triggerExpression
 
#endif  // HLTrigger_HLTfilters_TriggerExpressionParser_h