Planet Chili

Code: Select all

#include <iostream>
#include <variant>

void do_int( int ) { std::cout << "do_int chosen\n"; }

using TestVar = std::variant<int, double, float>;

template<typename T>
class Switch
{
public:
	Switch( T& value )
		:
		var( value )
	{}

	template<typename MatchType, typename CaseBlock, typename...Args>
	Switch& Case( CaseBlock block, Args&&...args )
	{
		auto memberfn_call = [ & ]( auto& var_, auto& object, auto&&...args_ )
		{
			( object.*block )( var_ );
		};

		std::visit( [&]( auto& var_ )
		{
			using type = std::decay_t<decltype( var_ )>;
			if constexpr( std::is_same_v<type, MatchType> )
			{
				if constexpr( std::is_member_function_pointer_v<CaseBlock> )
				{
					memberfn_call( 
						std::forward<decltype( var_ )>( var_ ), 
						std::forward<Args>( args )... 
					);
				}
				else
				{
					block( std::forward<Args>(args)..., std::forward<type>( var_ ) );
				}
			}
		}, var );

		return *this;
	}
private:
	T& var;
};

struct ATest
{
	void operator()( double d ) { std::cout << "ATest::operator() chosen\n"; }
	void do_float( float f ) { std::cout << "ATest::do_float chosen\n"; }
};
int main()
{
	TestVar v = 42.0;

	ATest atest;
	Switch{ v }
		.Case<int>( do_int )
		.Case<double>( atest )
		.Case<float>( &ATest::do_float, atest );

	v = 420;
	Switch{ v }
		.Case<int>(do_int)
		.Case<double>( atest )
		.Case<float>( &ATest::do_float, atest );

	return 0;
}

Code: Select all

Output:
ATest::operator() chosen
do_int chosen

Code: Select all

switch<type>( v )
{
    case<int>:
    case<double>:
    case<float>:
}

Code: Select all

class Monster
{
}

class Cat : public Monster
{

}

Code: Select all

class Agent{}

class TFT : public Agent{}
class Coordinator : public Agent{}
class Deflector : public Agent{} 

Code: Select all

class Outer
{
public:
    class Inner
    {
    };
};

Outer::Inner inner_object;

Code: Select all

class A{};
class B : public A{}; <- B is a derived class of A

A* pA = new B{};

Code: Select all

class Agent
{
public:
    Agent()=default;
    Agent( TFT const& value_ )
        :
    index( 0 ),
    tft_agent( value_ )
    {}
    Agent( Cooperator value_ )
        :
    index( 1 ),
    coop_agent( value_ )
    {}
    Agent( Defector value_ )
        :
    index( 2 ),
    dafuq_agent( value_ )
    {}

private:
    union {
        TFT tft_agent;
        Cooperator coop_agent;
        Defector dafuq_agent;
    };
    int index = -1;
};