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 <map>
#    include <stack>
#    include <string>
#    include <vector>

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