gls_bool_expression.h

Go to the documentation of this file.

#if !defined(GLS_BOOLEXPRESSION_H)
#define GLS_BOOLEXPRESSION_H

#ifdef WIN32
#pragma warning (disable:4786)
#endif

#include <string>
#include <map>
#include <vector>
#include <stack>

class GlsMenuDictionary;

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
class GlsBoolExpression
{
public:
  
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    GlsBoolExpression(GlsMenuDictionary& evalDict, bool defaultVal = false);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual ~GlsBoolExpression() {}

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    bool operator()() const;

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual void Set(const std::string& val);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    GlsBoolExpression& operator=(const GlsBoolExpression& r)
    {
        if (this != &r)
        {
            _RPNTokens        = r._RPNTokens;
            _latestValue      = r._latestValue;
            _expressionString = r._expressionString;
        }

        return *this;
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    bool operator==(const GlsBoolExpression& r) const
    {
        return _latestValue == r._latestValue;
    }


    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    std::string ExpressionString() const
        {
                return _expressionString;
        }


protected:

    enum Operator_t 
    {
        OR, 
        AND, 
        EQ, 
        NEQ,
        LT,
        LT_EQ,
        GT,
        GT_EQ,
        NOT,
        OPEN_PAREN,
        CLOSE_PAREN,

        MAX_OPERATORS,
    };

    typedef std::vector<std::string> TokenCont_t;
    typedef std::map<std::string, Operator_t> OperatorMap_t;

    static bool _initializedStaticData;

    static OperatorMap_t OP;

    static const unsigned PRECEDENCE[MAX_OPERATORS];

    GlsMenuDictionary& _evalDict;

    std::string _expressionString;

    mutable bool _latestValue;

    TokenCont_t _RPNTokens;


    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual std::string Evaluate(Operator_t op, 
                                 const std::string& operand1,
                                 const std::string& operand2) const;

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    virtual bool IsTrue(const std::string& word) const;

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    static bool IsAnOperator(const std::string& token)
    {
        return OP.find(token) != OP.end();
    }

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    static TokenCont_t InfixToRPN(const TokenCont_t& infixTokens);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    static void Tokenize(const std::string& expr, TokenCont_t& tokens);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    static std::string::size_type VarLength(
        const std::string& input, 
        std::string::size_type start);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    static std::string Uppercase(const std::string& str);


    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    static bool ValidInfix(const TokenCont_t& infixTokens);

}; // end GlsBoolExpression


//------------------------------------------------------------------------
//------------------------------------------------------------------------
inline std::ostream& operator<<(std::ostream& outstr, const GlsBoolExpression& e)
{
    outstr << e.ExpressionString();
    return outstr;
}

//------------------------------------------------------------------------
//------------------------------------------------------------------------
inline std::istream& operator>>(std::istream& instr, GlsBoolExpression& e)
{
    std::string exprStr;
    std::getline(instr, exprStr);
    e.Set(exprStr);
    return instr;
}


#endif // GLS_BOOLEXPRESSION_H