#pragma once

#ifndef TCG_TRAITS_H

#define TCG_TRAITS_H

// tcg includes

#include "sfinae.h"

// STD includes

#include <iterator>

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

namespace tcg {

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

//    TCG traits for generic type concepts

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

template <typename T>

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>

struct traits<T *> {

  typedef T **pointer_type;

  typedef T pointed_type;

  typedef T *&reference_type;

  typedef T *referenced_type;

  typedef T *element_type;

};

template <typename T>

struct traits<T[]> : public traits<T *> {

  typedef T element_type;

};

template <typename T>

struct traits<T &> : public traits<T> {};

template <>

struct traits<void> {

  typedef void *pointer_type;

  typedef void pointed_type;

  typedef void reference_type;

  typedef void referenced_type;

};

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

//    Qualifier removers

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

template <typename T>

struct remove_const {

  typedef T type;

};

template <typename T>

struct remove_const<const T> {

  typedef T type;

};

template <typename T>

struct remove_ref {

  typedef T type;

};

template <typename T>

struct remove_ref<T &> {

  typedef T type;

};

template <typename T>

struct remove_cref {

  typedef typename remove_const<typename remove_ref<T>::type>::type type;

};

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

//    TCG traits for function types

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

template <typename Func>

class function_traits {

  template <typename F, bool>

  struct result;

  template <typename F>

  struct result<F, true> {

    typedef typename F::result_type type;

  };

  template <typename F>

  struct result<F, false> {

    typedef struct { } type; };

  template <typename Q>

  static typename enable_if_exists<typename Q::result_type, char>::type

  result_fun(Q *);

  static double result_fun(...);

  template <typename F, bool>

  struct argument;

  template <typename F>

  struct argument<F, true> {

    typedef typename F::argument_type type;

  };

  template <typename F>

  struct argument<F, false> {

    typedef void type;

  };

  template <typename Q>

  static typename enable_if_exists<typename Q::argument_type, char>::type

  argument_fun(Q *);

  static double argument_fun(...);

  template <typename F, bool>

  struct first_arg;

  template <typename F>

  struct first_arg<F, true> {

    typedef typename F::first_argument_type type;

  };

  template <typename F>

  struct first_arg<F, false> {

    typedef void type;

  };

  template <typename Q>

  static typename enable_if_exists<typename Q::first_argument_type, char>::type

  first_arg_fun(Q *);

  static double first_arg_fun(...);

  template <typename F, bool>

  struct second_arg;

  template <typename F>

  struct second_arg<F, true> {

    typedef typename F::second_argument_type type;

  };

  template <typename F>

  struct second_arg<F, false> {

    typedef void type;

  };

  template <typename Q>

  static typename enable_if_exists<typename Q::second_argument_type, 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)),

    has_argument =

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

         sizeof(char)),

    has_first_arg =

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

         sizeof(char)),

    has_second_arg =

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

         sizeof(char))

  };

  typedef typename result<Func, has_result>::type ret_type;

  typedef typename argument<Func, has_argument>::type arg_type;

  typedef typename first_arg<Func, has_first_arg>::type arg1_type;

  typedef typename second_arg<Func, has_second_arg>::type arg2_type;

};

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

template <typename Ret>

struct function_traits<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>

struct function_traits<Ret (*)()> : public function_traits<Ret()> {};

template <typename Ret>

struct function_traits<Ret (&)()> : public function_traits<Ret()> {};

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

template <typename Ret, typename Arg>

struct function_traits<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 Ret, typename Arg>

struct function_traits<Ret (*)(Arg)> : public function_traits<Ret(Arg)> {};

template <typename Ret, typename Arg>

struct function_traits<Ret (&)(Arg)> : public function_traits<Ret(Arg)> {};

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

template <typename Ret, typename Arg1, typename Arg2>

struct function_traits<Ret(Arg1, Arg2)> {

  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 Ret, typename Arg1, typename Arg2>

struct function_traits<Ret (*)(Arg1, Arg2)>

    : public function_traits<Ret(Arg1, Arg2)> {};

template <typename Ret, typename Arg1, typename Arg2>

struct function_traits<Ret (&)(Arg1, Arg2)>

    : public function_traits<Ret(Arg1, Arg2)> {};

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

//    TCG traits for output container readers

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

template <typename Reader, typename OutputData = typename Reader::value_type>

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>

struct is_floating_point {

  enum { value = false };

};

template <>

struct is_floating_point<float> {

  enum { value = true };

};

template <>

struct is_floating_point<double> {

  enum { value = true };

};

template <>

struct is_floating_point<long double> {

  enum { value = true };

};

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

template <typename T>

struct is_function {

  enum { value = function_traits<T>::has_result };

};

template <typename T>

struct is_functor {

  template <typename Q>

  static typename enable_if_exists<typename Q::result_type, char>::type result(

      Q *);

  static double result(...);

  enum {

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

             sizeof(char))

  };

};

}  // namespace tcg

#endif  // TCG_TRAITS_H