GlobalLogicParser.cc

Go to the documentation of this file.

// this class header
#include "DataFormats/L1TGlobal/interface/GlobalLogicParser.h"

// system include files
#include <stack>

#include <iostream>
#include <sstream>

#include <boost/algorithm/string.hpp>

// user include files

#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// forward declarations

// constructor(s)

//   default constructor
GlobalLogicParser::GlobalLogicParser() {
  // empty, default C++ initialization for string and vector are enough
}

//   from the RPN vector and the operand token vector
//   no checks for consistency, empty logical and numerical expressions
//   requires special care when used
GlobalLogicParser::GlobalLogicParser(const RpnVector& rpnVec, const std::vector<OperandToken>& opTokenVector) {
  m_rpnVector = rpnVec;
  m_operandTokenVector = opTokenVector;
}

//   from a constant logical expression
//   numerical expression will be empty
GlobalLogicParser::GlobalLogicParser(const std::string& logicalExpressionVal) {
  // checks also for syntactic correctness of the logical expression

  if (!setLogicalExpression(logicalExpressionVal)) {
    // error(s) in logical expression - printed in the relevant place
    throw cms::Exception("FailModule") << "\nError in parsing the logical expression = " << logicalExpressionVal
                                       << std::endl;
  }
}

//   from a non-constant logical expression - add/remove spaces if needed
//   numerical expression will be empty
GlobalLogicParser::GlobalLogicParser(std::string& logicalExpressionVal) {
  // checks also for syntactic correctness of the logical expression

  // add spaces around brackets
  std::string logicalExpressionBS;
  addBracketSpaces(logicalExpressionVal, logicalExpressionBS);

  // trim leading or trailing spaces
  boost::trim(logicalExpressionBS);

  if (!buildRpnVector(logicalExpressionBS)) {
    // error(s) in logical expression
    throw cms::Exception("FailModule") << "\nError in parsing the logical expression = " << logicalExpressionVal
                                       << std::endl;
  }

  //LogDebug("L1TGlobal")
  //    << "\nInitial logical expression = '" << logicalExpressionVal << "'"
  //    << "\nFinal   logical expression = '" << logicalExpressionBS << "'\n"
  //    << std::endl;

  logicalExpressionVal = logicalExpressionBS;
  m_logicalExpression = logicalExpressionVal;

  // build operand token vector
  // dummy tokenNumber; tokenResult false
  buildOperandTokenVector();
}

//   from a logical and a numerical expression
GlobalLogicParser::GlobalLogicParser(const std::string logicalExpressionVal, const std::string numericalExpressionVal) {
  // checks also for correctness

  if (!setLogicalExpression(logicalExpressionVal)) {
    // error(s) in logical expression - printed in the relevant place
    throw cms::Exception("FailModule") << "\nError in parsing the logical expression = " << logicalExpressionVal
                                       << std::endl;
  }

  if (!setNumericalExpression(numericalExpressionVal)) {
    // error(s) in numerical expression - printed in the relevant place
    throw cms::Exception("FileModule") << "\nError in parsing the numerical expression = " << numericalExpressionVal
                                       << std::endl;
  }
}

//   from a logical and a numerical expression
//   no checks for correctness - use it only after the correctness was tested
GlobalLogicParser::GlobalLogicParser(const std::string& logicalExpressionVal,
                                     const std::string& numericalExpressionVal,
                                     const bool dummy) {
  clearRpnVector();
  if (!buildRpnVector(logicalExpressionVal)) {
    throw cms::Exception("FileModule") << "\nError in building RPN vector for the logical expression = "
                                       << logicalExpressionVal << std::endl;
  }

  m_logicalExpression = logicalExpressionVal;
  m_numericalExpression = numericalExpressionVal;
}

// destructor
GlobalLogicParser::~GlobalLogicParser() {
  // empty now
}

// public methods

// check a logical expression for correctness - add/remove spaces if needed
bool GlobalLogicParser::checkLogicalExpression(std::string& logicalExpressionVal) {
  // add spaces around brackets
  std::string logicalExpressionBS;
  addBracketSpaces(logicalExpressionVal, logicalExpressionBS);

  // trim leading or trailing spaces
  boost::trim(logicalExpressionBS);

  clearRpnVector();

  if (!buildRpnVector(logicalExpressionBS)) {
    return false;
  }

  LogDebug("L1TGlobal") << "\nGtLogicParser::checkLogicalExpression - "
                        << "\nInitial logical expression = '" << logicalExpressionVal << "'"
                        << "\nFinal   logical expression = '" << logicalExpressionBS << "'\n"
                        << std::endl;

  logicalExpressionVal = logicalExpressionBS;

  return true;
}

