GlobalLogicParser Class Reference

#include <GlobalLogicParser.h>

Inheritance diagram for GlobalLogicParser:

Classes
struct	OperandToken
struct	OperationRule
struct	TokenRPN

Public Types
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 }
typedef std::vector< TokenRPN >	RpnVector

Public Member Functions
void	buildOperandTokenVector ()
void	buildOperandTokenVectorNumExp ()
bool	buildRpnVector (const std::string &)
	build the rpn vector More...
bool	checkLogicalExpression (std::string &)
	check a logical expression for correctness - add/remove spaces if needed More...
void	clearRpnVector ()
	clear possible old rpn vector More...
void	convertIntToNameLogicalExpression (const std::map< int, std::string > &intToNameMap)
void	convertNameToIntLogicalExpression (const std::map< std::string, int > &nameToIntMap)
virtual const bool	expressionResult () const
virtual const bool	expressionResultNumExp () const
std::vector< GlobalLogicParser::OperandToken >	expressionSeedsOperandList ()
	GlobalLogicParser ()
	constructor(s) More...
	GlobalLogicParser (const RpnVector &, const std::vector< OperandToken > &)
	GlobalLogicParser (const std::string &logicalExpressionVal)
	GlobalLogicParser (std::string &logicalExpressionVal)
	GlobalLogicParser (const std::string logicalExpressionVal, const std::string numericalExpressionVal)
	from a logical and a numerical expression More...
	GlobalLogicParser (const std::string &logicalExpressionVal, const std::string &numericalExpressionVal, const bool dummy)
std::string	logicalExpression () const
	return the logical expression More...
std::string	numericalExpression () const
	return the numerical expression More...
int	operandIndex (const std::string &operandNameVal) const
	return the position index of the operand in the logical expression More...
std::string	operandName (const int iOperand) const
	return the name of the (iOperand)th operand in the logical expression More...
bool	operandResult (const std::string &operandNameVal) const
bool	operandResult (const int tokenNumberVal) const
bool	operandResultNumExp (const std::string &operandNameVal) const
bool	operandResultNumExp (const int iOperand) const
std::vector< OperandToken > &	operandTokenVector ()
	return the vector of operand tokens More...
const std::vector< OperandToken > &	operandTokenVector () const
RpnVector	rpnVector () const
	return the RPN vector More...
virtual	~GlobalLogicParser ()
	destructor More...

Protected Member Functions
void	addBracketSpaces (const std::string &, std::string &)
	add spaces before and after parantheses More...
virtual OperationType	getOperation (const std::string &tokenString, OperationType lastOperation, TokenRPN &rpnToken) const
const OperationRule *	getRuleFromType (OperationType t)
	get the rule entry to an operation type More...
bool	setLogicalExpression (const std::string &)
	set the logical expression - check for correctness the input string More...
bool	setNumericalExpression (const std::string &)

Protected Attributes
std::string	m_logicalExpression
	logical expression to be parsed More...
std::string	m_numericalExpression
std::vector< OperandToken >	m_operandTokenVector
	vector of operand tokens More...
RpnVector	m_rpnVector
	RPN vector - equivalent to the logical expression. More...

Static Protected Attributes
static const struct OperationRule	m_operationRules []

Detailed Description

Description: see header file.

Implementation: <TODO: enter implementation details>

Author

: Vasile Mihai Ghete - HEPHY Vienna

Definition at line 17 of file GlobalLogicParser.h.

Member Typedef Documentation

RpnVector

typedef std::vector<TokenRPN> GlobalLogicParser::RpnVector

Definition at line 42 of file GlobalLogicParser.h.

Member Enumeration Documentation

OperationType

enum GlobalLogicParser::OperationType

Enumerator
OP_NULL
OP_INVALID
OP_AND
OP_OR
OP_NOT
OP_OPERAND
OP_OPENBRACKET
OP_CLOSEBRACKET
OP_XOR

Definition at line 25 of file GlobalLogicParser.h.

                     {
    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
  };

Constructor & Destructor Documentation

GlobalLogicParser() [1/6]

