#ifndef TCG_TRAITS_H

#define TCG_TRAITS_H

// tcg includes

#include "sfinae.h"

// STD includes

#include <iterator></iterator>

//--------------------------------------------------------------------------

namespace tcg

{

//****************************************************************************

//    TCG traits for generic type concepts

//****************************************************************************

template <typename t=""></typename>

struct traits {

	typedef T *pointer_type;

	typedef T pointed_type;

	typedef T &reference_type;

	typedef T referenced_type;

	typedef T element_type;

};

template <typename t=""></typename>

struct traits<t *=""> {</t>

	typedef T **pointer_type;

	typedef T pointed_type;

	typedef T *&reference_type;

	typedef T *referenced_type;

	typedef T *element_type;

};

template <typename t=""></typename>

struct traits<t[]> : public traits<t *=""> {</t></t[]>

	typedef T element_type;

};

template <typename t=""></typename>

struct traits<t &=""> : public traits<t> {</t></t>

};

template <>

struct traits<void> {</void>

	typedef void *pointer_type;

	typedef void pointed_type;

	typedef void reference_type;

	typedef void referenced_type;

};

//****************************************************************************

//    Qualifier removers

//****************************************************************************

template <typename t=""></typename>

struct remove_const {

	typedef T type;

};

template <typename t=""></typename>

struct remove_const<const t=""> {</const>

	typedef T type;

};

template <typename t=""></typename>

struct remove_ref {

	typedef T type;

};

template <typename t=""></typename>

struct remove_ref<t &=""> {</t>

	typedef T type;

};

template <typename t=""></typename>

struct remove_cref {

	typedef typename remove_const<typename remove_ref<t="">::type>::type type;</typename>

};

//****************************************************************************

//    TCG traits for function types

//****************************************************************************

template <typename func=""></typename>

class function_traits

{

	template <typename bool="" f,=""></typename>

	struct result;

	template <typename f=""></typename>

	struct result<f, true=""> {</f,>

		typedef typename F::result_type type;

	};

	template <typename f=""></typename>

	struct result<f, false=""> {</f,>

		typedef struct {

		} type;

	};

	template <typename q=""></typename>

	static typename enable_if_exists

									 char>::type

	result_fun(Q *);

	static double result_fun(...);

	template <typename bool="" f,=""></typename>

	struct argument;

	template <typename f=""></typename>

	struct argument<f, true=""> {</f,>

		typedef typename F::argument_type type;

	};

	template <typename f=""></typename>

	struct argument<f, false=""> {</f,>

		typedef void type;

	};

	template <typename q=""></typename>

	static typename enable_if_exists

									 char>::type

	argument_fun(Q *);

	static double argument_fun(...);

	template <typename bool="" f,=""></typename>

	struct first_arg;

	template <typename f=""></typename>

	struct first_arg<f, true=""> {</f,>

		typedef typename F::first_argument_type type;

	};

	template <typename f=""></typename>

	struct first_arg<f, false=""> {</f,>

		typedef void type;

	};

	template <typename q=""></typename>

	static typename enable_if_exists

									 char>::type

	first_arg_fun(Q *);

	static double first_arg_fun(...);

	template <typename bool="" f,=""></typename>

	struct second_arg;

	template <typename f=""></typename>

	struct second_arg<f, true=""> {</f,>

		typedef typename F::second_argument_type type;

	};

	template <typename f=""></typename>

	struct second_arg<f, false=""> {</f,>

		typedef void type;

	};

	template <typename q=""></typename>

	static typename enable_if_exists

									 char>::type

	second_arg_fun(Q *);

	static double second_arg_fun(...);

public:

	enum { has_result = (sizeof(result_fun(typename tcg::traits<func>::pointer_type())) == sizeof(char)),</func>

		   has_argument = (sizeof(argument_fun(typename tcg::traits<func>::pointer_type())) == sizeof(char)),</func>

		   has_first_arg = (sizeof(first_arg_fun(typename tcg::traits<func>::pointer_type())) == sizeof(char)),</func>

