#include "functor.h"

#include <boost/proto/core.hpp>
#include <boost/proto/context.hpp>
namespace proto = boost::proto;
using proto::_;

template<typename Expr>
struct PredicateExpr;

struct PredicateGramma:proto::or_<
  proto::terminal<base<_> const& >,
  proto::logical_or<PredicateGramma, PredicateGramma>,
  proto::logical_and<PredicateGramma, PredicateGramma>,
  proto::negate<PredicateGramma> >{};

struct PredicateDomain: proto::domain<proto::generator<PredicateExpr>, PredicateGramma>{};

struct PredicateContext{
  int i;
  PredicateContext(int i_):i(i_){}

  template<typename Expr, typename Tag = typename Expr::proto_tag>
  struct eval:proto::default_eval<Expr, PredicateContext>{};

  template<typename Expr>
  struct eval<Expr, proto::tag::terminal>{
    typedef typename bool result_type;
    result_type operator()(Expr & expr, PredicateContext& ctx)const{
      return proto::value(expr)(ctx.i);
    }
  };

};

template<typename Expr>
struct PredicateExpr : proto::extends<Expr, PredicateExpr<Expr>, PredicateDomain>
{
  PredicateExpr( const Expr& expr = Expr()):PredicateExpr::proto_extends(expr){}

  bool operator()(int i)  const{
    PredicateContext ctx(i);

    return proto::eval(*this, ctx);
  }

};




template<typename T>
struct Predicate:PredicateExpr<typename proto::terminal<base<T > const&>::type>
{
  typedef typename proto::terminal<base<T> const&>::type  expr_type;

  Predicate():PredicateExpr<expr_type>(expr_type::make(T())){}

  template<typename R>
  Predicate(R r):PredicateExpr<expr_type>(expr_type::make(T(r))){}


};