bool GlobalLogicParser::buildRpnVector(const std::string& logicalExpressionVal) {
  //LogDebug("L1TGlobal")
  //<< "\nGtLogicParser::buildRpnVector - "
  //<< "\nLogical expression = '" << logicalExpressionVal << "'\n"
  //<< std::endl;

  OperationType actualOperation = OP_NULL;
  OperationType lastOperation = OP_NULL;

  // token as string and as TokenRPN, stack to form the postfix notation
  std::string tokenString;
  TokenRPN rpnToken;
  std::stack<TokenRPN> operatorStack;

  static const std::string whitespaces = " \r\v\n\t";

  // clear possible old rpn vector
  clearRpnVector();

  // stringstream to separate all tokens
  std::istringstream exprStringStream(logicalExpressionVal);

  while (!exprStringStream.eof()) {
    exprStringStream >> std::skipws >> std::ws >> tokenString;

    // skip the end
    if (tokenString.find_first_not_of(whitespaces) == std::string::npos || tokenString.length() == 0) {
      //LogTrace("L1TGlobal")
      //<< "  Break for token string = " << tokenString
      //<< std::endl;

      break;
    }

    actualOperation = getOperation(tokenString, lastOperation, rpnToken);

    //LogTrace("L1TGlobal")
    //<< "  Token string = '" << tokenString << "'"
    //<< "\tActual Operation = " << actualOperation
    //<< std::endl;

    // http://en.wikipedia.org/wiki/Postfix_notation#Converting_from_infix_notation

    switch (actualOperation) {
      case OP_OPERAND: {
        // operands get pushed to the postfix notation immediately
        m_rpnVector.push_back(rpnToken);
      }

      break;
      case OP_INVALID: {
        int errorPosition = exprStringStream.tellg();

        edm::LogError("L1TGlobal") << "\nLogical expression = '" << logicalExpressionVal << "'"
                                   << "\n  Syntax error during parsing: "
                                   << "\n     " << exprStringStream.str().substr(0, errorPosition) << "\n     "
                                   << exprStringStream.str().substr(errorPosition)
                                   << "\n  Returned empty RPN vector and result false." << std::endl;

        // clear the rpn vector before returning
        clearRpnVector();

        return false;
      }

      break;
      case OP_NOT: {
        operatorStack.push(rpnToken);
        // there are no operators with higher precedence
      }

      break;
      case OP_XOR: {
        // first pop operators with higher precedence (NOT)
        while (!operatorStack.empty() && operatorStack.top().operation == OP_NOT) {
          m_rpnVector.push_back(operatorStack.top());
          operatorStack.pop();
        }
        operatorStack.push(rpnToken);
      }

      break;
      case OP_AND: {
        // first pop operators with higher precedence (XOR, NOT)
        while (!operatorStack.empty() &&
               (operatorStack.top().operation == OP_NOT || operatorStack.top().operation == OP_AND)) {
          m_rpnVector.push_back(operatorStack.top());
          operatorStack.pop();
        }
        operatorStack.push(rpnToken);
      }

      break;
      case OP_OR: {
        // pop operators with higher precedence (AND, XOR, NOT)
        while (!operatorStack.empty() &&
               (operatorStack.top().operation == OP_NOT || operatorStack.top().operation == OP_XOR ||
                operatorStack.top().operation == OP_AND)) {
          m_rpnVector.push_back(operatorStack.top());
          operatorStack.pop();
        }
        // push operator on stack
        operatorStack.push(rpnToken);
      }

      break;
      case OP_OPENBRACKET: {
        // just push it on stack
        operatorStack.push(rpnToken);
      }

      break;
      case OP_CLOSEBRACKET: {
        // check if the operatorStack is empty
        if (operatorStack.empty()) {
          int errorPosition = exprStringStream.tellg();

          edm::LogError("L1TGlobal") << "\nLogical expression = '" << logicalExpressionVal << "'"
                                     << "\n  Syntax error during parsing - misplaced ')':"
                                     << "\n     " << exprStringStream.str().substr(0, errorPosition) << "\n     "
                                     << exprStringStream.str().substr(errorPosition)
                                     << "\n  Returned empty RPN vector and result false." << std::endl;

          // clear the rpn vector before returning
          clearRpnVector();

          return false;
        }

        // pop stack until a left parenthesis is found
        do {
          if (operatorStack.top().operation != OP_OPENBRACKET) {
            m_rpnVector.push_back(operatorStack.top());  // pop
            operatorStack.pop();
          }
          if (operatorStack.empty()) {  // the operatorStack must not be empty

            int errorPosition = exprStringStream.tellg();

            edm::LogError("L1TGlobal") << "\nLogical expression = '" << logicalExpressionVal << "'"
                                       << "\n  Syntax error during parsing - misplaced ')':"
                                       << "\n     " << exprStringStream.str().substr(0, errorPosition) << "\n     "
                                       << exprStringStream.str().substr(errorPosition)
                                       << "\n  Returned empty RPN vector and result false." << std::endl;

            // clear the rpn vector before returning
            clearRpnVector();
            return false;
          }
        } while (operatorStack.top().operation != OP_OPENBRACKET);

        operatorStack.pop();  // pop the open bracket.
      }

      break;
      default: {
        // empty
      } break;
    }

    lastOperation = actualOperation;  // for the next turn
  }

  // pop the rest of the operator stack
  while (!operatorStack.empty()) {
    if (operatorStack.top().operation == OP_OPENBRACKET) {
      edm::LogError("L1TGlobal") << "\nLogical expression = '" << logicalExpressionVal << "'"
                                 << "\n  Syntax error during parsing - missing ')':"
                                 << "\n  Returned empty RPN vector and result false." << std::endl;

      // clear the rpn vector before returning
      clearRpnVector();
      return false;
    }

    m_rpnVector.push_back(operatorStack.top());
    operatorStack.pop();
  }

  // count all operations and check if the result is 1
  int counter = 0;
  for (RpnVector::iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    if (it->operation == OP_OPERAND)
      counter++;
    if (it->operation == OP_OR || it->operation == OP_AND || it->operation == OP_XOR)
      counter--;
    if (counter < 1) {
      edm::LogError("L1TGlobal") << "\nLogical expression = '" << logicalExpressionVal << "'"
                                 << "\n  Syntax error during parsing - too many operators"
                                 << "\n  Returned empty RPN vector and result false." << std::endl;

      // clear the rpn vector before returning
      clearRpnVector();
      return false;
    }
  }

  if (counter > 1) {
    edm::LogError("L1TGlobal") << "\nLogical expression = '" << logicalExpressionVal << "'"
                               << "\n  Syntax error during parsing - too many operands"
                               << "\n  Returned empty RPN vector and result false." << std::endl;

    // clear the rpn vector before returning
    clearRpnVector();
    return false;
  }
  return true;
}

