template <class T, T v>
struct integral_constant
{
    typedef T                                    value_type;
    static const value_type                      value = v;
    typedef integral_constant<value_type, value> type;
};

template <class T, T v>
const typename integral_constant<T, v>::value_type
integral_constant<T, v>::
value;

typedef integral_constant<bool, true>  true_type;
typedef integral_constant<bool, false> false_type;

template <class T> struct remove_const { typedef T type; };
template <class T> struct remove_const<const T> { typedef T type; };
template <class T> struct remove_volatile { typedef T type; };
template <class T> struct remove_volatile<volatile T> { typedef T type; };
template <class T> struct remove_cv:
  remove_const<typename remove_volatile<T>::type> { };

template <class, class> struct is_same: false_type { };
template <class T> struct is_same<T, T>: true_type { };

// is T a standard signed/unsigned integer type?
template <class> struct __is_std_signed: false_type { };
template <class> struct __is_std_unsigned: false_type { };

// __is_std_signed specializations for each standard signed
// integer type (T must not be cv-qualified)
template <> struct __is_std_signed<signed char>: true_type { };
template <> struct __is_std_signed<int>: true_type { };
template <> struct __is_std_signed<short>: true_type { };
template <> struct __is_std_signed<long>: true_type { };
template <> struct __is_std_signed<long long>: true_type { };

// __is_std_unsigned specializations for each standard unsigned
// integer type (T must not be cv-qualified)
template <> struct __is_std_signed<unsigned char>: true_type { };
template <> struct __is_std_signed<unsigned int>: true_type { };
template <> struct __is_std_signed<unsigned short>: true_type { };
template <> struct __is_std_signed<unsigned long>: true_type { };
template <> struct __is_std_signed<unsigned long long>: true_type { };

// __is_ext_signed and __is_ext_unsigned traits for implementation
// defined extended signed and extended unsigned integer types
template <class> struct __is_ext_signed: false_type { };
template <class> struct __is_ext_unsigned: false_type { };

template <class T>
struct is_signed:
  integral_constant<bool,
                       __is_std_signed<typename remove_cv<T>::type>::value
                    || __is_ext_signed<typename remove_cv<T>::type>::value>
{ };

template <class T>
struct is_unsigned:
  integral_constant<bool,
                       __is_std_unsigned<typename remove_cv<T>::type>::value
                    || __is_ext_unsigned<typename remove_cv<T>::type>::value>
{ };

template <class T>
struct is_integral:
  integral_constant<
    bool,
       is_signed<T>::value
    || is_unsigned<T>::value
    || is_same<typename remove_cv<T>::type, bool>::value
    || is_same<typename remove_cv<T>::type, char>::value
    || is_same<typename remove_cv<T>::type, wchar_t>::value>
{ };

#include <assert.h>

template <class T, bool Expect>
void test ()
{
    // verify that is_integral<T> is publicly (directly or otherwise)
    // derived from integral_constant<bool, Expect> and that the base
    // has a static const data member of type bool named value with
    // the expected value (and if the same member exists in the
    // derived class it has the same value as well)
#define TEST(T)                                              \
    do {                                                     \
        const is_integral<T> trait = is_integral<T>();       \
        typedef integral_constant<bool, Expect> Base;        \
        const Base &base = trait;                            \
        const bool &base_result = Base::value;               \
        const bool &derived_result = is_integral<T>::value;  \
        assert (Expect == base_result);                      \
        assert (base_result == derived_result);              \
    } while (0)

    TEST (T);
    TEST (const T);
    TEST (volatile T);
    TEST (const volatile T);
}


typedef int Array [];
struct Incomplete;
enum Enumeration { };
typedef void Function ();
typedef void (*FunctionPointer)();
typedef int Incomplete::*MemberPointer;
typedef void (Incomplete::*MemberFunctionPointer)();

int main ()
{
    // exercise signed intergral types
    test<signed char, true>();
    test<signed short, true>();
    test<signed int, true>();
    test<signed long, true>();
    test<signed long long, true>();

    // exercise unsigned intergral types
    test<unsigned char, true>();
    test<unsigned short, true>();
    test<unsigned int, true>();
    test<unsigned long, true>();
    test<unsigned long long, true>();

    // exercise bool, char, and wchar_t
    test<bool, true>();
    test<char, true>();
    test<wchar_t, true>();

    // references to integral types are not themselves integral types
    test<signed char&, false>();
    test<signed short&, false>();
    test<signed int&, false>();
    test<signed long&, false>();
    test<signed long long&, false>();

    test<bool&, false>();
    test<char&, false>();
    test<wchar_t&, false>();

    // exercise floating point types
    test<float, false>();
    test<double, false>();
    test<long double, false>();

    // exercise other types
    test<void, false>();
    test<void*, false>();
    test<int*, false>();
    test<const int*, false>();
    test<volatile int*, false>();
    test<const volatile int*, false>();

    test<Array, false>();
    test<Incomplete, false>();
    test<Enumeration, false>();
    test<Function, false>();
    test<FunctionPointer, false>();
    test<MemberFunctionPointer, false>();
    test<MemberPointer, false>();
}