		   has_second_arg = (sizeof(second_arg_fun(typename tcg::traits<func>::pointer_type())) == sizeof(char)) };</func>

	typedef typename result<func, has_result="">::type ret_type;</func,>

	typedef typename argument<func, has_argument="">::type arg_type;</func,>

	typedef typename first_arg<func, has_first_arg="">::type arg1_type;</func,>

	typedef typename second_arg<func, has_second_arg="">::type arg2_type;</func,>

};

//-----------------------------------------------------------------------

template <typename ret=""></typename>

struct function_traits<ret()> {</ret()>

	enum { has_result = true,

		   has_argument = false,

		   has_first_arg = false,

		   has_second_arg = false };

	typedef Ret ret_type;

	typedef void arg_type;

	typedef void arg1_type;

	typedef void arg2_type;

};

template <typename ret=""></typename>

struct function_traits<ret (*)()=""> : public function_traits<ret()> {</ret()></ret>

};

template <typename ret=""></typename>

struct function_traits<ret(&)()> : public function_traits<ret()> {</ret()></ret(&)()>

};

//-----------------------------------------------------------------------

template <typename arg="" ret,="" typename=""></typename>

struct function_traits<ret(arg)> {</ret(arg)>

	enum { has_result = true,

		   has_argument = true,

		   has_first_arg = false,

		   has_second_arg = false };

	typedef Ret ret_type;

	typedef Arg arg_type;

	typedef void arg1_type;

	typedef void arg2_type;

};

template <typename arg="" ret,="" typename=""></typename>

struct function_traits<ret (*)(arg)=""> : public function_traits<ret(arg)> {</ret(arg)></ret>

};

template <typename arg="" ret,="" typename=""></typename>

struct function_traits<ret(&)(arg)> : public function_traits<ret(arg)> {</ret(arg)></ret(&)(arg)>

};

//-----------------------------------------------------------------------

template <typename arg1,="" arg2="" ret,="" typename=""></typename>

struct function_traits<ret(arg1, arg2)=""> {</ret(arg1,>

	enum { has_result = true,

		   has_first_arg = true,

		   has_second_arg = true };

	typedef Ret ret_type;

	typedef Arg1 arg1_type;

	typedef Arg2 arg2_type;

};

template <typename arg1,="" arg2="" ret,="" typename=""></typename>

struct function_traits<ret (*)(arg1,="" arg2)=""> : public function_traits<ret(arg1, arg2)=""> {</ret(arg1,></ret>

};

template <typename arg1,="" arg2="" ret,="" typename=""></typename>

struct function_traits<ret(&)(arg1, arg2)=""> : public function_traits<ret(arg1, arg2)=""> {</ret(arg1,></ret(&)(arg1,>

};

//******************************************************************************

//    TCG traits for output container readers

//******************************************************************************

template <typename outputdata="typename" reader,="" reader::value_type="" typename=""></typename>

struct container_reader_traits {

	typedef Reader reader_type;

	typedef OutputData value_type;

	static void openContainer(reader_type &reader) { reader.openContainer(); }

	static void addElement(reader_type &reader, const value_type &data) { reader.addElement(data); }

	static void closeContainer(reader_type &reader) { reader.closeContainer(); }

};

//************************************************************************************

//    Notable Test  traits

//************************************************************************************

template <typename t=""></typename>

struct is_floating_point {

	enum { value = false };

};

template <>

struct is_floating_point<float> {</float>

	enum { value = true };

};

template <>

struct is_floating_point<double> {</double>

	enum { value = true };

};

template <>

struct is_floating_point<long double=""> {</long>

	enum { value = true };

};

//-----------------------------------------------------------------------

template <typename t=""></typename>

struct is_function {

	enum { value = function_traits<t>::has_result };</t>

};

template <typename t=""></typename>

struct is_functor {

	template <typename q=""></typename>

	static typename enable_if_exists

									 char>::type

	result(Q *);

	static double result(...);

	enum { value = (sizeof(result(typename tcg::traits<t>::pointer_type())) == sizeof(char)) };</t>

};

} // namespace tcg

#endif // TCG_TRAITS_H