// clear rpn vector
void GlobalLogicParser::clearRpnVector() { m_rpnVector.clear(); }

// build from the RPN vector the operand token vector
// dummy tokenNumber and token result
void GlobalLogicParser::buildOperandTokenVector() {
  //LogTrace("L1TGlobal")
  //<< "\nGtLogicParser::buildOperandTokenVector - "
  //<< std::endl;

  // reserve memory
  size_t rpnVectorSize = m_rpnVector.size();
  m_operandTokenVector.reserve(rpnVectorSize);

  int opNumber = 0;

  for (RpnVector::const_iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    //LogTrace("L1TGlobal")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;

    switch (it->operation) {
      case OP_OPERAND: {
        OperandToken opToken;
        opToken.tokenName = it->operand;
        opToken.tokenNumber = opNumber;
        opToken.tokenResult = false;

        m_operandTokenVector.push_back(opToken);

      }

      break;
      case OP_NOT: {
        // do nothing
      }

      break;
      case OP_OR: {
        // do nothing
      }

      break;
      case OP_AND: {
        // do nothing
      }
      case OP_XOR: {
        // do nothing
      }

      break;
      default: {
        // should not arrive here
      }

      break;
    }

    opNumber++;
  }
}

// return the position index of the operand in the logical expression
int GlobalLogicParser::operandIndex(const std::string& operandNameVal) const {
  int result = -1;

  OperationType actualOperation = OP_NULL;
  OperationType lastOperation = OP_NULL;

  std::string tokenString;
  TokenRPN rpnToken;  // token to be used by getOperation

  // stringstream to separate all tokens
  std::istringstream exprStringStream(m_logicalExpression);

  // temporary index for usage in the loop
  int tmpIndex = -1;

  while (!exprStringStream.eof()) {
    exprStringStream >> tokenString;

    //LogTrace("L1TGlobal")
    //<< "Token string = " << tokenString
    //<< std::endl;

    actualOperation = getOperation(tokenString, lastOperation, rpnToken);
    if (actualOperation == OP_INVALID) {
      // it should never be invalid
      edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                                 << "\n  Invalid operation/operand " << operandNameVal
                                 << "\n  Returned index is by default out of range (-1)." << std::endl;

      return result;
    }

    if (actualOperation != OP_OPERAND) {
      // do nothing

    } else {
      tmpIndex++;
      if (rpnToken.operand == operandNameVal) {
        result = tmpIndex;

        //LogDebug("L1TGlobal")
        //<< "\nGtLogicParser::operandIndex - "
        //<< "\nLogical expression = '" << m_logicalExpression << "'"
        //<< "\nIndex of operand " << operandNameVal << " = " << result
        //<< std::endl;

        return result;
      }
    }
    lastOperation = actualOperation;
  }

  //
  edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                             << "\n  Operand " << operandNameVal << " not found in the logical expression"
                             << "\n  Returned index is by default out of range (-1)." << std::endl;

  return result;
}

// return the name of the (iOperand)th operand in the logical expression
std::string GlobalLogicParser::operandName(const int iOperand) const {
  std::string result;

  OperationType actualOperation = OP_NULL;
  OperationType lastOperation = OP_NULL;

  std::string tokenString;
  TokenRPN rpnToken;  // token to be used by getOperation

  // stringstream to separate all tokens
  std::istringstream exprStringStream(m_logicalExpression);

  // temporary index for usage in the loop
  int tmpIndex = -1;

  while (!exprStringStream.eof()) {
    exprStringStream >> tokenString;

    //LogTrace("L1TGlobal")
    //<< "Token string = " << tokenString
    //<< std::endl;

    actualOperation = getOperation(tokenString, lastOperation, rpnToken);
    if (actualOperation == OP_INVALID) {
      // it should never be invalid
      edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                                 << "\n  Invalid operation/operand at position " << iOperand
                                 << "\n  Returned empty name by default." << std::endl;

      return result;
    }

    if (actualOperation != OP_OPERAND) {
      // do nothing

    } else {
      tmpIndex++;
      if (tmpIndex == iOperand) {
        result = rpnToken.operand;

        //LogDebug("L1TGlobal")
        //<< "\nGtLogicParser::operandName - "
        //<< "\nLogical expression = '" << m_logicalExpression << "'"
        //<< "\nOperand with index " << iOperand << " = " << result
        //<< std::endl;

        return result;
      }
    }
    lastOperation = actualOperation;
  }

  //
  edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                             << "\n  No operand found at position " << iOperand << "\n  Returned empty name by default."
                             << std::endl;

  return result;
}

