The Big Programming Thread - Page 539

#include<iostream>
#include<memory>
#include<string>
#include<type_traits>
#include<cxxabi.h>
#include<tseq/tseq.hpp>
#include<abstract/abstract_t.hpp>
#include<abstract/deconstruct.hpp>
using std::cout;
using std::endl;

template<class t>
std::unique_ptr<char> demangle(){
	return std::unique_ptr<char>(abi::__cxa_demangle(typeid(t).name(),nullptr,nullptr,nullptr));
}

struct context_t{
	typedef void return_type;

	//recursive catch-all nnary behaviour
	template<class type0,class... typeN>
	return_type operator()(type0& value0,typeN&... valueN) const {
		(*this)(value0);
		(*this)(valueN...);
	}

	//partition the set of types into two.
	typedef tseq::tseq_t<std::string,char> subset;
	template<class type>
	using subset_disabler=std::enable_if_t<
		!tseq::find<std::decay_t<type>>(subset()),
		return_type
	>;

	template<class type>
	using subset_enabler=std::enable_if_t<
		tseq::find<std::decay_t<type>>(subset()),
		return_type
	>;

	//general behaviour, enabled for complement of subset
	template<class type>
	subset_disabler<type> operator()(type& value) const {
		cout
			<<"\tgeneral behaviour..."
			<<"\n\ttype:  "<<demangle<type>().get()
			<<"\n\tvalue: "<<value
			<<"\n\tconst: "<<std::is_const<type>::value
			<<"\n\n";
	}

	//subset specialized behaviour, enabled for subset
	template<class type>
	subset_enabler<type> operator()(type& value) const {
		cout
			<<"\tsubset behaviour, qualified std::string and char..."
			<<"\n\tsubset type:  "<<demangle<type>().get()
			<<"\n\tvalue: "<<value
			<<"\n\tconst: "<<std::is_const<type>::value
			<<"\n\n";
	}

	//'fully specialized' unary behaviour, takes preference over any function template
	return_type operator()(const char* value) const {
		cout
			<<"\tspecialized behaviour for const char*...."
			<<"\n\ttype: hello teamliquid type"
			<<"\n\tvalue: hello teamliquid"
			<<"\n\talso: "<<value<<"\n\n";
	}

	//fully specialized binary behaviour
	return_type operator()(const char*,char&) const {
		cout
			<<"\twatson: how did this function get instantiated?\n\tholmes: recursively, my dear watson.\n\n";
	}

};

const context_t context;

int main(){

	//define an abstraction for a set of types
	typedef abstract::abstract_t<int,char,float> abstract_t0;

	//make some values
	abstract_t0 
		a0(int(2)),
		a1(char('b'))
	;
	const abstract_t0
		a2(float(2));

	//deconstruct!
	cout<<"\nunary deconstruction:\n";
	deconstruct(context,a0);

	cout<<"\nbinary deconstruction:\n";
	deconstruct(context,a1,a2);

	//define another abstraction for a set of types
	typedef abstract::abstract_t<const char*,std::string> abstract_t1;

	//make some values
	abstract_t1
		a3(std::string("hello")),
		a4((const char*)("jello"))
	;

	//deconstruct!
	cout<<"\nbinary deconstruction:\n";
	deconstruct(context,a3,a4);

	cout<<"\npentary[sic] deconstruction:\n";
	deconstruct(context,a0,a3,a2,a4,a1);

}

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

unary deconstruction:
	general behaviour...
	type:  int
	value: 2
	const: 0


binary deconstruction:
	subset behaviour, qualified std::string and char...
	subset type:  char
	value: b
	const: 0

	general behaviour...
	type:  float
	value: 2
	const: 1


binary deconstruction:
	subset behaviour, qualified std::string and char...
	subset type:  std::string
	value: hello
	const: 0

	specialized behaviour for const char*....
	type: hello teamliquid type
	value: hello teamliquid
	also: jello


pentary[sic] deconstruction:
	general behaviour...
	type:  int
	value: 2
	const: 0

	subset behaviour, qualified std::string and char...
	subset type:  std::string
	value: hello
	const: 0

	general behaviour...
	type:  float
	value: 2
	const: 1

	watson: how did this function get instantiated?
	holmes: recursively, my dear watson.