// TestProto.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>

using namespace std;
namespace proto = boost::proto;

struct guard_tag{};

// grammar forbidding address of for terminals
struct terminal_grammar : 
		proto::not_<proto::address_of<proto::_> >
{};

// Forward-declare an expression wrapper
template<typename Expr>
struct mp_terminal;

struct sm_domain
	: proto::domain< proto::generator<mp_terminal>, terminal_grammar >
{};

template<typename Expr>
struct mp_terminal
	: proto::extends<Expr, mp_terminal<Expr>, sm_domain>
{
	typedef
		proto::extends<Expr, mp_terminal<Expr>, sm_domain>
		base_type;
	// Needs a constructor
	mp_terminal(Expr const &e = Expr())
		: base_type(e)
	{}
	// Unhide Proto's overloaded assignment operator
	using base_type::operator=;
};

template <class T1,class T2>
struct GuardOR 
{
    template <class FSM,class EVT,class SourceState,class TargetState>
    bool operator()(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt)
    {
        return (T1()(fsm,evt,src,tgt) || T2()(fsm,evt,src,tgt));
    }
};
template <class T1,class T2>
struct GuardAND 
{
	template <class FSM,class EVT,class SourceState,class TargetState>
	bool operator()(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt)
	{
		return (T1()(fsm,evt,src,tgt) && T2()(fsm,evt,src,tgt));
	}
};
template <class T1>
struct GuardNOT 
{
	template <class FSM,class EVT,class SourceState,class TargetState>
	bool operator()(FSM& fsm,EVT const& evt,SourceState& src,TargetState& tgt)
	{
		return !(T1()(fsm,evt,src,tgt));
	}
};

struct BuildGuards
   : proto::or_<
        proto::when<
                    proto::logical_or<BuildGuards,BuildGuards >,
                    GuardOR<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
                >,
        proto::when<
                    proto::logical_and<BuildGuards,BuildGuards >,
                    GuardAND<BuildGuards(proto::_left),BuildGuards(proto::_right)>()
                >,
        proto::when<
                    proto::logical_not<BuildGuards >,
                    GuardNOT<BuildGuards(proto::_value)>()
                >,
         proto::when <
					proto::terminal<guard_tag>,
                    proto::_()
				>
   >
{};

struct True : mp_terminal<typename proto::terminal<guard_tag>::type>
{
	template <class T>
	bool operator()(T&)
	{
		std::cout << "always true" << std::endl;
		return true;
	}
};
struct False : mp_terminal<typename proto::terminal<guard_tag>::type>
{
	template <class T>
	bool operator()(T& )
	{
		std::cout << "always false" << std::endl;
		return false;
	}
};
struct Dummy1 : mp_terminal<typename proto::terminal<guard_tag>::type>
{
	template <class T>
	bool operator()(T& )
	{
		std::cout << "dummy" << std::endl;
		return true;
	}
};
template <class Expr>
void print_guard(Expr const& expr)
{
	cout << "in print_guard" << endl;
	cout << "matches:" << proto::matches<Expr,BuildGuards>::value << endl;
	typedef
		boost::result_of<BuildGuards(Expr)>::type
		result_type;
	cout << "result_type" << endl;
	cout << typeid(result_type).name() << endl;

	cout << "end print_guard" << endl;
}

int main()
{
	print_guard((True()&& Dummy1()));
	print_guard((True()|| False()));
	print_guard( ( True()&& (Dummy1() || !(False() || True())) ) );
	print_guard((True()|| !False()));
	print_guard( (!False()) );
    return 0;
}