// return the result for an operand with name operandNameVal
// in the logical expression using the operand token vector
bool GlobalLogicParser::operandResult(const std::string& operandNameVal) const {
  for (size_t i = 0; i < m_operandTokenVector.size(); ++i) {
    if ((m_operandTokenVector[i]).tokenName == operandNameVal) {
      return (m_operandTokenVector[i]).tokenResult;
    }
  }

  // return false - should not arrive here
  edm::LogError("L1TGlobal") << "\n  Operand " << operandNameVal << " not found in the operand token vector"
                             << "\n  Returned false by default." << std::endl;

  return false;
}

// return the result for an operand with tokenNumberVal
// using the operand token vector
bool GlobalLogicParser::operandResult(const int tokenNumberVal) const {
  for (size_t i = 0; i < m_operandTokenVector.size(); ++i) {
    if ((m_operandTokenVector[i]).tokenNumber == tokenNumberVal) {
      return (m_operandTokenVector[i]).tokenResult;
    }
  }

  // return false - should not arrive here
  edm::LogError("L1TGlobal") << "\n  No operand with token number " << tokenNumberVal
                             << " found in the operand token vector"
                             << "\n  Returned false by default." << std::endl;

  return false;
}

// return the result for the logical expression
// require a proper operand token vector
const bool GlobalLogicParser::expressionResult() const {
  //LogTrace("L1TGlobal")
  //<< "\nGtLogicParser::expressionResult - "
  //<< std::endl;

  // return false if there is no RPN vector built
  if (m_rpnVector.empty()) {
    edm::LogError("L1TGlobal") << "\n  No built RPN vector exists."
                               << "\n  Returned false by default." << std::endl;
    return false;
  }

  // stack containing temporary results
  std::stack<bool> resultStack;
  bool b1, b2;

  for (RpnVector::const_iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    //LogTrace("L1TGlobal")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;

    switch (it->operation) {
      case OP_OPERAND: {
        resultStack.push(operandResult(it->operand));
      }

      break;
      case OP_NOT: {
        b1 = resultStack.top();
        resultStack.pop();      // pop the top
        resultStack.push(!b1);  // and push the result
      }

      break;
      case OP_OR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 || b2);
      }

      break;
      case OP_XOR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 ^ b2);
      }

      break;
      case OP_AND: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 && b2);
      }

      break;
      default: {
        // should not arrive here
      }

      break;
    }
  }

  // get the result in the top of the stack

  //LogTrace("L1TGlobal")
  //<< "\nGtLogicParser::expressionResult - "
  //<< "\nResult = " << resultStack.top()
  //<< std::endl;

  return resultStack.top();
}

// return the result for an operand with name operandNameVal
// in the logical expression using a numerical expression
bool GlobalLogicParser::operandResultNumExp(const std::string& operandNameVal) const {
  bool result = false;

  // get the position index of the operand in the logical string
  const int iOperand = operandIndex(operandNameVal);

  result = operandResult(iOperand);

  return result;
}

// return the result for an operand with index iOperand
// in the logical expression using a numerical expression
bool GlobalLogicParser::operandResultNumExp(const int iOperand) const {
  bool result = false;

  // parse the numerical expression

  OperationType actualOperation = OP_NULL;
  OperationType lastOperation = OP_NULL;

  std::string tokenString;
  TokenRPN rpnToken;  // token to be used by getOperation

  // stringstream to separate all tokens
  std::istringstream exprStringStream(m_numericalExpression);

  // temporary index for usage in the loop
  int tmpIndex = -1;

  while (!exprStringStream.eof()) {
    exprStringStream >> tokenString;

    //LogTrace("L1TGlobal")
    //<< "Token string = " << tokenString
    //<< std::endl;

    actualOperation = getOperation(tokenString, lastOperation, rpnToken);
    if (actualOperation == OP_INVALID) {
      // it should never be invalid
      edm::LogError("L1TGlobal") << "\nNumerical expression = '" << m_numericalExpression << "'"
                                 << "\n  Invalid operation/operand at position " << iOperand
                                 << "\n  Returned false by default." << std::endl;

      result = false;
      return result;
    }

    if (actualOperation != OP_OPERAND) {
      // do nothing

    } else {
      tmpIndex++;
      if (tmpIndex == iOperand) {
        if (rpnToken.operand == "1") {
          result = true;
        } else {
          if (rpnToken.operand == "0") {
            result = false;
          } else {
            // something went wrong - break
            //
            edm::LogError("L1TGlobal") << "\nNumerical expression = '" << m_numericalExpression << "'"
                                       << "\n  Invalid result for operand at position " << iOperand << ": "
                                       << rpnToken.operand << "\n  It must be 0 or 1"
                                       << "\n  Returned false by default." << std::endl;

            result = false;
            return result;
          }
        }

        //LogDebug("L1TGlobal")
        //<< "\nGtLogicParser::operandResult - "
        //<< "\nNumerical expression = '" << m_numericalExpression << "'"
        //<< "\nResult for operand with index " << iOperand
        //<< " = " << result << "'\n"
        //<< std::endl;

        return result;
      }
    }
    lastOperation = actualOperation;
  }

  //
  edm::LogError("L1TGlobal") << "\nNumerical expression = '" << m_numericalExpression << "'"
                             << "\n  No operand found at position " << iOperand << "\n  Returned false by default."
                             << std::endl;

  return result;
}

