Expression.h

Go to the documentation of this file.

#ifndef __EXPRESSION_H__
#define __EXPRESSION_H__

#include <map>
#include <set>
#include <string>

#include "Util/Types.h"
#include "Util/OptPilotException.h"

#include "Expression/Parser/expression.hpp"
#include "Expression/Parser/evaluator.hpp"
#include "Expression/Parser/requirements.hpp"
#include "Expression/Parser/skipper.hpp"
#include "Expression/Parser/function.hpp"

#include <boost/function.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/variant/get.hpp>
#include <boost/variant/variant.hpp>
#include "boost/smart_ptr.hpp"
#include "boost/tuple/tuple.hpp"
#include "boost/algorithm/string.hpp"


typedef std::map<std::string, double> variableDictionary_t;
typedef std::map<std::string, client::function::type> functionDictionary_t;


class Expression;
namespace Expressions {

    typedef Expression Expr_t;

    // result of an evaluated expression
    typedef boost::tuple<double, bool> Result_t;
    enum Result_tIdx{
        VALUE,
        IS_VALID
    };

    //FIXME: this actually should be a map of type (name, fusion::vector<...>)
    typedef std::map<std::string, Expressions::Expr_t*> Named_t;

    //XXX name of one single expression
    typedef std::pair<std::string, Expressions::Expr_t*> SingleNamed_t;

    enum OperatorType_t {
        NONE,
        EQ,             // ==
        NOT_EQ,         // !=
        INEQ_LHS,       // <
        INEQ_LHS_EQ,    // <=
        INEQ_RHS,       // >
        INEQ_RHS_EQ     // >=
    };

}

#include "Expression/GlobalFunctions.h"

class Expression {

public:

    Expression()
    {}

    Expression(std::string expr)
        : expr_(expr)
    {
        determineConstrOperator();
        functionDictionary_t global_funcs = GlobalFunctions::get();
        known_expr_funcs_.insert(global_funcs.begin(), global_funcs.end());
        parse();
    }

    Expression(std::string expr, functionDictionary_t known_expr_funcs)
        : expr_(expr)
        , known_expr_funcs_(known_expr_funcs)
    {
        determineConstrOperator();
        functionDictionary_t global_funcs = GlobalFunctions::get();
        known_expr_funcs_.insert(global_funcs.begin(), global_funcs.end());
        parse();
    }

    virtual ~Expression()
    {}


    std::set<std::string> getReqVars()  const { return vars_;  }
    std::set<std::string> getReqFuncs() const { return funcs_; }
    std::string toString()              const { return expr_;  }
    functionDictionary_t getRegFuncs()  const { return known_expr_funcs_; }

    Expressions::OperatorType_t getOpType() const { return type_; }

    Expressions::Result_t evaluate(variableDictionary_t vars) {

        iterator_type iter = expr_.begin();
        iterator_type end  = expr_.end();
        client::error_handler<iterator_type> error_handler(iter, end);
        client::code_gen::StackEvaluator     evaluator(error_handler);
        evaluator.registerVariables(vars);
        evaluator.registerFunctions(known_expr_funcs_);

        double result = 0.0;
        bool   valid  = false;
        if (evaluator(ast_)) {
            result = evaluator.result();
            valid  = true;
        }

        return boost::make_tuple(result, valid);
    }


private:

    typedef std::string::const_iterator iterator_type;
    client::ast::expression ast_;

    std::set<std::string> vars_;
    std::set<std::string> funcs_;

    std::string expr_;
    functionDictionary_t known_expr_funcs_;

    Expressions::OperatorType_t type_;

    void determineConstrOperator() {

        std::string op = expr_;

        if(boost::find_first(op, "=="))
            type_ = Expressions::EQ;
        else if(boost::find_first(op, "!="))
            type_ = Expressions::NOT_EQ;
        else if(boost::find_first(op, "<="))
            type_ = Expressions::INEQ_LHS_EQ;
        else if(boost::find_first(op, "<"))
            type_ = Expressions::INEQ_LHS;
        else if(boost::find_first(op, ">="))
            type_ = Expressions::INEQ_RHS_EQ;
        else if(boost::find_first(op,">"))
            type_ = Expressions::INEQ_RHS;
        else
            type_ = Expressions::NONE;
    }

    void parse() {

        iterator_type iter = expr_.begin();
        iterator_type end  = expr_.end();

        client::error_handler<iterator_type>       error_handler(iter, end);
        client::parser::expression<iterator_type>  expression(error_handler);
        client::parser::skipper<iterator_type>     skipper;
        client::code_gen::requirements             requirements(error_handler);

        bool success = phrase_parse(iter, end, expression, skipper, ast_);

        if (!success || iter != end) {
            std::cout << "Parsing failed!" << std::endl;
            std::string here = (iter != end ? std::string(iter, end): expr_);
            throw new OptPilotException("Expression::parse()",
                                         "Parsing failed here: " + here + "!");
        }

        // store the functions and variables required to evaluate this
        // expression
        if (requirements(ast_)) {
            vars_ = requirements.variables();
            funcs_ = requirements.functions();
        }
    }
};

#endif