#ifndef __JLANG__JCOMPARISONAVAILABLE__
#define __JLANG__JCOMPARISONAVAILABLE__

#include <type_traits>

#include "JLang/JNullType.hh"


/**
 * \author mdejong
 */

namespace JLANG {}
namespace JPP { using namespace JLANG; }

namespace JLANG {

  /**
   * Local namespace for fallback implementations for comparison operators.
   */  
  namespace JLOCAL {

    template<class T>
    class JTypedef {

      template<class U>   static auto first_type(U*)   -> decltype(std::declval<typename U::first_type>());
      template<typename>  static auto first_type(...)  -> std::false_type;

      template<class U>   static auto second_type(U*)  -> decltype(std::declval<typename U::second_type>());
      template<typename>  static auto second_type(...) -> std::false_type;

      template<class U>   static auto value_type(U*)   -> decltype(std::declval<typename U::value_type>());
      template<typename>  static auto value_type(...)  -> std::false_type;
    
    public:
      static const bool has_first_type  = !std::is_same<std::false_type, decltype(first_type<T> (0))>::value;
      static const bool has_second_type = !std::is_same<std::false_type, decltype(second_type<T>(0))>::value;
      static const bool has_value_type  = !std::is_same<std::false_type, decltype(value_type<T> (0))>::value;
    };


    /**
     * Template definition of test availability of comparison operators.
     */
    template<class T,
	     bool has_first_and_second_type = JTypedef<T>::has_first_type && JTypedef<T>::has_second_type,
	     bool has_value_type            = JTypedef<T>::has_value_type>
    class JComparisonAvailable;

    /**
     * Template specialisation of test availability of comparison operators of non-composite data types.
     */
    template<class T>
    class JComparisonAvailable<T, false, false>
    {
      template<class U>   static auto eq(U*)  -> decltype(std::declval<U>() == std::declval<U>());
      template<class U>   static auto ne(U*)  -> decltype(std::declval<U>() != std::declval<U>());
      template<class U>   static auto lt(U*)  -> decltype(std::declval<U>() <  std::declval<U>());
      template<class U>   static auto gt(U*)  -> decltype(std::declval<U>() >  std::declval<U>());
      template<class U>   static auto le(U*)  -> decltype(std::declval<U>() <= std::declval<U>());
      template<class U>   static auto ge(U*)  -> decltype(std::declval<U>() >= std::declval<U>());

      template<typename>  static auto eq(...) -> std::false_type;
      template<typename>  static auto ne(...) -> std::false_type;
      template<typename>  static auto lt(...) -> std::false_type;
      template<typename>  static auto gt(...) -> std::false_type;
      template<typename>  static auto le(...) -> std::false_type;
      template<typename>  static auto ge(...) -> std::false_type;

    public:
      static const bool has_eq = std::is_same<bool, decltype(eq<T>(0))>::value;  //!< true if operator== available; else false
      static const bool has_ne = std::is_same<bool, decltype(ne<T>(0))>::value;  //!< true if operator!= available; else false
      static const bool has_lt = std::is_same<bool, decltype(lt<T>(0))>::value;  //!< true if operator<  available; else false
      static const bool has_gt = std::is_same<bool, decltype(gt<T>(0))>::value;  //!< true if operator>  available; else false
      static const bool has_le = std::is_same<bool, decltype(le<T>(0))>::value;  //!< true if operator<= available; else false
      static const bool has_ge = std::is_same<bool, decltype(ge<T>(0))>::value;  //!< true if operator>= available; else false
    };

    
    /**
     * Template specialisation of test availability of comparison operators of composite data types which have a type definitions for first_type and second_type.\n
     * This applies to STL containers such as std::pair.\n
     * Note that STL provides for the comparison of the container based on comparisons of its elements.
     */
    template<class T>
    class JComparisonAvailable<T, true, false>
    {
      typedef typename T::first_type     first_type;
      typedef typename T::second_type    second_type;

    public:
      static const bool has_eq = JComparisonAvailable<first_type>::has_eq && JComparisonAvailable<second_type>::has_eq;
      static const bool has_ne = JComparisonAvailable<first_type>::has_ne && JComparisonAvailable<second_type>::has_ne;
      static const bool has_lt = JComparisonAvailable<first_type>::has_lt && JComparisonAvailable<second_type>::has_lt;
      static const bool has_gt = JComparisonAvailable<first_type>::has_gt && JComparisonAvailable<second_type>::has_gt;
      static const bool has_le = JComparisonAvailable<first_type>::has_le && JComparisonAvailable<second_type>::has_le;
      static const bool has_ge = JComparisonAvailable<first_type>::has_ge && JComparisonAvailable<second_type>::has_ge;
    };


    /**
     * Template specialisation of test availability of comparison operators of composite data types which have a type definition for for value_type.\n
     * This applies to STL containers such as std::vector and std::set.\n
     * Note that STL provides for the comparison of the container based on comparisons of its elements.\n
     */
    template<class T>
    class JComparisonAvailable<T, false, true> :
      public JComparisonAvailable<typename T::value_type>
    {};


    /**
     * Template base class for data structures without equality capability.
     * This class implements the operators <tt> == != </tt>.
     */
    template<class T>
    class JNoequals {
    private:
      /**
       * Equal operator.
       *
       * \param  first        first object
       * \param  second       second object
       * \return              true if two objects are equal; else false
       */
      friend inline JNullType operator==(const T& first, const T& second)
      { 
	return JNullType();
      }


      /**
       * Not equal operator.
       *
       * \param  first        first object
       * \param  second       second object
       * \return              true if two objects are not equal; else false
       */
      friend inline JNullType operator!=(const T& first, const T& second)
      {
	return JNullType();
      }
    };
  }

  using JLOCAL::JComparisonAvailable;
  using JLOCAL::JNoequals;
}

#endif