L1TGlobal/interface/GlobalLogicParser.h

0001 #ifndef L1TGlobal_GlobalLogicParser_h
0002 #define L1TGlobal_GlobalLogicParser_h
0003
0004 // system include files
0005 #include <string>
0006 #include <vector>
0007 #include <list>
0008 #include <map>
0009
0010 #include <iosfwd>
0011
0012 // user include files
0013
0014 // forward declarations
0015
0016 // class declaration
0017 class GlobalLogicParser {
0018 public:
0019   struct OperandToken {
0020     std::string tokenName;
0021     int tokenNumber;
0022     bool tokenResult;
0023   };
0024
0025   enum OperationType {
0026     OP_NULL = 1,
0027     OP_INVALID = 2,
0028     OP_AND = 4,
0029     OP_OR = 8,
0030     OP_NOT = 16,
0031     OP_OPERAND = 32,
0032     OP_OPENBRACKET = 64,
0033     OP_CLOSEBRACKET = 128,
0034     OP_XOR = 256
0035   };
0036
0037   struct TokenRPN {
0038     OperationType operation;  // type of operation: AND, OR, NOT or OPERAND
0039     std::string operand;      // a possible operand
0040   };
0041
0042   typedef std::vector<TokenRPN> RpnVector;
0043
0044 public:
0045   /// constructor(s)
0046
0047   ///   default constructor
0048   GlobalLogicParser();
0049
0050   ///   from the RPN vector and the operand token vector
0051   ///   no checks for consistency, empty logical and numerical expressions
0052   ///   requires special care when used
0053   GlobalLogicParser(const RpnVector&, const std::vector<OperandToken>&);
0054
0055   ///   from a constant logical expression
0056   ///   numerical expression will be empty
0057   GlobalLogicParser(const std::string& logicalExpressionVal);
0058
0059   //   from a non-constant logical expression - add/remove spaces if needed
0060   //   numerical expression will be empty
0061   GlobalLogicParser(std::string& logicalExpressionVal);
0062
0063   ///   from a logical and a numerical expression
0064   GlobalLogicParser(const std::string logicalExpressionVal, const std::string numericalExpressionVal);
0065
0066   ///   from a logical and a numerical expression
0067   ///   no checks for correctness - use it only after the correctness was tested
0068   GlobalLogicParser(const std::string& logicalExpressionVal,
0069                     const std::string& numericalExpressionVal,
0070                     const bool dummy);
0071
0072   /// destructor
0073   virtual ~GlobalLogicParser();
0074
0075 public:
0076   /// return the logical expression
0077   inline std::string logicalExpression() const { return m_logicalExpression; }
0078
0079   /// check a logical expression for correctness - add/remove spaces if needed
0080   bool checkLogicalExpression(std::string&);
0081
0082   /// return the numerical expression
0083   inline std::string numericalExpression() const { return m_numericalExpression; }
0084
0085 public:
0086   /// build the rpn vector
0087   bool buildRpnVector(const std::string&);
0088
0089   /// clear possible old rpn vector
0090   void clearRpnVector();
0091
0092   /// return the RPN vector
0093   inline RpnVector rpnVector() const { return m_rpnVector; }
0094
0095   /// build from the RPN vector the operand token vector
0096   /// dummy tokenNumber and tokenResult
0097   void buildOperandTokenVector();
0098
0099   /// return the vector of operand tokens
0100   inline std::vector<OperandToken>& operandTokenVector() { return m_operandTokenVector; }
0101   inline const std::vector<OperandToken>& operandTokenVector() const { return m_operandTokenVector; }
0102
0103 public:
0104   /// return the position index of the operand in the logical expression
0105   int operandIndex(const std::string& operandNameVal) const;
0106
0107   /// return the name of the (iOperand)th operand in the logical expression
0108   std::string operandName(const int iOperand) const;
0109
0110   /// return the result for an operand with name operandNameVal
0111   /// in the logical expression using the operand token vector
0112   bool operandResult(const std::string& operandNameVal) const;
0113
0114   /// return the result for an operand with tokenNumberVal
0115   /// using the operand token vector
0116   bool operandResult(const int tokenNumberVal) const;
0117
0118   /// return the result for the logical expression
0119   /// require a proper operand token vector
0120   virtual const bool expressionResult() const;
0121
0122   /// return the result for an operand with name operandNameVal
0123   /// in the logical expression using a numerical expression
0124   bool operandResultNumExp(const std::string& operandNameVal) const;
0125
0126   /// return the result for an operand with index iOperand
0127   /// in the logical expression using a numerical expression
0128   bool operandResultNumExp(const int iOperand) const;
0129
0130   /// build from the RPN vector the operand token vector
0131   /// using a numerical expression
0132   void buildOperandTokenVectorNumExp();
0133
0134   /// return the result for the logical expression
0135   /// require a proper numerical expression
0136   virtual const bool expressionResultNumExp() const;
0137
0138   /// convert the logical expression composed with names to
0139   /// a logical expression composed with int numbers using
0140   /// a (string, int)  map
0141   void convertNameToIntLogicalExpression(const std::map<std::string, int>& nameToIntMap);
0142
0143   /// convert a logical expression composed with integer numbers to
0144   /// a logical expression composed with names using a map (int, string)
0145
0146   void convertIntToNameLogicalExpression(const std::map<int, std::string>& intToNameMap);
0147
0148   /// return the list of operand tokens for the logical expression
0149   /// which are to be used as seeds
0150   std::vector<GlobalLogicParser::OperandToken> expressionSeedsOperandList();
0151
0152 protected:
0153   struct OperationRule {
0154     const char* opString;
0155     int opType;
0156     int forbiddenLastOperation;  // int for bitmask of forbidden operations
0157   };
0158
0159   virtual OperationType getOperation(const std::string& tokenString,
0160                                      OperationType lastOperation,
0161                                      TokenRPN& rpnToken) const;
0162
0163   /// get the rule entry to an operation type
0164   const OperationRule* getRuleFromType(OperationType t);
0165
0166   static const struct OperationRule m_operationRules[];
0167
0168 protected:
0169   /// add spaces before and after parantheses
0170   void addBracketSpaces(const std::string&, std::string&);
0171
0172   /// set the logical expression - check for correctness the input string
0173   bool setLogicalExpression(const std::string&);
0174
0175   /// set the numerical expression (the logical expression with each operand
0176   /// replaced with the value) from a string
0177   /// check also for correctness the input string
0178   bool setNumericalExpression(const std::string&);
0179
0180 protected:
0181   /// logical expression to be parsed
0182   std::string m_logicalExpression;
0183
0184   /// numerical expression
0185   /// (logical expression with operands replaced with the actual values)
0186   std::string m_numericalExpression;
0187
0188   /// RPN vector - equivalent to the logical expression
0189   RpnVector m_rpnVector;
0190
0191   /// vector of operand tokens
0192   std::vector<OperandToken> m_operandTokenVector;
0193 };
0194
0195 #endif /*L1TGlobal_GtLogicParser_h*/