#ifndef FOUR_H
#define FOUR_H

namespace four
{

	enum FUN  {FUN_F = 1, FUN_G = 4};
	struct Tst_2
	{
		const static int enabled_fun = FUN_F | FUN_G;
		void f()
		{
			std::cout << "f" <<  std::endl;
		}
		void g()
		{
			std::cout << "g"  << std::endl;
		}
	};
	
	struct Tst_1
	{
		const static int enabled_fun = FUN_F;
		void f()
		{
			std::cout << "f" <<  std::endl;
		}
	};

	template <int I, class T>
	struct enable_if_1
	{typedef T type;};
	
	template < class T>
	struct enable_if_1<0, T >
	{};

	template <int I, class T>
	struct Int2Type
	{typedef T type;};
	template <class T>
	struct Int2Type<0, T>
	{typedef void type;};

	template <int I>
	struct Interface
	{
	typedef void FUN_R;
	template<class T>
	Interface(T* x) : x_(x), f_(0), g_(0)
	{ 
		set_g( (typename Int2Type<T::enabled_fun&FUN_G, T>::type*)0);
		set_f( (typename Int2Type<T::enabled_fun&FUN_F, T>::type*)0);
	}
	
	template <class T>
	void set_f (T* p = 0)
	{
	 f_ = (vTable_<T>::template f<void>);
	}
	
	void set_f (void* v =0)
	{}
	
	template <class T>
	void set_g (T* p = 0)
	{
	 g_ = (vTable_<T>::template g<void>);
	}
	
	void set_g (void* v =0)
	{}
	template <class T>
	typename enable_if_1<I & FUN_F, T>::type
	 f()
	{
		f_ ? f_(x_) : throw;
	}
	template <class T>
	typename enable_if_1<I & FUN_G, T>::type
	 g()
	{
		g_ ? g_(x_) : throw ;
	}
	private:
	template <class TT>
	struct vTable_
	{
		template<class T>  static typename enable_if_1<TT::enabled_fun & FUN_F, T>::type f(void* x)
		{
			static_cast<TT*>(x)->f();
		}
		 template<class T> static typename enable_if_1<TT::enabled_fun & FUN_G, T>::type g(void* x)
		{
			static_cast<TT*>(x)->g();
		}
	};

	private:
	typedef  void (*FUN)(void*);
	FUN f_, g_;
	void* x_;
	};

	void test()
	{

		{
			Tst_2 t2;
			typedef Interface<FUN_F | FUN_G> Interface;
			Interface i(&t2);
			i.f<Interface::FUN_R>();
			i.g<Interface::FUN_R>();
		}
		{
			Tst_1 t1;
			typedef Interface<FUN_F | FUN_G> Interface;
			Interface i(&t1);
			i.f<Interface::FUN_R>();
			i.g<void>();
		}
	}

}

#endif