#pragma once

template <bool flag, typename T, typename U>
struct Select
{
private:
	template<bool>
	struct In 
	{ typedef T ResultType; };

	template<>
	struct In<false>
	{ typedef U ResultType; };

public:
	typedef typename In<flag>::ResultType Type;
};




template <typename T>
struct TypeCheck
{
private:
	typedef char (&yes)[1];
	typedef char (&no) [2];

private:
	struct Reference
	{
	private:
		template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other	Raw; };
		template<typename Arg>					struct In<Arg &>					{ enum { value = true  };	typedef typename Arg	Raw; };
	public:
		enum { Result = In<T>::value };
		typedef typename In<T>::Raw				Raw;
	};

	struct Array
	{
	private:
		template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other	Raw; };
		template<typename Arg, size_t s>		struct In<Arg[s]>					{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg[]>					{ enum { value = true  };	typedef typename Arg	Raw; };
	public:
		enum { Result = In<T>::value };
		typedef typename In<T>::Raw				Raw;
	};

	struct Pointer
	{
	private:
		template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other	Raw; };
		template<typename Arg>					struct In<Arg *>					{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg *&>					{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg, typename Obj>	struct In<Arg Obj::*>				{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg, typename Obj>	struct In<Arg Obj::*&>				{ enum { value = true  };	typedef typename Arg	Raw; };
	public:
		enum { Result = In<T>::value };
		typedef typename In<T>::Raw				Raw;
	};

	struct Const
	{
	private:
		template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other	Raw; };
		template<typename Arg>					struct In<Arg const>				{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg const &>				{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg const []>				{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg, size_t s>		struct In<Arg const [s]>			{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg const volatile &>		{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg const volatile []>	{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg, size_t s>		struct In<Arg const volatile [s]>	{ enum { value = true  };	typedef typename Arg	Raw; };
	public:
		enum { Result = In<T>::value };
		typedef typename In<T>::Raw				Raw;
	};


	struct Volatile
	{
	private:
		template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other	Raw; };
		template<typename Arg>					struct In<Arg volatile>				{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg volatile &>			{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg volatile []>			{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg, size_t s>		struct In<Arg volatile [s]>			{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg const volatile &>		{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg>					struct In<Arg const volatile []>	{ enum { value = true  };	typedef typename Arg	Raw; };
		template<typename Arg, size_t s>		struct In<Arg const volatile [s]>	{ enum { value = true  };	typedef typename Arg	Raw; };
	public:
		enum { Result = In<T>::value };
		typedef typename In<T>::Raw				Raw;
	};


	struct Member
	{
	private:
		template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other	Raw; };
		template<typename Arg, typename Obj>	struct In<Arg Obj::*>				{ enum { value = true  };	typedef typename Arg	Raw; };
	public:
		enum { Result = In<T>::value };
		typedef typename In<T>::Raw				Raw;
	};


	struct Class
	{
	private:
		template< typename Obj >	static yes	IsClass( int Obj::* );
		template< typename >		static no	IsClass( ... );
	public:
		enum { Result = sizeof(IsClass<T>(0)) == sizeof(yes) };
	};


	struct Void
	{
	private:
		// 参照以外
		template< bool flag >
		struct Imp
		{
		private:
			template<typename Other>			struct In 							{ enum { value = false }; };
			template<>							struct In<void *>					{ enum { value = true  }; };
			template<>							struct In<void const *>				{ enum { value = true  }; };
			template<>							struct In<void volatile *>			{ enum { value = true  }; };
			template<>							struct In<void const volatile *>	{ enum { value = true  }; };
		public:
			enum { value = In<T *>::value };
		};

		// 参照などの場合はこっちへ
		template<>
		struct Imp<true>
		{	enum { value = false };	};

	public:
		enum { Result = Imp<Reference::Result>::value };
	};


public:
	enum
	{
		IsReference	= Reference	::Result,
		IsArray		= Array		::Result,
		IsVolatile	= Volatile	::Result,
		IsConst		= Const		::Result,
		IsPointer	= Pointer	::Result,
		IsMember	= Member	::Result,
		IsClass		= Class		::Result,
		IsVoid		= Void		::Result,
		IsRaw		= !(IsReference | IsArray | IsVolatile | IsConst | IsPointer | IsMember),
	};

	typedef typename Select< IsVoid,      void,
			typename Select< IsVolatile,  typename Volatile ::Raw,
			typename Select< IsConst,     typename Const    ::Raw,
			typename Select< IsPointer,   typename Pointer  ::Raw,
			typename Select< IsArray,     typename Array    ::Raw,
			typename Select< IsReference, typename Reference::Raw,
				T
			>::Type
			>::Type
			>::Type
			>::Type
			>::Type
			>::Type
			Raw;
};



// 型の修飾子を全て取る（配列も取る）
template< typename T >
struct TypePeel
{
private:
	typedef typename T																							Peel00;
	typedef typename Select< TypeCheck<Peel00>::IsRaw, Peel00, typename TypeCheck<Peel00>::Raw>::Type			Peel01;
	typedef typename Select< TypeCheck<Peel01>::IsRaw, Peel01, typename TypeCheck<Peel01>::Raw>::Type			Peel02;
	typedef typename Select< TypeCheck<Peel02>::IsRaw, Peel02, typename TypeCheck<Peel02>::Raw>::Type			Peel03;
	typedef typename Select< TypeCheck<Peel03>::IsRaw, Peel03, typename TypeCheck<Peel03>::Raw>::Type			Peel04;
	typedef typename Select< TypeCheck<Peel04>::IsRaw, Peel04, typename TypeCheck<Peel04>::Raw>::Type			Peel05;
	typedef typename Select< TypeCheck<Peel05>::IsRaw, Peel05, typename TypeCheck<Peel05>::Raw>::Type			Peel06;
	typedef typename Select< TypeCheck<Peel06>::IsRaw, Peel06, typename TypeCheck<Peel06>::Raw>::Type			Peel07;
	typedef typename Select< TypeCheck<Peel07>::IsRaw, Peel07, typename TypeCheck<Peel07>::Raw>::Type			Peel08;
	typedef typename Select< TypeCheck<Peel08>::IsRaw, Peel08, typename TypeCheck<Peel08>::Raw>::Type			Peel09;
	typedef typename Select< TypeCheck<Peel09>::IsRaw, Peel09, typename TypeCheck<Peel09>::Raw>::Type			Peel10;

public:
	typedef typename Peel10																						RawType;
};



// 引数最適化のためのクラス。
template< typename T >
struct AdjustArgument
{
private:
	template <bool flag>
	struct Change
	{
	private:
		template<bool>	struct In 		{ typedef T const & Result;	};
		template<>		struct In<true>	{ typedef T Result;			};
	public:
		typedef typename In<flag>::Result	Result;
	};


	typedef typename Change<TypeCheck<T>::IsReference || TypeCheck<T>::IsVoid>::Result		ChangeType;

public:
	typedef typename Select<TypeCheck<T>::IsArray, T, ChangeType>::Type						Type;
};



// メンバ変数用に const とか参照を解除するためのクラス。
template< typename T >
struct AdjustMember
{
private:
	template<typename Other>				struct In 							{ enum { value = false };	typedef typename Other				Raw;    };
	template<typename Arg>					struct In<Arg const>				{ enum { value = true  };	typedef typename Arg				Raw;    };
	template<typename Arg>					struct In<Arg const &>				{ enum { value = true  };	typedef typename Arg				Raw;    };
	template<typename Arg>					struct In<Arg const []>				{ enum { value = true  };	typedef typename Arg				Raw[];  };
	template<typename Arg, size_t s>		struct In<Arg const [s]>			{ enum { value = true  };	typedef typename Arg				Raw[s]; };
	template<typename Arg>					struct In<Arg const volatile &>		{ enum { value = true  };	typedef typename Arg volatile		Raw;    };
	template<typename Arg>					struct In<Arg const volatile []>	{ enum { value = true  };	typedef typename Arg volatile		Raw[];  };
	template<typename Arg, size_t s>		struct In<Arg const volatile [s]>	{ enum { value = true  };	typedef typename Arg volatile		Raw[s]; };

public:
	typedef typename In<T>::Raw				Type;

	enum
	{
		IsChange = In<T>::value
	};
};



class Binder
{
private:
	struct Bind
	{
	friend class Binder;
	private:
		Bind()	{}
	};

	struct Unbind
	{
	friend class Binder;
	private:
		Unbind()	{}
	};

public:
	template< typename E1 >
	struct Checker
	{
		template< typename E2 > inline const E1 &
		operator()( const E1 &e1, const E2 & )
		{	return e1;		};
	};

	template<>
	struct Checker<Bind>
	{
		template< typename E2 > inline const E2 &
		operator()( const Bind &, const E2 &e2 )
		{	return e2;		};
	};


	template< typename Type >
	struct IsBind
	{
	private:
		template< typename Type >	struct In			{	enum { value = false };		};
		template<>					struct In<Bind>		{	enum { value = true  };		};

	public:
		// unbinder か調べる。const & とかされている場合もあるので、型の修飾子は TypePeel で完全に取り払う。
		enum { value = In<typename TypePeel<Type>::RawType>::value };
	};


	template< typename Type >
	struct IsUnbind
	{
	private:
		template< typename Type >	struct In			{	enum { value = false };		};
		template<>					struct In<Unbind>	{	enum { value = true  };		};

	public:
		// unbinder か調べる。const & とかされている場合もあるので、型の修飾子は TypePeel で完全に取り払う。
		enum { value = In<typename TypePeel<Type>::RawType>::value };
	};

public:
	static Bind		bind;				// bind   用クラス
	static Unbind	unbind;				// unbind 用クラス
};


__declspec( selectany ) Binder::Bind	Binder::bind;
__declspec( selectany ) Binder::Unbind	Binder::unbind;