GlobalLogicParser::GlobalLogicParser

(

)

constructor(s)

default constructor

Definition at line 36 of file GlobalLogicParser.cc.

                                     {
  // empty, default C++ initialization for string and vector are enough
}

GlobalLogicParser() [2/6]

GlobalLogicParser::GlobalLogicParser	(	const RpnVector &	rpnVec,
		const std::vector< OperandToken > &	opTokenVector
	)

from the RPN vector and the operand token vector no checks for consistency, empty logical and numerical expressions requires special care when used

Definition at line 43 of file GlobalLogicParser.cc.

References m_operandTokenVector, and m_rpnVector.

                                                                                                          {
  m_rpnVector = rpnVec;
  m_operandTokenVector = opTokenVector;
}

GlobalLogicParser() [3/6]

GlobalLogicParser::GlobalLogicParser

(

const std::string &

logicalExpressionVal

)

from a constant logical expression numerical expression will be empty

Definition at line 50 of file GlobalLogicParser.cc.

References Exception, and setLogicalExpression().

                                                                          {
  // 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;
  }
}

GlobalLogicParser() [4/6]

GlobalLogicParser::GlobalLogicParser

(

std::string &

logicalExpressionVal

)

Definition at line 62 of file GlobalLogicParser.cc.

References addBracketSpaces(), buildOperandTokenVector(), buildRpnVector(), Exception, m_logicalExpression, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

                                                                    {
  // 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();
}

GlobalLogicParser() [5/6]

GlobalLogicParser::GlobalLogicParser	(	const std::string	logicalExpressionVal,
		const std::string	numericalExpressionVal
	)

from a logical and a numerical expression

Definition at line 92 of file GlobalLogicParser.cc.

References Exception, setLogicalExpression(), and setNumericalExpression().

                                                                                                                 {
  // 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;
  }
}

GlobalLogicParser() [6/6]

GlobalLogicParser::GlobalLogicParser	(	const std::string &	logicalExpressionVal,
		const std::string &	numericalExpressionVal,
		const bool	dummy
	)

from a logical and a numerical expression no checks for correctness - use it only after the correctness was tested

Definition at line 110 of file GlobalLogicParser.cc.

References buildRpnVector(), clearRpnVector(), Exception, m_logicalExpression, and m_numericalExpression.

                                                       {
  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;
}

~GlobalLogicParser()

GlobalLogicParser::~GlobalLogicParser ( )

virtual

destructor

Definition at line 124 of file GlobalLogicParser.cc.

                                      {
  // empty now
}

Member Function Documentation

addBracketSpaces()

void GlobalLogicParser::addBracketSpaces ( const std::string &  srcExpression, std::string &  dstExpression  )

protected

add spaces before and after parantheses

Definition at line 1399 of file GlobalLogicParser.cc.

References brackets, position, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by checkLogicalExpression(), GlobalLogicParser(), setLogicalExpression(), and setNumericalExpression().

                                                                                                 {
  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++;
  }
}

buildOperandTokenVector()

void GlobalLogicParser::buildOperandTokenVector

(

)

build from the RPN vector the operand token vector dummy tokenNumber and tokenResult

Definition at line 378 of file GlobalLogicParser.cc.

References m_operandTokenVector, m_rpnVector, OP_AND, OP_NOT, OP_OPERAND, OP_OR, OP_XOR, GlobalLogicParser::OperandToken::tokenName, GlobalLogicParser::OperandToken::tokenNumber, and GlobalLogicParser::OperandToken::tokenResult.

Referenced by GlobalLogicParser().

                                                {
  //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++;
  }
}

buildOperandTokenVectorNumExp()

void GlobalLogicParser::buildOperandTokenVectorNumExp

(

)

build from the RPN vector the operand token vector using a numerical expression

Definition at line 770 of file GlobalLogicParser.cc.

References m_operandTokenVector, m_rpnVector, OP_AND, OP_NOT, OP_OPERAND, OP_OR, OP_XOR, operandResultNumExp(), GlobalLogicParser::OperandToken::tokenName, GlobalLogicParser::OperandToken::tokenNumber, and GlobalLogicParser::OperandToken::tokenResult.

                                                      {
  //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++;
  }
}