// build from the RPN vector the operand token vector
// using a numerical expression
void GlobalLogicParser::buildOperandTokenVectorNumExp() {
  //LogTrace("L1TGlobal")
  //<< "\nGtLogicParser::buildOperandTokenVector - "
  //<< std::endl;

  // reserve memory
  size_t rpnVectorSize = m_rpnVector.size();
  m_operandTokenVector.reserve(rpnVectorSize);

  int opNumber = 0;

  for (RpnVector::const_iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    //LogTrace("L1TGlobal")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;

    switch (it->operation) {
      case OP_OPERAND: {
        OperandToken opToken;
        opToken.tokenName = it->operand;
        opToken.tokenNumber = opNumber;
        opToken.tokenResult = operandResultNumExp(it->operand);

        m_operandTokenVector.push_back(opToken);

      }

      break;
      case OP_NOT: {
        // do nothing
      }

      break;
      case OP_OR: {
        // do nothing
      }

      break;
      case OP_XOR: {
        // do nothing
      }

      break;
      case OP_AND: {
        // do nothing
      }

      break;
      default: {
        // should not arrive here
      }

      break;
    }

    opNumber++;
  }
}

// return the result for the logical expression
const bool GlobalLogicParser::expressionResultNumExp() const {
  //LogTrace("L1TGlobal")
  //<< "\nGtLogicParser::expressionResult - "
  //<< std::endl;

  // return false if there is no expression
  if (m_rpnVector.empty()) {
    edm::LogError("L1TGlobal") << "\n  No built RPN vector exists."
                               << "\n  Returned false by default." << std::endl;
    return false;
  }

  // stack containing temporary results
  std::stack<bool> resultStack;
  bool b1, b2;

  for (RpnVector::const_iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    //LogTrace("L1TGlobal")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;

    switch (it->operation) {
      case OP_OPERAND: {
        resultStack.push(operandResultNumExp(it->operand));
      }

      break;
      case OP_NOT: {
        b1 = resultStack.top();
        resultStack.pop();      // pop the top
        resultStack.push(!b1);  // and push the result
      }

      break;
      case OP_OR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 || b2);
      }

      break;
      case OP_XOR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 ^ b2);
      }

      break;
      case OP_AND: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 && b2);
      }

      break;
      default: {
        // should not arrive here
      }

      break;
    }
  }

  // get the result in the top of the stack

  //LogTrace("L1TGlobal")
  //<< "\nGtLogicParser::expressionResult - "
  //<< "\nLogical expression   = '" << m_logicalExpression << "'"
  //<< "\nNumerical expression = '" << m_numericalExpression << "'"
  //<< "\nResult = " << resultStack.top()
  //<< std::endl;

  return resultStack.top();
}

// convert the logical expression composed with names to
// a logical expression composed with int numbers using
// a (string, int)  map

void GlobalLogicParser::convertNameToIntLogicalExpression(const std::map<std::string, int>& nameToIntMap) {
  if (m_logicalExpression.empty()) {
    return;
  }

  // non-empty logical expression

  OperationType actualOperation = OP_NULL;
  OperationType lastOperation = OP_NULL;

  std::string tokenString;
  TokenRPN rpnToken;  // token to be used by getOperation

  int intValue = -1;

  // stringstream to separate all tokens
  std::istringstream exprStringStream(m_logicalExpression);
  std::string convertedLogicalExpression;

  while (!exprStringStream.eof()) {
    exprStringStream >> tokenString;

    actualOperation = getOperation(tokenString, lastOperation, rpnToken);
    if (actualOperation == OP_INVALID) {
      // it should never be invalid
      edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                                 << "\n  Invalid operation/operand in logical expression."
                                 << "\n  Return empty logical expression." << std::endl;

      m_logicalExpression.clear();
      return;
    }

    if (actualOperation != OP_OPERAND) {
      convertedLogicalExpression.append(getRuleFromType(actualOperation)->opString);

    } else {
      typedef std::map<std::string, int>::const_iterator CIter;

      CIter it = nameToIntMap.find(rpnToken.operand);
      if (it != nameToIntMap.end()) {
        intValue = it->second;
        std::stringstream intStr;
        intStr << intValue;
        convertedLogicalExpression.append(intStr.str());

      } else {
        // it should never be happen
        edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                                   << "\n  Could not convert " << rpnToken.operand << " to integer!"
                                   << "\n  Return empty logical expression." << std::endl;

        m_logicalExpression.clear();
        return;
      }
    }

    convertedLogicalExpression.append(" ");  // one whitespace after each token
    lastOperation = actualOperation;
  }

  // remove the last space
  //convertedLogicalExpression.erase(convertedLogicalExpression.size() - 1);
  boost::trim(convertedLogicalExpression);

  LogDebug("L1TGlobal") << "\nGtLogicParser::convertNameToIntLogicalExpression - "
                        << "\nLogical expression (strings) = '" << m_logicalExpression << "'"
                        << "\nLogical expression (int)     = '" << convertedLogicalExpression << "'\n"
                        << std::endl;

  // replace now the logical expression with strings with
  // the converted logical expression

  m_logicalExpression = convertedLogicalExpression;

  return;
}

