GlobalLogicParser.h

Go to the documentation of this file.

#ifndef L1TGlobal_GlobalLogicParser_h
#define L1TGlobal_GlobalLogicParser_h
 
// system include files
#include <string>
#include <vector>
#include <list>
#include <map>
 
#include <iosfwd>
 
// user include files
 
// forward declarations
 
// class declaration
class GlobalLogicParser {
public:
  struct OperandToken {
    std::string tokenName;
    int tokenNumber;
    bool tokenResult;
  };
 
  enum OperationType {
    OP_NULL = 1,
    OP_INVALID = 2,
    OP_AND = 4,
    OP_OR = 8,
    OP_NOT = 16,
    OP_OPERAND = 32,
    OP_OPENBRACKET = 64,
    OP_CLOSEBRACKET = 128,
    OP_XOR = 256
  };
 
  struct TokenRPN {
    OperationType operation;  // type of operation: AND, OR, NOT or OPERAND
    std::string operand;      // a possible operand
  };
 
  typedef std::vector<TokenRPN> RpnVector;
 
public:
 
  GlobalLogicParser();
 
  GlobalLogicParser(const RpnVector&, const std::vector<OperandToken>&);
 
  GlobalLogicParser(const std::string& logicalExpressionVal);
 
  //   from a non-constant logical expression - add/remove spaces if needed
  //   numerical expression will be empty
  GlobalLogicParser(std::string& logicalExpressionVal);
 
  GlobalLogicParser(const std::string logicalExpressionVal, const std::string numericalExpressionVal);
 
  GlobalLogicParser(const std::string& logicalExpressionVal,
                    const std::string& numericalExpressionVal,
                    const bool dummy);
 
  virtual ~GlobalLogicParser();
 
public:
  inline std::string logicalExpression() const { return m_logicalExpression; }
 
  bool checkLogicalExpression(std::string&);
 
  inline std::string numericalExpression() const { return m_numericalExpression; }
 
public:
  bool buildRpnVector(const std::string&);
 
  void clearRpnVector();
 
  inline RpnVector rpnVector() const { return m_rpnVector; }
 
  void buildOperandTokenVector();
 
  inline std::vector<OperandToken>& operandTokenVector() { return m_operandTokenVector; }
  inline const std::vector<OperandToken>& operandTokenVector() const { return m_operandTokenVector; }
 
public:
  int operandIndex(const std::string& operandNameVal) const;
 
  std::string operandName(const int iOperand) const;
 
  bool operandResult(const std::string& operandNameVal) const;
 
  bool operandResult(const int tokenNumberVal) const;
 
  virtual const bool expressionResult() const;
 
  bool operandResultNumExp(const std::string& operandNameVal) const;
 
  bool operandResultNumExp(const int iOperand) const;
 
  void buildOperandTokenVectorNumExp();
 
  virtual const bool expressionResultNumExp() const;
 
  void convertNameToIntLogicalExpression(const std::map<std::string, int>& nameToIntMap);
 
 
  void convertIntToNameLogicalExpression(const std::map<int, std::string>& intToNameMap);
 
  std::vector<GlobalLogicParser::OperandToken> expressionSeedsOperandList();
 
protected:
  struct OperationRule {
    const char* opString;
    int opType;
    int forbiddenLastOperation;  // int for bitmask of forbidden operations
  };
 
  virtual OperationType getOperation(const std::string& tokenString,
                                     OperationType lastOperation,
                                     TokenRPN& rpnToken) const;
 
  const OperationRule* getRuleFromType(OperationType t);
 
  static const struct OperationRule m_operationRules[];
 
protected:
  void addBracketSpaces(const std::string&, std::string&);
 
  bool setLogicalExpression(const std::string&);
 
  bool setNumericalExpression(const std::string&);
 
protected:
  std::string m_logicalExpression;
 
  std::string m_numericalExpression;
 
  RpnVector m_rpnVector;
 
  std::vector<OperandToken> m_operandTokenVector;
};
 
#endif /*L1TGlobal_GtLogicParser_h*/