buildRpnVector()

bool GlobalLogicParser::buildRpnVector

(

const std::string &

logicalExpressionVal

)

build the rpn vector

buildRpnVector Build the postfix notation.

Parameters

expression

The expression to be parsed.

Returns

"true" if everything was parsed. "false" if an error occured.

Definition at line 164 of file GlobalLogicParser.cc.

References clearRpnVector(), getOperation(), m_rpnVector, OP_AND, OP_CLOSEBRACKET, OP_INVALID, OP_NOT, OP_NULL, OP_OPENBRACKET, OP_OPERAND, OP_OR, OP_XOR, AlCaHLTBitMon_QueryRunRegistry::string, and gpuVertexFinder::ws.

Referenced by checkLogicalExpression(), GlobalLogicParser(), and setLogicalExpression().

                                                                            {
  //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;
}

checkLogicalExpression()

bool GlobalLogicParser::checkLogicalExpression

(

std::string &

logicalExpressionVal

)

check a logical expression for correctness - add/remove spaces if needed

Definition at line 131 of file GlobalLogicParser.cc.

References addBracketSpaces(), buildRpnVector(), clearRpnVector(), LogDebug, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

                                                                              {
  // 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;
}

clearRpnVector()

void GlobalLogicParser::clearRpnVector

(

)

clear possible old rpn vector

Definition at line 374 of file GlobalLogicParser.cc.

References m_rpnVector.

Referenced by buildRpnVector(), checkLogicalExpression(), GlobalLogicParser(), and setLogicalExpression().

{ m_rpnVector.clear(); }

convertIntToNameLogicalExpression()

void GlobalLogicParser::convertIntToNameLogicalExpression

(

const std::map< int, std::string > &

intToNameMap

)

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

Definition at line 998 of file GlobalLogicParser.cc.

References TauDecayModes::dec, getOperation(), getRuleFromType(), m_logicalExpression, OP_INVALID, OP_NULL, OP_OPERAND, GlobalLogicParser::TokenRPN::operand, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

                                                                                                    {
  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;
}

convertNameToIntLogicalExpression()

void GlobalLogicParser::convertNameToIntLogicalExpression

(

const std::map< std::string, int > &

nameToIntMap

)

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

Definition at line 917 of file GlobalLogicParser.cc.

References getOperation(), getRuleFromType(), Json::intValue, LogDebug, m_logicalExpression, OP_INVALID, OP_NULL, OP_OPERAND, GlobalLogicParser::TokenRPN::operand, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

                                                                                                    {
  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;
}

expressionResult()

const bool GlobalLogicParser::expressionResult ( ) const

virtual

return the result for the logical expression require a proper operand token vector

Definition at line 593 of file GlobalLogicParser.cc.

References b1, b2, m_rpnVector, OP_AND, OP_NOT, OP_OPERAND, OP_OR, OP_XOR, and operandResult().

Referenced by HLTL1TSeed::seedsL1TriggerObjectMaps().

                                                     {
  //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();
}

expressionResultNumExp()

const bool GlobalLogicParser::expressionResultNumExp ( ) const

virtual

return the result for the logical expression require a proper numerical expression

Definition at line 831 of file GlobalLogicParser.cc.

References b1, b2, m_rpnVector, OP_AND, OP_NOT, OP_OPERAND, OP_OR, OP_XOR, and operandResultNumExp().

                                                           {
  //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();
}

expressionSeedsOperandList()

std::vector< GlobalLogicParser::OperandToken > GlobalLogicParser::expressionSeedsOperandList

(

)

return the list of operand tokens for the logical expression which are to be used as seeds

Definition at line 1079 of file GlobalLogicParser.cc.

References b1, b2, m_operandTokenVector, m_rpnVector, OP_AND, OP_NOT, OP_OPERAND, OP_OR, OP_XOR, GlobalLogicParser::OperandToken::tokenName, GlobalLogicParser::OperandToken::tokenNumber, and GlobalLogicParser::OperandToken::tokenResult.

