#pragma once

#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<typename char="" q::result_type,="">::type</typename>

  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<typename char="" q::argument_type,="">::type</typename>

  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<typename char="" q::first_argument_type,="">::type</typename>

  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<typename char="" q::second_argument_type,="">::type</typename>

  second_arg_fun(Q *);

  static double second_arg_fun(...);

public:

  enum {

    has_result =

        (sizeof(result_fun(typename tcg::traits<func>::pointer_type())) ==</func>

         sizeof(char)),

    has_argument =

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

         sizeof(char)),

    has_first_arg =

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

         sizeof(char)),

    has_second_arg =

        (sizeof(second_arg_fun(typename tcg::traits<func>::pointer_type())) ==</func>

         sizeof(char))

  };

  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>

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

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)=""></ret>

    : public function_traits<ret(arg1, arg2)=""> {};</ret(arg1,>

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

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

    : public function_traits<ret(arg1, arg2)=""> {};</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<typename char="" q::result_type,="">::type result(</typename>

      Q *);

  static double result(...);

  enum {

    value = (sizeof(result(typename tcg::traits<t>::pointer_type())) ==</t>

             sizeof(char))

  };

};

}  // namespace tcg

#endif  // TCG_TRAITS_H