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*/