Referenced by HLTL1TSeed::HLTL1TSeed().

                                                                                       {
  //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;
}

getOperation()

GlobalLogicParser::OperationType GlobalLogicParser::getOperation ( const std::string &  tokenString, OperationType  lastOperation, TokenRPN &  rpnToken  ) const

protectedvirtual

getOperation Get the operation from a string and check if it is allowed

Parameters

tokenString	The string to examine.
lastOperation	The last operation.
rpnToken	The destination where the token for postfix notation is written to.

Returns

The Operation type or OP_INVALID, if the operation is not allowed

Definition at line 1340 of file GlobalLogicParser.cc.

References mps_fire::i, m_operationRules, OP_INVALID, OP_OPERAND, GlobalLogicParser::TokenRPN::operand, and GlobalLogicParser::TokenRPN::operation.

Referenced by buildRpnVector(), convertIntToNameLogicalExpression(), convertNameToIntLogicalExpression(), operandIndex(), operandName(), and operandResultNumExp().

                                                                                           {
  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;
}

getRuleFromType()

const GlobalLogicParser::OperationRule * GlobalLogicParser::getRuleFromType ( OperationType  oType )

protected

get the rule entry to an operation type

getRuleFromType Looks for the entry in the operation rules and returns a reference if it was found

Parameters

oType

The type of the operation.

Returns

The reference to the entry or 0 if the Rule was not found.

Definition at line 1384 of file GlobalLogicParser.cc.

References mps_fire::i, m_operationRules, and OP_NULL.

Referenced by convertIntToNameLogicalExpression(), and convertNameToIntLogicalExpression().

                                                                                            {
  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]);
}

logicalExpression()

std::string GlobalLogicParser::logicalExpression ( ) const

inline

return the logical expression

Definition at line 77 of file GlobalLogicParser.h.

References m_logicalExpression.

{ return m_logicalExpression; }

numericalExpression()

std::string GlobalLogicParser::numericalExpression ( ) const

inline

return the numerical expression

Definition at line 83 of file GlobalLogicParser.h.

References m_numericalExpression.

{ return m_numericalExpression; }

operandIndex()

int GlobalLogicParser::operandIndex

(

const std::string &

operandNameVal

)

const

return the position index of the operand in the logical expression

Definition at line 437 of file GlobalLogicParser.cc.

References getOperation(), m_logicalExpression, OP_INVALID, OP_NULL, OP_OPERAND, GlobalLogicParser::TokenRPN::operand, mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by operandResultNumExp().

                                                                         {
  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;
}

operandName()

std::string GlobalLogicParser::operandName

(

const int

iOperand

)

const

return the name of the (iOperand)th operand in the logical expression

Definition at line 498 of file GlobalLogicParser.cc.

References getOperation(), m_logicalExpression, OP_INVALID, OP_NULL, OP_OPERAND, GlobalLogicParser::TokenRPN::operand, mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 {
  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;
}

operandResult() [1/2]

bool GlobalLogicParser::operandResult

(

const std::string &

operandNameVal

)

const

return the result for an operand with name operandNameVal in the logical expression using the operand token vector

Definition at line 560 of file GlobalLogicParser.cc.

References mps_fire::i, and m_operandTokenVector.

Referenced by expressionResult(), and operandResultNumExp().

                                                                           {
  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;
}

operandResult() [2/2]

bool GlobalLogicParser::operandResult

(

const int

tokenNumberVal

)

const

return the result for an operand with tokenNumberVal using the operand token vector

Definition at line 576 of file GlobalLogicParser.cc.

References mps_fire::i, and m_operandTokenVector.

                                                                    {
  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;
}

operandResultNumExp() [1/2]

bool GlobalLogicParser::operandResultNumExp

(

const std::string &

operandNameVal

)

const

return the result for an operand with name operandNameVal in the logical expression using a numerical expression

Definition at line 675 of file GlobalLogicParser.cc.

References operandIndex(), operandResult(), and mps_fire::result.

Referenced by buildOperandTokenVectorNumExp(), and expressionResultNumExp().

                                                                                 {
  bool result = false;

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

  result = operandResult(iOperand);

  return result;
}

