The Big Programming Thread - Page 486

int main(){
	std::string m0("team "),m1("liquid\n"); //messages to send, implicitly cast to cbuf_t
	std::vector<char> m2(m0.size()),m3(m1.size()),m4(m0.size()),m5(m1.size()); //buffers to receive on, implictly cast to buf_t
	try{
		sck_t<unix,dgram> s0,s1,s2; //std datagram unix socket
		adr_t<unix> a0("sck_file"); //file to com through

		bnd [s0](a0); //bind s0 to a0

		con	
			[s1](a0)
			[s2](a0)
		; //'connect' (just sets default receiver since it's dgram) s1 and s2 to a0

		snd	
			[s1](m0,m1)
			[s2](m0,m1)
		; //send m0 and m1 through s1, then m0 and m1 through s2

		rcv	
			[s0](m2,m3,m4,m5)
		; //receive all 4 messages on the respective buffers

		ulnk(a0); //unlink the file
	}catch(std::exception const& e){
		std::cout<<e.what()<<std::endl;
	}
	std::cout<<m2.data()<<m3.data()<<m4.data()<<m5.data();
	//prints 
		//team liquid
		//team liquid
}

class snd_pt{ //primer type
public:
	template<class sck_t>
	class snd_et{ //executable type
		friend class snd_pt; //primer class only one that can construct this
		snd_pt const& r; //ref to primer
		sck_t const& s;
		snd_et(snd_pt const& r_,sck_t const& s_):r(r_),s(s_){}
	public:
		...
		//executable calls
		template<class cbuf_t>
		snd_pt const& operator()(cbuf_t&& cbuf)const{ //only final call will return to outer scope
			snd(s,std::forward<cbuf_t>(cbuf)); //call snd on socket with buf
			return r; //return primer for chaining
		}
		template<class cbuf_t,class... cbuf_ts>
		snd_pt const& operator()(cbuf_t&& cbuf,cbuf_ts&&... cbufs)const{ //call then recurse
			(*this)(std::forward<cbuf_t>(cbuf));
			(*this)(std::forward<cbuf_ts>(cbufs)...);
		}
	};
	//primer call
	template<class sck_t>
	decltype(auto) 
	operator[](sck_t const& s)const{ 
		return snd_et<sck_t>(*this,s);
	}
};

const snd_pt snd; //make a const primer ready to use

connect({s1, a0}, {s2, a0});
send({s1, {m0, m1}}, {s2, {m0, m1}});

//unit race modifier, higher is better
enum race_t{zerg,terran,protoss};
//unit armor modifier, higher is better
enum armor_t{light,medium,heavy}; 

//unit type, all information in type
template<race_t race,armor_t armor> struct unit_t{}; 

//shape template
template<class> class damage_t; 

//damage class calculates the damage done by a fungal over intervals of time
template<race_t race,armor_t armor> 
class damage_t<unit_t<race,armor>>{
	//max damage per time unit
	const int max_damage=5; 
public:
	//all info in type, don't need no variable
	damage_t(unit_t<race,armor>const&){} 
	//calculate damage for over given interval
	int operator()(int interval_j){ 
		return (max_damage-race-armor)*interval_j;
	}
	template<class... int_ts>
	int operator()(int interval_0,int_ts... intervals){
		//sum all the damages over intervals
		int total_damage=(*this)(interval_0)+(*this)(intervals...); 
		return total_damage;
	}
};

//infestor_t catches a unit_t through its array subscript operator and entangles him in a fungal_t. 
//it roots unit to callsite, while wrapping him damage_t allowing to deal damage over time intervals through
//damage_t function call operator.
//have to decay unit_t so we don't instantiate unspecified damage_t<unit_t&> or whatevs instead of damage_t<unit_t>.

template<template<class> class damage_t>
class infestor_t{ 					
public:							
	template<class unit_t>			 
	class fungaled_t:public damage_t<std::decay_t<unit_t>>{ 							
		//only the infestor_t can create a fungaled_t
		friend class infestor_t;

		//the fungal being casted on unit when array subscript operator is called
		explicit fungaled_t(unit_t&& unit):damage_t<std::decay_t<unit_t>>(std::forward<unit_t>(unit)){} 

		 //land fungal and lock unit_t in place at the callsite when we return through return value optimization/cpy elision
		fungaled_t(fungaled_t&& fungaled):damage_t<std::decay_t<unit_t>>(std::move(fungaled)){}

	public:
		//fungaled_t literally can not be moved or copied besides when being returned and fungaled at callsite.
		fungaled_t(fungaled_t const&)=delete; 
		fungaled_t& operator=(fungaled_t const&)=delete;	
		fungaled_t& operator=(fungaled_t&&)=delete;
	};

	//unit walks into our array subscript operator
	template<class unit_t>
	decltype(auto) 
	operator[](unit_t&& unit)const{
		//cast fungal, it "lands" at call site after we return.
		return fungaled_t<unit_t>(std::forward<unit_t>(unit)); 
	}

};

int main(){
	try{
		infestor_t<damage_t> infestor;

		typedef unit_t<zerg,light> light_zerg_t;
		light_zerg_t zergling; //weakest unit in the game
		std::cout<<infestor[zergling](1,1,1)<<std::endl; //does (5)*(1+1+1)=15 damage. 

		typedef unit_t<protoss,heavy> heavy_protoss_t;
		heavy_protoss_t sentry; //strongest unit in the game
		std::cout<<infestor[sentry](1,1,1)<<std::endl; //does (5-2-2)*(1+1+1)=3 damage;

		auto cheat_sentry=infestor[sentry]; //compiler error, not allowed to move or copy from callsite!

	}catch(std::exception const& e){
		std::cout<<e.what()<<std::endl;
	}
}