// convert a logical expression composed with integer numbers to
// a logical expression composed with names using a map (int, string)

void GlobalLogicParser::convertIntToNameLogicalExpression(const std::map<int, std::string>& intToNameMap) {
  if (m_logicalExpression.empty()) {
    return;
  }

  // non-empty logical expression

  OperationType actualOperation = OP_NULL;
  OperationType lastOperation = OP_NULL;

  std::string tokenString;
  TokenRPN rpnToken;  // token to be used by getOperation

  // stringstream to separate all tokens
  std::istringstream exprStringStream(m_logicalExpression);
  std::string convertedLogicalExpression;

  while (!exprStringStream.eof()) {
    exprStringStream >> tokenString;

    actualOperation = getOperation(tokenString, lastOperation, rpnToken);
    if (actualOperation == OP_INVALID) {
      // it should never be invalid
      edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                                 << "\n  Invalid operation/operand in logical expression."
                                 << "\n  Return empty logical expression." << std::endl;

      m_logicalExpression.clear();
      return;
    }

    if (actualOperation != OP_OPERAND) {
      convertedLogicalExpression.append(getRuleFromType(actualOperation)->opString);

    } else {
      typedef std::map<int, std::string>::const_iterator CIter;

      // convert string to int
      int indexInt;
      std::istringstream iss(rpnToken.operand);
      iss >> std::dec >> indexInt;

      CIter it = intToNameMap.find(indexInt);
      if (it != intToNameMap.end()) {
        convertedLogicalExpression.append(it->second);

      } else {
        // it should never be happen
        edm::LogError("L1TGlobal") << "\nLogical expression = '" << m_logicalExpression << "'"
                                   << "\n  Could not convert " << rpnToken.operand << " to string!"
                                   << "\n  Return empty logical expression." << std::endl;

        m_logicalExpression.clear();
        return;
      }
    }

    convertedLogicalExpression.append(" ");  // one whitespace after each token
    lastOperation = actualOperation;
  }

  // remove the last space
  //convertedLogicalExpression.erase(convertedLogicalExpression.size() - 1);
  boost::trim(convertedLogicalExpression);

  //LogDebug("L1TGlobal")
  //        << "\nGtLogicParser::convertIntToNameLogicalExpression - "
  //        << "\nLogical expression (int) =    '" << m_logicalExpression << "'"
  //        << "\nLogical expression (string) = '" << convertedLogicalExpression << "'\n"
  //        << std::endl;

  // replace now the logical expression with int with
  // the converted logical expression

  m_logicalExpression = convertedLogicalExpression;

  return;
}