operandResultNumExp() [2/2]

bool GlobalLogicParser::operandResultNumExp

(

const int

iOperand

)

const

return the result for an operand with index iOperand in the logical expression using a numerical expression

Definition at line 688 of file GlobalLogicParser.cc.

References getOperation(), m_numericalExpression, OP_INVALID, OP_NULL, OP_OPERAND, GlobalLogicParser::TokenRPN::operand, mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                    {
  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;
}

operandTokenVector() [1/2]

std::vector<OperandToken>& GlobalLogicParser::operandTokenVector ( )

inline

return the vector of operand tokens

Definition at line 100 of file GlobalLogicParser.h.

References m_operandTokenVector.

Referenced by HLTL1TSeed::HLTL1TSeed(), and HLTL1TSeed::seedsL1TriggerObjectMaps().

{ return m_operandTokenVector; }

operandTokenVector() [2/2]

const std::vector<OperandToken>& GlobalLogicParser::operandTokenVector ( ) const

inline

Definition at line 101 of file GlobalLogicParser.h.

References m_operandTokenVector.

{ return m_operandTokenVector; }

rpnVector()

RpnVector GlobalLogicParser::rpnVector ( ) const

inline

return the RPN vector

Definition at line 93 of file GlobalLogicParser.h.

References m_rpnVector.

Referenced by GlobalAlgorithm::GlobalAlgorithm().

{ return m_rpnVector; }

setLogicalExpression()

bool GlobalLogicParser::setLogicalExpression ( const std::string &  logicalExpressionVal )

protected

set the logical expression - check for correctness the input string

Definition at line 1421 of file GlobalLogicParser.cc.

References addBracketSpaces(), buildRpnVector(), clearRpnVector(), m_logicalExpression, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

Referenced by GlobalLogicParser().

                                                                                  {
  // 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;
}

setNumericalExpression()

bool GlobalLogicParser::setNumericalExpression ( const std::string &  numericalExpressionVal )

protected

set the numerical expression (the logical expression with each operand replaced with the value) from a string check also for correctness the input string

Definition at line 1449 of file GlobalLogicParser.cc.

References addBracketSpaces(), m_numericalExpression, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

Referenced by GlobalLogicParser().

                                                                                      {
  // 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;
}

Member Data Documentation

m_logicalExpression

std::string GlobalLogicParser::m_logicalExpression

protected

logical expression to be parsed

Definition at line 182 of file GlobalLogicParser.h.

Referenced by convertIntToNameLogicalExpression(), convertNameToIntLogicalExpression(), GlobalLogicParser(), logicalExpression(), operandIndex(), operandName(), and setLogicalExpression().

m_numericalExpression

std::string GlobalLogicParser::m_numericalExpression

protected

numerical expression (logical expression with operands replaced with the actual values)

Definition at line 186 of file GlobalLogicParser.h.

Referenced by GlobalLogicParser(), numericalExpression(), operandResultNumExp(), and setNumericalExpression().

m_operandTokenVector

std::vector<OperandToken> GlobalLogicParser::m_operandTokenVector

protected

vector of operand tokens

Definition at line 192 of file GlobalLogicParser.h.

Referenced by buildOperandTokenVector(), buildOperandTokenVectorNumExp(), expressionSeedsOperandList(), GlobalLogicParser(), operandResult(), and operandTokenVector().

m_operationRules

const struct OperationRule GlobalLogicParser::m_operationRules[]

staticprotected

Definition at line 166 of file GlobalLogicParser.h.

Referenced by getOperation(), and getRuleFromType().

m_rpnVector

RpnVector GlobalLogicParser::m_rpnVector

protected

RPN vector - equivalent to the logical expression.

Definition at line 189 of file GlobalLogicParser.h.

Referenced by buildOperandTokenVector(), buildOperandTokenVectorNumExp(), buildRpnVector(), clearRpnVector(), expressionResult(), expressionResultNumExp(), expressionSeedsOperandList(), GlobalLogicParser(), and rpnVector().