The Big Programming Thread - Page 508

#pragma once
#include<utility>
#include<is_member.hpp>
#include<variant_t.hpp>

namespace tags{

struct add{};
struct sub{};

}

template<class tag> struct binop_t;
typedef binop_t<tags::add> add_t;
typedef binop_t<tags::sub> sub_t;

typedef variant_t<add_t,sub_t,int> node_t;

template<class tag>
struct binop_t{
	node_t lhs,rhs;	
	binop_t(node_t&& _lhs,node_t&& _rhs):
		lhs(std::move(_lhs)),
		rhs(std::move(_rhs))
	{}
	binop_t()=delete;
	binop_t(binop_t&& binop)=default;
	binop_t& operator=(binop_t&& binop)=default;
	binop_t(const binop_t& binop)=default;
	binop_t& operator=(const binop_t& binop)=default;
};

#pragma once
#include<iostream>
#include<node_t.hpp>
#include<apply_visitor.hpp>

struct printer_t{
	typedef void return_type;
	int indentation{1};
	std::ostream& out;

	void indent(){ for(int i=0;i<indentation;++i) out<<"  "; }

	template<class T>
	void print(const T& obj){
		indent();
		out<<obj<<std::endl;
	}

	printer_t(std::ostream& _out):out(_out){}

	void operator()(int node){ print(node); }

	template<class tag>
	void operator()(const binop_t<tag>& node){ 
		print(is_add<tag>::value?'+':'-');
		++indentation;
		apply_visitor(*this,node.lhs);
		apply_visitor(*this,node.rhs);
		--indentation;
	}

};

#pragma once
#include<apply_visitor.hpp>
#include<node_t.hpp>

struct evaluator_t{
	typedef int return_type;

	int operator()(int node)const{ return node; }

	int operator()(const add_t& node)const{ 
		int lhs=apply_visitor(*this,node.lhs);
		int rhs=apply_visitor(*this,node.rhs);
		return lhs+rhs;
	}

	int operator()(const sub_t& node)const{
		int lhs=apply_visitor(*this,node.lhs);
		int rhs=apply_visitor(*this,node.rhs);
		return lhs-rhs;
	}

};

#include<exception>
#include<iostream>
#include<sstream>
#include<vector>

#include<apply_visitor.hpp>
#include<node_t.hpp>
#include<printer_t.hpp>
#include<evaluator_t.hpp>

using namespace std;

int main(){
	
	try{
		//some copy / move semantics
		node_t node0(add_t(1,1)); 		//add_t value ctor @ callsite, 
								//add_t move ctored  @ node0
		node_t node1(node0);			//add_t copy ctor @ node1 <- node0
		node_t node2(std::move(node1));	//add_t move ctor @ node2 <- node1
		node_t node3=node2;			//add_t copy asgn @ node3 <- node2
		node_t node4=std::move(node3);	//add_t move asgn @ node4 <- node3
		//make some nodes
		vector<node_t> nodes{
			add_t(
				sub_t(4,2),
				add_t(0,4)
			),
			2,
			sub_t(
				add_t(sub_t(0,4),add_t(2,0)),
				add_t(sub_t(4,2),add_t(0,4))
			),
			add_t(
				sub_t(
					2,
					add_t(sub_t(0,4),add_t(add_t(sub_t(2,0),add_t(4,2)),0))
				),
				sub_t(
					add_t(sub_t(4,2),add_t(0,4)),
					add_t(2,add_t(0,sub_t(4,sub_t(2,0))))
				)
			)
		};
		//loop, print and evaluate
		for(const auto& root:nodes){
			stringstream ast;
			apply_visitor(printer_t(ast),root);
			int result=apply_visitor(evaluator_t(),root);
			cout<<"\nast:\n"<<ast.str()<<"\nresult: "<<result<<"\n\n";
		}
	
	}catch(exception const& e){
		cout<<"exception caught: "<<e.what()<<endl;
	}
	return 0;
}

[jeh@gimli workbench]$ make
g++ -c -std=c++1y -I. -Wfatal-errors -fdiagnostics-color -fmessage-length=64 -ggdb main.cpp
g++ -o workbench main.o 
rm -rf *o 
[jeh@gimli workbench]$ ./workbench 

ast:
  +
    -
      4
      2
    +
      0
      4

result: 6


ast:
  2

result: 2


ast:
  -
    +
      -
        0
        4
      +
        2
        0
    +
      -
        4
        2
      +
        0
        4

result: -8


ast:
  +
    -
      2
      +
        -
          0
          4
        +
          +
            -
              2
              0
            +
              4
              2
          0
    -
      +
        -
          4
          2
        +
          0
          4
      +
        2
        +
          0
          -
            4
            -
              2
              0

result: 0

#pragma once
namespace guts{

template<class u_i,class... t_k>
struct
	is_member_impl;

template<class u_i,class t_j,class... t_k>
struct 
	is_member_impl<u_i,t_j,t_k...>:
	is_member_impl<u_i,t_k...	 >
{};

template<class t_i,class... t_k>
struct
	is_member_impl<t_i,t_i,t_k...>
{ static const bool value=true; };

template<class u_i>
struct
	is_member_impl<u_i>
{ static const bool value=false; };

template<class u_i,class... t_n>
using 
	is_member=
		is_member_impl<u_i,t_n...>;

}