// return the list of operand tokens for the logical expression
// which are to be used as seeds
std::vector<GlobalLogicParser::OperandToken> GlobalLogicParser::expressionSeedsOperandList() {
  //LogDebug("L1TGlobal")
  //<< "\nGtLogicParser::expressionSeedsOperandList - "
  //<< "\nLogical expression = '" << m_logicalExpression << "'"
  //<< "\nm_rpnVector.size() = " << m_rpnVector.size()
  //<< "\nm_operandTokenVector.size() = " << m_operandTokenVector.size()
  //<< std::endl;

  // seed list
  std::vector<OperandToken> opVector;
  opVector.reserve(m_operandTokenVector.size());

  // temporary results
  std::stack<OperandToken> tmpStack;
  std::vector<OperandToken> tmpVector;
  tmpVector.reserve(m_operandTokenVector.size());

  OperandToken b1, b2;

  bool newOperandBlock = true;
  bool oneBlockOnly = true;
  bool operandOnly = true;

  int iOperand = -1;

  OperandToken dummyToken;
  dummyToken.tokenName = "dummy";
  dummyToken.tokenNumber = -1;
  dummyToken.tokenResult = false;

  for (RpnVector::const_iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    //LogTrace("L1TGlobal")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;

    switch (it->operation) {
      // RPN always start a block with an operand
      case OP_OPERAND: {
        // more blocks with operations
        // push operands from previous block, if any in the tmpVector
        // (reverse order to compensate the stack push/top/pop)
        if ((!newOperandBlock)) {
          for (std::vector<OperandToken>::reverse_iterator itOp = tmpVector.rbegin(); itOp != tmpVector.rend();
               itOp++) {
            opVector.push_back(*itOp);

            //LogTrace("L1TGlobal")
            //<< "  Push operand " << (*itOp).tokenName
            //<<" on the seed operand list"
            //<< std::endl;
          }

          tmpVector.clear();

          newOperandBlock = true;
          oneBlockOnly = false;
        }

        iOperand++;

        //LogTrace("L1TGlobal")
        //<< "  Push operand " << (m_operandTokenVector.at(iOperand)).tokenName
        //<< " on the operand stack"
        //<< std::endl;

        tmpStack.push(m_operandTokenVector.at(iOperand));
      }

      break;
      case OP_NOT: {
        newOperandBlock = false;
        operandOnly = false;

        b1 = tmpStack.top();
        tmpStack.pop();  // pop the top

        tmpStack.push(dummyToken);  // and push dummy result

        //LogTrace("L1TGlobal")
        //<< "  Clear tmp operand list"
        //<< std::endl;

        tmpVector.clear();

      }

      break;
      case OP_OR: {
        newOperandBlock = false;
        operandOnly = false;

        b1 = tmpStack.top();
        tmpStack.pop();
        b2 = tmpStack.top();
        tmpStack.pop();

        tmpStack.push(dummyToken);  // and push dummy result

        if (b1.tokenNumber >= 0) {
          tmpVector.push_back(b1);

          //LogTrace("L1TGlobal")
          //<< "  Push operand " << b1.tokenName
          //<<" on the tmp list"
          //<< std::endl;
        }

        if (b2.tokenNumber >= 0) {
          tmpVector.push_back(b2);

          //LogTrace("L1TGlobal")
          //<< "  Push operand " << b2.tokenName
          //<<" on the tmp list"
          //<< std::endl;
        }

      }

      break;
      case OP_XOR: {
        newOperandBlock = false;
        operandOnly = false;

        b1 = tmpStack.top();
        tmpStack.pop();
        b2 = tmpStack.top();
        tmpStack.pop();

        tmpStack.push(dummyToken);  // and push dummy result

        if (b1.tokenNumber >= 0) {
          tmpVector.push_back(b1);

          //LogTrace("L1TGlobal")
          //<< "  Push operand " << b1.tokenName
          //<<" on the tmp list"
          //<< std::endl;
        }

        if (b2.tokenNumber >= 0) {
          tmpVector.push_back(b2);

          //LogTrace("L1TGlobal")
          //<< "  Push operand " << b2.tokenName
          //<<" on the tmp list"
          //<< std::endl;
        }

      }

      break;
      case OP_AND: {
        newOperandBlock = false;
        operandOnly = false;

        b1 = tmpStack.top();
        tmpStack.pop();
        b2 = tmpStack.top();
        tmpStack.pop();

        tmpStack.push(dummyToken);

        if (b1.tokenNumber >= 0) {
          tmpVector.push_back(b1);

          //LogTrace("L1TGlobal")
          //<< "  Push operand " << b1.tokenName
          //<<" on the tmp list"
          //<< std::endl;
        }

        if (b2.tokenNumber >= 0) {
          tmpVector.push_back(b2);

          //LogTrace("L1TGlobal")
          //<< "  Push operand " << b2.tokenName
          //<<" on the tmp list"
          //<< std::endl;
        }

      }

      break;
      default: {
        // should not arrive here
      }

      break;
    }
  }

  // one block only or one operand only
  if (oneBlockOnly || operandOnly) {
    // one operand only -
    // there can be only one operand, otherwise one needs an operation
    if (operandOnly) {
      b1 = tmpStack.top();
      tmpVector.push_back(b1);
    }

    //
    for (std::vector<OperandToken>::reverse_iterator itOp = tmpVector.rbegin(); itOp != tmpVector.rend(); itOp++) {
      opVector.push_back(*itOp);

      //LogTrace("L1TGlobal")
      //<< "  One block or one operand only: push operand " << (*itOp).tokenName
      //<<" on the seed operand list"
      //<< std::endl;
    }

  } else {
    //LogTrace("L1TGlobal")
    //        << "  More blocks:  push the last block on the seed operand list" << std::endl;

    for (std::vector<OperandToken>::reverse_iterator itOp = tmpVector.rbegin(); itOp != tmpVector.rend(); itOp++) {
      opVector.push_back(*itOp);

      //LogTrace("L1TGlobal")
      //<< "  Push operand:  " << (*itOp).tokenName
      //<<" on the seed operand list"
      //<< std::endl;
    }
  }

  // remove duplicates from the seed vector
  // slow...
  std::vector<OperandToken> opVectorU;
  opVectorU.reserve(opVector.size());

  for (std::vector<OperandToken>::const_iterator constIt = opVector.begin(); constIt != opVector.end(); constIt++) {
    bool tokenIncluded = false;

    for (std::vector<OperandToken>::iterator itOpU = opVectorU.begin(); itOpU != opVectorU.end(); itOpU++) {
      if ((*itOpU).tokenName == (*constIt).tokenName) {
        tokenIncluded = true;
        break;
      }
    }

    if (!tokenIncluded) {
      opVectorU.push_back(*constIt);
    }
  }

  return opVectorU;
}

