expression.hpp

/*
 * expression.hpp
 *
 * Created on: 26 Jan 2011
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_EXPRESSION_HPP_
#define SCHNEK_EXPRESSION_HPP_

#include "variables.hpp"
#include "../util/logger.hpp"

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-copy"

#include <boost/lexical_cast.hpp>
#include <boost/function.hpp>

#include <boost/fusion/include/push_back.hpp>
#include <boost/fusion/include/invoke.hpp>
#include <boost/fusion/include/cons.hpp>

#include <boost/mpl/begin.hpp>
#include <boost/mpl/end.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/deref.hpp>

#pragma GCC diagnostic pop
#pragma GCC diagnostic pop

#include <memory>
#include <string>
#include <iostream>
#include <set>

#undef LOGLEVEL
#define LOGLEVEL 0

namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
namespace bft = boost::function_types;

namespace schnek {

class WrongNumberOfArgsException : public EvaluationException
{
  public:
    WrongNumberOfArgsException() : EvaluationException("Wrong number of arguments!") {}
};

class FunctionNotFoundException : public EvaluationException
{
  public:
    FunctionNotFoundException(std::string functionName) : EvaluationException("Function '"+functionName+"' was not defined!") {}
};

class TypeCastException : public EvaluationException
{
  public:
    TypeCastException() : EvaluationException("Could not convert types") {}
};

typedef std::set<long> DependencyList;

template<typename vtype>
class Expression
{
  public:
    virtual ~Expression() {}

    virtual vtype eval() = 0;

    virtual bool isConstant() = 0;

    vtype operator()() { return eval(); }

    virtual DependencyList getDependencies() { return DependencyList(); }

    typedef std::shared_ptr<Expression> pExpression;
    typedef vtype ValueType;
};

template<class ResultVariant>
struct ExpressionEvaluator : public boost::static_visitor<ResultVariant>
{
  template<class ExpressionPointer>
  ResultVariant operator()(ExpressionPointer e) { return e->eval(); }
};

template<typename vtype>
class Value : public Expression<vtype>
{
  private:
    vtype val;
  public:
    typedef vtype ValueType;
    Value(vtype val_) : val(val_) {}
    vtype eval()
    {
      SCHNEK_TRACE_LOG(5, "Value<vtype>::eval(" << val << ")")
      return val;
    }
    bool isConstant() { return true; }
    vtype &getReference() { return val; }
};

template<typename vtype>
class ReferencedValue : public Expression<vtype>
{
  private:
    pVariable var;
  public:
    ReferencedValue(const pVariable &var_) : var(var_) {}
    vtype eval() {
//      if (var->isConstant())
//      {
//        //std::cerr << "Attempting to assign variable\n";
//        return boost::get<vtype>(var->getValue());
//      }
//      else
//        return boost::get<vtype>(var->evaluateExpression());
       // it is assumed that the referenced variable has been evaluated
      SCHNEK_TRACE_LOG(5, "ReferencedValue<vtype>::eval(" << var->getValue() << ")")
      return boost::get<vtype>(var->getValue());
    }
    bool isConstant() { return var->isConstant(); }

    DependencyList getDependencies()
    {
      DependencyList dep;
      dep.insert(var->getId());
      return dep;
    }
};

template<typename vtype>
class ExternalValue : public Expression<vtype>
{
  private:
    vtype *var;
  public:
    ExternalValue(vtype *var_) : var(var_) {}

    vtype eval() {
//      std::cout << "Returning value " << *var << "\n";
      SCHNEK_TRACE_LOG(5, "ExternalValue<vtype>::eval(" << *var << ")")
      return *var;
    }

    bool isConstant() { return false; }
};

template<class oper, class vtype>
class UnaryOp : public Expression<vtype>
{
  private:
    typedef typename Expression<vtype>::pExpression pExpression;
    pExpression expr;
  public:
    UnaryOp(pExpression expr_) : expr(expr_) {}

    vtype eval() { return oper::eval(expr->eval()); }

    bool isConstant() { return expr->isConstant(); }

    DependencyList getDependencies()
    {
      return expr->getDependencies();
    }
};

template<class vtype>
struct ExpressionInfo {
  bool positive;
  typename Expression<vtype>::pExpression expression;
  ExpressionInfo(bool positive_, typename Expression<vtype>::pExpression expression_)
    : positive(positive_), expression(expression_) {}
};

template<class oper, class vtype>
class BinaryOp : public Expression<vtype>
{
  private:
    typedef BinaryOp<oper, vtype> SelfType;
    typedef typename Expression<vtype>::pExpression pExpression;

    typedef BinaryOp<typename oper::Inverted, vtype> InvType;
    typedef std::shared_ptr<InvType> pInvType;
    friend class BinaryOp<typename oper::Inverted, vtype>;

    std::list<ExpressionInfo<vtype> > expressions;
  public:
    BinaryOp(pExpression expr1_, pExpression expr2_)
    {
      typedef std::shared_ptr<BinaryOp<oper, vtype> > pBinaryOp;

      pBinaryOp binaryExpr1 = std::dynamic_pointer_cast<SelfType>(expr1_);
      pInvType invExpr1 = std::dynamic_pointer_cast<InvType>(expr1_);

      pBinaryOp binaryExpr2 = std::dynamic_pointer_cast<SelfType>(expr2_);
      pInvType invExpr2 = std::dynamic_pointer_cast<InvType>(expr2_);

      if (binaryExpr1)
      {
        expressions.insert(expressions.end(), binaryExpr1->expressions.begin(), binaryExpr1->expressions.end());
      }
      else if (invExpr1)
      {
        expressions.insert(expressions.end(), invExpr1->expressions.begin(), invExpr1->expressions.end());
      }
      else
      {
        expressions.push_back(ExpressionInfo<vtype>(true, expr1_));
      }

      if (binaryExpr2)
      {
        typename std::list<ExpressionInfo<vtype> >::iterator it = binaryExpr2->expressions.begin();
        if (!oper::isPositive)
        {
          expressions.push_back(ExpressionInfo<vtype>(!it->positive, it->expression));
          ++it;
        }
        expressions.insert(expressions.end(), it, binaryExpr2->expressions.end());
      }
      else if (invExpr2)
      {
        typename std::list<ExpressionInfo<vtype> >::iterator it = invExpr2->expressions.begin();
        if (!oper::isPositive)
        {
          expressions.push_back(ExpressionInfo<vtype>(!it->positive, it->expression));
          ++it;
        }
        expressions.insert(expressions.end(), it, invExpr2->expressions.end());
      }
      else
      {
        expressions.push_back(ExpressionInfo<vtype>(oper::isPositive, expr2_));
      }
    }

    vtype eval() {
      typedef typename oper::Positive opPositive;
      typedef typename oper::Negative opNegative;
      typename std::list<ExpressionInfo<vtype> >::iterator it = expressions.begin();
//      std::cout << std::endl << "EVAL: " << expressions.size() << std::endl;
      vtype val = it->expression->eval();

      while (++it != expressions.end())
      {
//        std::cout << "    : " << val << " " << it->positive << " " << it->expression->eval() << " ";
        val = it->positive ? opPositive::eval(val, it->expression->eval()) : opNegative::eval(val, it->expression->eval());
//        std::cout << val << std::endl;
      }
      return val;
    }

    bool isConstant() {
      for(ExpressionInfo<vtype> exp: expressions)
      {
          if (!exp.expression->isConstant()) return false;
      }
      return true;
    }

    DependencyList getDependencies()
    {
      DependencyList dependencies;

      for(ExpressionInfo<vtype> exp: expressions)
      {
        DependencyList dep = exp.expression->getDependencies();
        dependencies.insert(dep.begin(), dep.end());
      }
      return dependencies;
    }
};

template<class vtype>
struct FastCast
{
  vtype operator()(int a);
  vtype operator()(double a);
  vtype operator()(std::string a);
};

template<>
struct FastCast<int>
{
    int operator()(int a) { return a; }
    int operator()(double a) { return static_cast<int>(a); }
    int operator()(std::string a) { return boost::lexical_cast<int>(a); }
};

template<>
struct FastCast<double>
{
    double operator()(int a) { return static_cast<double>(a); }
    double operator()(double a) { return a; }
    double operator()(std::string a) { return boost::lexical_cast<double>(a); }
};

template<>
struct FastCast<std::string>
{
    std::string operator()(int a) { return boost::lexical_cast<std::string>(a); }
    std::string operator()(double a) { return boost::lexical_cast<std::string>(a); }
    std::string operator()(std::string a) { return a; }
};



template<class vtype>
struct StaticCast
{
  public:
    template<class atype>
    vtype operator()(const atype& a) { return static_cast<vtype>(a); }
};

template<class vtype>
struct LexicalCast
{
  public:
    template<class atype>
    vtype operator()(const atype& a) { return boost::lexical_cast<vtype>(a); }
};

template<class vtype, class vtype_orig, template<class> class CastType = StaticCast>
class TypecastOp : public Expression<vtype>
{
  public:
    typedef typename Expression<vtype_orig>::pExpression pExpressionOrig;
  private:
    pExpressionOrig expr;
  public:
    TypecastOp(pExpressionOrig expr_) : expr(expr_) {}

    vtype eval() {
      try {
        return CastType<vtype>()(expr->eval());
      }
      catch(boost::bad_lexical_cast &e)
      {
        throw TypeCastException();
      }
    }

    bool isConstant() { return expr->isConstant(); }

    DependencyList getDependencies()
    {
      return expr->getDependencies();
    }
};

struct DependenciesGetter : public boost::static_visitor<DependencyList>
{
  template<class ExpressionPointer>
  DependencyList operator()(ExpressionPointer e) { return e->getDependencies(); }
};

#undef LOGLEVEL
#define LOGLEVEL 0

} // namespace schnek

#endif // SCHNEK_EXPRESSION_HPP_