L1GtLogicParser.h

Go to the documentation of this file.

#ifndef L1GlobalTrigger_L1GtLogicParser_h
#define L1GlobalTrigger_L1GtLogicParser_h

// system include files
#include <string>
#include <vector>
#include <list>
#include <map>

#include <iosfwd>

// user include files

// forward declarations

// class declaration
class L1GtLogicParser
{

public:

    struct OperandToken
    {
        std::string tokenName;
        int tokenNumber;
        bool tokenResult;
    };

    enum OperationType {
        OP_NULL=1,
        OP_INVALID=2,
        OP_AND=4,
        OP_OR=8,
        OP_NOT=16,
        OP_OPERAND=32,
        OP_OPENBRACKET=64,
        OP_CLOSEBRACKET=128
    };

    struct TokenRPN
    {
        OperationType operation;             // type of operation: AND, OR, NOT or OPERAND
        std::string   operand;               // a possible operand
    };

    typedef std::vector<TokenRPN> RpnVector;

public:


    L1GtLogicParser();

    L1GtLogicParser(const RpnVector&, const std::vector<OperandToken>&);

    L1GtLogicParser(const std::string& logicalExpressionVal);

    //   from a non-constant logical expression - add/remove spaces if needed
    //   numerical expression will be empty
    L1GtLogicParser(std::string& logicalExpressionVal);

    L1GtLogicParser(const std::string logicalExpressionVal,
                    const std::string numericalExpressionVal);

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

    virtual ~L1GtLogicParser();

public:

    inline std::string logicalExpression() const { return m_logicalExpression; }

    bool checkLogicalExpression(std::string&);

    inline std::string numericalExpression() const { return m_numericalExpression; }

public:

    bool buildRpnVector(const std::string&);

    void clearRpnVector();

    inline RpnVector rpnVector() const { return m_rpnVector; }

    void buildOperandTokenVector();

    inline std::vector<OperandToken>& operandTokenVector() { return m_operandTokenVector; }
    inline const std::vector<OperandToken>& operandTokenVector() const { return m_operandTokenVector; }

public:

    int operandIndex(const std::string& operandNameVal) const;

    std::string operandName(const int iOperand) const;

    bool operandResult(const std::string& operandNameVal) const;

    bool operandResult(const int tokenNumberVal) const;

    virtual const bool expressionResult() const;

    bool operandResultNumExp(const std::string& operandNameVal) const;

    bool operandResultNumExp(const int iOperand) const;

    void buildOperandTokenVectorNumExp();

    virtual const bool expressionResultNumExp() const;

    void convertNameToIntLogicalExpression(
        const std::map<std::string, int>& nameToIntMap);


    void convertIntToNameLogicalExpression(const std::map<int, std::string>& intToNameMap);

    std::vector<L1GtLogicParser::OperandToken> expressionSeedsOperandList();


protected:


    struct OperationRule
    {
        const char* opString;
        int         opType;
        int         forbiddenLastOperation;    // int for bitmask of forbidden operations
    };


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

    const OperationRule* getRuleFromType(OperationType t);

    static const struct OperationRule m_operationRules[];

protected:

    void addBracketSpaces(const std::string&, std::string&);

    bool setLogicalExpression(const std::string&);

    bool setNumericalExpression(const std::string&);

protected:

    std::string m_logicalExpression;

    std::string m_numericalExpression;

    RpnVector m_rpnVector;

    std::vector<OperandToken> m_operandTokenVector;


};

#endif /*L1GlobalTrigger_L1GtLogicParser_h*/