// private methods

GlobalLogicParser::OperationType GlobalLogicParser::getOperation(const std::string& tokenString,
                                                                 OperationType lastOperation,
                                                                 TokenRPN& rpnToken) const {
  OperationType actualOperation = OP_OPERAND;  // default value

  int i = 0;

  while (m_operationRules[i].opType != OP_OPERAND) {
    if (tokenString == m_operationRules[i].opString) {
      actualOperation = (OperationType)m_operationRules[i].opType;
      break;
    }
    i++;
  }

  // check if the operation is allowed
  if (m_operationRules[i].forbiddenLastOperation & lastOperation) {
    return OP_INVALID;
  }

  //
  if (actualOperation == OP_OPERAND) {
    rpnToken.operand = tokenString;

  } else {
    rpnToken.operand = "";
  }

  rpnToken.operation = actualOperation;

  // else we got a valid operation
  return actualOperation;
}

const GlobalLogicParser::OperationRule* GlobalLogicParser::getRuleFromType(OperationType oType) {
  int i = 0;

  while ((m_operationRules[i].opType != oType) && (m_operationRules[i].opType != OP_NULL)) {
    i++;
  }

  if (m_operationRules[i].opType == OP_NULL) {
    return nullptr;
  }

  return &(m_operationRules[i]);
}

// add spaces before and after parentheses - make separation easier
void GlobalLogicParser::addBracketSpaces(const std::string& srcExpression, std::string& dstExpression) {
  static const std::string brackets = "()";  // the brackets to be found

  dstExpression = srcExpression;  // copy the string

  size_t position = 0;
  while ((position = dstExpression.find_first_of(brackets, position)) != std::string::npos) {
    // add space after if none is there
    if (((position + 1) != std::string::npos) && (dstExpression[position + 1] != ' ')) {
      dstExpression.insert(position + 1, " ");
    }

    // add space before if none is there
    if ((position != 0) && (dstExpression[position - 1] != ' ')) {
      dstExpression.insert(position, " ");
      position++;
    }
    position++;
  }
}

// set the logical expression - check for correctness the input string
bool GlobalLogicParser::setLogicalExpression(const std::string& logicalExpressionVal) {
  // add spaces around brackets
  std::string logicalExpressionBS;
  addBracketSpaces(logicalExpressionVal, logicalExpressionBS);

  // trim leading or trailing spaces
  boost::trim(logicalExpressionBS);

  clearRpnVector();

  if (!buildRpnVector(logicalExpressionBS)) {
    m_logicalExpression = "";
    return false;
  }

  m_logicalExpression = logicalExpressionBS;

  //LogDebug("L1TGlobal")
  //<< "\nGtLogicParser::setLogicalExpression - "
  //<< "\nLogical expression = '" << m_logicalExpression << "'\n"
  //<< std::endl;

  return true;
}

// set the numerical expression (the logical expression with each operand
// replaced with the value) from a string
// check also for correctness the input string
bool GlobalLogicParser::setNumericalExpression(const std::string& numericalExpressionVal) {
  // add spaces around brackets
  std::string numericalExpressionBS;
  addBracketSpaces(numericalExpressionVal, numericalExpressionBS);

  // check for consistency with the logical expression
  // TODO FIXME

  // trim leading or trailing spaces
  boost::trim(numericalExpressionBS);

  m_numericalExpression = numericalExpressionBS;

  //LogDebug("L1TGlobal")
  //<< "\nGtLogicParser::setNumericalExpression - "
  //<< "\nNumerical Expression = '" << m_numericalExpression << "'\n"
  //<< std::endl;

  return true;
}

// static members

// rules for operations
// 1st column: operation string
// 2nd column: operation type
// 3rd column: forbiddenLastOperation (what operation the operator/operand must not follow)
const struct GlobalLogicParser::OperationRule GlobalLogicParser::m_operationRules[] = {
    {"AND", OP_AND, OP_AND | OP_OR | OP_XOR | OP_NOT | OP_OPENBRACKET | OP_NULL},
    {"OR", OP_OR, OP_AND | OP_OR | OP_XOR | OP_NOT | OP_OPENBRACKET | OP_NULL},
    {"XOR", OP_XOR, OP_AND | OP_OR | OP_XOR | OP_NOT | OP_OPENBRACKET | OP_NULL},
    {"NOT", OP_NOT, OP_OPERAND | OP_CLOSEBRACKET},
    {"(", OP_OPENBRACKET, OP_OPERAND | OP_CLOSEBRACKET},
    {")", OP_CLOSEBRACKET, OP_AND | OP_OR | OP_XOR | OP_NOT | OP_OPENBRACKET},
    {nullptr, OP_OPERAND, OP_OPERAND | OP_CLOSEBRACKET},
    {nullptr, OP_NULL, OP_NULL}};