SelectionExprParser.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef SELECTION_HELPERS__SELECTION_EXPR_PARSER_H
#define SELECTION_HELPERS__SELECTION_EXPR_PARSER_H
 
#include <boost/tokenizer.hpp>
#include <functional>
#include <memory>
#include <string>
 
#include "SelectionHelpers/ISelectionReadAccessor.h"
#include "SelectionHelpers/SelectionHelpers.h"
 
namespace CP {
 
// Private detail namespace. This is not strictly private to enable testing
namespace DetailSelectionExprParser {
 
class Separator {
 public:
  bool operator()(std::string::const_iterator &next,
                  const std::string::const_iterator &end,
                  std::string &tok) const;
 
  void reset() {}
};
 
// Typedef over boost's tokenizer using the above Separator
typedef boost::tokenizer<Separator> Tokenizer;
 
class Lexer {
 public:
  Lexer(const std::string &s);
 
  Lexer(const Lexer &) = delete;
  Lexer(Lexer &&) = default;
 
  enum Type {
    AND = 0,
    OR,
    LEFT,
    RIGHT,
    NOT,
    TRUE_LITERAL,
    FALSE_LITERAL,
    VAR,
    END
  };
 
  struct Symbol {
    Type type;
    std::string value;
  };
 
  Symbol nextSymbol();
 
 private:
  std::string m_string;
  Tokenizer m_tokenizer;
  Tokenizer::iterator m_iterator;
};
}  // namespace DetailSelectionExprParser
 
class SelectionExprParser {
 public:
  SelectionExprParser(DetailSelectionExprParser::Lexer lexer,
                      bool defaultToChar = false);
 
  StatusCode build(std::unique_ptr<ISelectionReadAccessor> &accessor);
 
 private:
  // Construct a binary OR
  StatusCode expression(std::unique_ptr<ISelectionReadAccessor> &root);
  // Construct an AND, attempts to group all ANDs it can see into a list 
  StatusCode term(std::unique_ptr<ISelectionReadAccessor> &root);
  // Handle other constructs, potentially more ORs or ANDs.
  StatusCode factor(std::unique_ptr<ISelectionReadAccessor> &root);
 
  // The lexer to generate symbols from.
  DetailSelectionExprParser::Lexer m_lexer;
  // The last extracted symbol
  DetailSelectionExprParser::Lexer::Symbol m_symbol;
  // Stores constructor parameter to be used in calls to makeSelectionAccessorVar.
  bool m_defaultToChar;
};
 
}  // namespace CP
 
#endif