#pragma once
namespace guts{

template<class t_i,int j,class... t_j>
struct
	index_of_impl;

template<class t_i,int j,class t_j,class... t_k>
struct 
	index_of_impl<t_i,j  ,t_j,t_k...>:
	index_of_impl<t_i,j+1,t_k...	>
{};

template<class t_i,int i,class... t_k>
struct
	index_of_impl<t_i,i,t_i,t_k...>
{ static const int value=i; };

template<class t_i,class... t_k>
using 
	index_of=
		index_of_impl<t_i,0,t_k...>;

}

#pragma once
namespace guts{
	
template<int k,class... t_j>
struct
	type_at_impl;

template<int k,class t_i,class... t_j>
struct
	type_at_impl<k  ,t_i,t_j...>:
	type_at_impl<k+1,t_j...	   >
{};

template<class t_i,class... t_k>
struct
	type_at_impl<0,t_i,t_k...>
{ typedef t_i type; };

template<int k,class... t_n>
using
	type_at=
		type_at_impl<k,t_n...>;

}

#pragma once
#include<utility>

template<class visitor_t,class visitable_t>
decltype(auto) apply_visitor(visitor_t&& visitor,visitable_t&& visitable){
	return visitable.accept(std::forward<visitor_t>(visitor));
}

#pragma once
#include<cassert>
#include<array>
#include<memory>
#include<type_traits>
#include<utility>
#include<index_of.hpp>
#include<is_member.hpp>
#include<type_at.hpp>
#include<type_traits>

template<class... t_n>
class variant_t{
public:

	template<class t_i> 
	using index_of=guts::index_of<t_i,t_n...>;

	template<class u_i>	
	using is_member=guts::is_member<u_i,t_n...>;
	
	template<int i> 
	using type_tag=guts::type_at<i,t_n...>;

	static const int rank=sizeof...(t_n);

	template<class t_i,class type=void>	
	using enabler=std::enable_if_t<is_member<t_i>::value,type>;

private:

	struct concept_t{ virtual ~concept_t(){} };

	template<class t_i>
	struct model_t:concept_t{
		t_i data;
		model_t(const t_i& _data):data(_data){}
		model_t(t_i&& _data):data(std::move(_data)){}
	};

	std::unique_ptr<concept_t> model_ptr;
	int index;
	
	template<class t_i>
	t_i& as()
	{ return static_cast<model_t<t_i>&>(*model_ptr).data; }

	template<class t_i>
	void copy_ctor_impl(const variant_t& object)
	{ model_ptr=std::make_unique<model_t<t_i>>(object.as<t_i>()); }

	template<class t_i>
	variant_t& copy_asgn_impl(const variant_t& object){
		as<t_i>()=object.as<t_i>();
		return *this;
	}

	template<class t_i>
	void move_ctor_impl(variant_t&& object)
	{ model_ptr=std::make_unique<model_t<t_i>>(std::move(object.as<t_i>())); }

	template<class t_i>
	variant_t& move_asgn_impl(variant_t&& object){
		as<t_i>()=std::move(as<t_i>());
		return *this;
	}

public:

	variant_t()=delete;

	variant_t(const variant_t& object):
		index(object.index){

		static const std::array<
			void(variant_t::*)(const variant_t&),
			rank
		> impls{ &variant_t::copy_ctor_impl<t_n>... };

		(this->*impls[index])(object);
	}

	variant_t& operator=(const variant_t& object){

		static const std::array<
			variant_t&(variant_t::*)(const variant_t&), 
			rank
		> impls{ &variant_t::copy_asgn_impl<t_n>... };

		return (this->*impls[index])(object);
	}

	variant_t(variant_t&& object):
		index(object.index){ 

		static const std::array<
			void(variant_t::*)(variant_t&&),
			rank
		> impls{ &variant_t::move_ctor_impl<t_n>... };

		(this->*impls[index])(std::move(object));
	}

	variant_t& operator=(variant_t&& object){

		static const std::array<
			variant_t&(variant_t::*)(variant_t&&),
			rank
		> impls{ &variant_t::move_asgn_impl<t_n>... };

		return (this->*impls[index])(std::move(object));
	}

	template<class u_i, class = enabler<u_i>>
	const u_i& as() const
	{ return static_cast<const model_t<u_i>&>(*model_ptr).data; }


	template<class u_i,class = enabler<u_i>> 
	variant_t(u_i&& _data):
		index(index_of<u_i>::value),
		model_ptr(new model_t<u_i>(std::forward<u_i>(_data)))
	{}

	~variant_t(){}

private:

	template<class t_i,class visitor_t>
	decltype(auto)
	accept_impl(visitor_t&& visitor)
	{ return visitor(as<t_i>()); }

	template<class t_i,class visitor_t>
	decltype(auto)
	accept_impl(visitor_t&& visitor) const
	{ return visitor(as<t_i>()); }

public:

	template<class visitor_t>
	decltype(auto)
	accept(visitor_t&& visitor){

		typedef typename 
			std::decay_t<visitor_t>::return_type 
				(variant_t::*accept_impl_t)(visitor_t&&);

		static const std::array<
			accept_impl_t,
			rank
		> impls{&variant_t::accept_impl<t_n,visitor_t>...};

		return (this->*impls[index])(std::forward<visitor_t>(visitor));
	}

	template<class visitor_t>
	decltype(auto)
	accept(visitor_t&& visitor) const{

		typedef typename 
			std::decay_t<visitor_t>::return_type 
				(variant_t::*accept_impl_t)(visitor_t&&) const;

		static const std::array<
			accept_impl_t,
			rank
		> impls{&variant_t::accept_impl<t_n,visitor_t>...};

		return (this->*impls[index])(std::forward<visitor_t>(visitor));
	}

};