#ifndef BOOST_TYPE_TRAITS_HPP
#define BOOST_TYPE_TRAITS_HPP

#include <cstddef>
#include <climits>

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

CONTENTS
~~~~~~~~

1: Helper Macros for builtin compiler support.
2: Fundamental type operations:
   Usage: "class_name<T>::type" performs indicated transformation on T.

   remove_volatile        - remove top level volatile qualifier
   remove_const           - remove top level const qualifier
   remove_cv              - remove top level const/volatile qualifiers
   remove_reference       - remove top level reference if present
   remove_bounds          - remove top level array bound if present

3: Fundamental type properties
   Usage: "class_name<T>::value" is true if indicated property is true, false otherwise
   
   is_fundamental_type    - builtin required by standard
   is_builtin_type        - all builtins including compiler specific extentions
   is_void                - true if T is void
   is_class_type          - T is a struct class or union
   is_empty               - T is an empty struct or class
   is_same_type           - T and U are same type
   is_const               - T is const
   is_volatile            - T is volatile
   is_reference           - T is a reference
   is_pointer             - T is a pointer
   is_member_pointer      - T is a pointer to a member
   is_array               - T is an array
   is_enum                - T is an enum
   has_trivial_constructor- T has trivial default constructor
   has_trivial_copy       - T has trivial copy constructor
   has_trivial_assign     - T has trivial assignment operator
   has_trivial_destructor - T has trivial destructor
   is_POD                 - T is a POD type


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

//
// Helper macros for builitin compiler support.
// If your compiler has builtin support for any of the following
// traits concepts, then redefine the appropriate macros to pick
// up on the compiler support:
//
// BOOST_IS_ENUM(T) should evaluate to true if T is an enumerator type, false otherwise.
// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if T() <==> memset
// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect

#define BOOST_IS_ENUM(T) false
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
#define BOOST_HAS_TRIVIAL_COPY(T) false
#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false


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

namespace boost{
//
// start with fundamental type operations:

namespace _Jm{
//
// implementation helper:
//
template <class T>
struct cv_traits_imp{};

template <class T>
struct cv_traits_imp<T*>
{
   static const bool is_const = false;
   static const bool is_volatile = false;
   typedef T non_const_type;
   typedef T non_volatile_type;
   typedef T unqualified_type;
   static const char* what() { return ""; }
};

template <class T>
struct cv_traits_imp<const T*>
{
   static const bool is_const = true;
   static const bool is_volatile = false;
   typedef T non_const_type;
   typedef const T non_volatile_type;
   typedef T unqualified_type;
   static const char* what() { return "const"; }
};

template <class T>
struct cv_traits_imp<volatile T*>
{
   static const bool is_const = false;
   static const bool is_volatile = true;
   typedef volatile T non_const_type;
   typedef T non_volatile_type;
   typedef T unqualified_type;
   static const char* what() { return "volatile"; }
};

template <class T>
struct cv_traits_imp<const volatile T*>
{
   static const bool is_const = true;
   static const bool is_volatile = true;
   typedef volatile T non_const_type;
   typedef const T non_volatile_type;
   typedef T unqualified_type;
   static const char* what() { return "const volatile"; }
};

} // namespace _Jm

// * convert a type T to a non-volatile type - remove_volatile<T>
template <typename T>
struct remove_volatile
{
   typedef typename _Jm::cv_traits_imp<T*>::non_volatile_type type;
};
template <typename T> struct remove_volatile<T&>{ typedef T& type; };

// * convert a type T to non-const type - remove_const<T>
template <typename T>
struct remove_const
{
   typedef typename _Jm::cv_traits_imp<T*>::non_const_type type;
};
template <typename T> struct remove_const<T&>{ typedef T& type; };

//  convert a type T to a non-cv-qualified type - remove_cv<T>
template <typename T>
struct remove_cv
{
   typedef typename _Jm::cv_traits_imp<T*>::unqualified_type type;
};
template <typename T> struct remove_cv<T&>{ typedef T& type; };

// * convert a type T to a non-reference if it is one - remove_reference<T>
template <typename T> struct remove_reference{ typedef T type; };
template <typename T> struct remove_reference<T&>{ typedef T type; };
// are these well formed???
//template <typename T> struct remove_reference<T&const>{ typedef T type; };
//template <typename T> struct remove_reference<T&volatile>{ typedef T type; };
//template <typename T> struct remove_reference<T&const volatile>{ typedef T type; };

// * convert an array type to underlying non-array type - remove_bounds<T>
template <typename T> struct remove_bounds{ typedef T type; };
template <typename T, std::size_t N> struct remove_bounds<T[N]>{ typedef T type; };

/**************************************************************************/
//
// fundamental property classes:

//* is a type T  declared const - is_const<T>
template <typename T>
struct is_const
{
   static const bool value = _Jm::cv_traits_imp<T*>::is_const;
};

//* is a type T declared volatile - is_volatile<T>
template <typename T>
struct is_volatile
{
   static const bool value = _Jm::cv_traits_imp<T*>::is_volatile;
};

//* is a type T the same as type U - is_same_type<T,U>
template <typename T, typename U> struct is_same_type { static const bool value = false; };
template <typename T> struct is_same_type<T, T> { static const bool value = true; };

//* is a type T a fundamental type described in the standard - is_fundamental_type<T>
template <typename T> struct is_fundamental_type{ static const bool value = false; };
template <> struct is_fundamental_type<char>{ static const bool value = true; };
template <> struct is_fundamental_type<signed char>{ static const bool value = true; };
template <> struct is_fundamental_type<unsigned char>{ static const bool value = true; };
template <> struct is_fundamental_type<wchar_t>{ static const bool value = true; };
template <> struct is_fundamental_type<short>{ static const bool value = true; };
template <> struct is_fundamental_type<unsigned short>{ static const bool value = true; };
template <> struct is_fundamental_type<int>{ static const bool value = true; };
template <> struct is_fundamental_type<unsigned int>{ static const bool value = true; };
template <> struct is_fundamental_type<long>{ static const bool value = true; };
template <> struct is_fundamental_type<unsigned long>{ static const bool value = true; };
template <> struct is_fundamental_type<float>{ static const bool value = true; };
template <> struct is_fundamental_type<double>{ static const bool value = true; };
template <> struct is_fundamental_type<long double>{ static const bool value = true; };
template <> struct is_fundamental_type<bool>{ static const bool value = true; };

//* is a type T void - is_void<T>
template <typename T> struct is_void{ static const bool value = false; };
template <> struct is_void<void>{ static const bool value = true; };

//* is a type T a built in type - is_builtin_type<T>
// specialise for compiler defined extentions:
template <typename T> struct is_builtin_type{ static const bool value = is_fundamental_type<T>::value; };
#ifdef ULLONG_MAX
template <> struct is_builtin_type<long long>{ static const bool value = true; };
template <> struct is_builtin_type<unsigned long long>{ static const bool value = true; };
#endif
#if defined(__BORLANDC__) || defined(_MSC_VER)
template <> struct is_builtin_type<__int64>{ static const bool value = true; };
template <> struct is_builtin_type<unsigned __int64>{ static const bool value = true; };
#endif

//* is a type T a reference type - is_reference<T>
template <typename T> struct is_reference{ static const bool value = false; };
template <typename T> struct is_reference<T&>{ static const bool value = true; };

//* is a type T a pointer type (including function pointers) - is_pointer<T>
template <typename T> struct is_pointer{ static const bool value = false; };
template <typename T> struct is_pointer<T*>{ static const bool value = true; };
template <typename T> struct is_pointer<T*const>{ static const bool value = true; };
template <typename T> struct is_pointer<T*volatile>{ static const bool value = true; };
template <typename T> struct is_pointer<T*volatile const>{ static const bool value = true; };
template <typename T, typename U> struct is_pointer<U T::*>{ static const bool value = true; };
#ifdef __BORLANDC__
// this doesn't work:
//template <typename T> struct is_pointer<T __closure*>{ static const bool value = true; };
#endif

//*? is a type T a regular function pointer - is_function_pointer<T>
// there appears to be no implemenation for this??

//* is a type T a member function pointer - is_member_pointer<T>
template <typename T> struct is_member_pointer{ static const bool value = false; };
template <typename T, typename U> struct is_member_pointer<U T::*>{ static const bool value = true; };


//* is a type T an array - is_array<T>
template <typename T> struct is_array{ static const bool value = false; };
template <typename T, std::size_t N> struct is_array<T[N]>{ static const bool value = true; };

//*? is a type T an enum - is_enum<T>
template <typename T> struct is_enum{ static const bool value = BOOST_IS_ENUM(T); };

//*? is a type T a composite type (class/struct/union) - is_class_type<T> - can be implemented if is_enum<T> can be (and vice-versa).
template <typename T> struct is_class_type
{
   static const bool value = !(is_pointer<T>::value
                               || is_reference<T>::value
                               || is_array<typename remove_cv<T>::type>::value
                               || is_enum<typename remove_cv<T>::type>::value
                               || is_builtin_type<typename remove_cv<T>::type>::value);
};

//* is a type T an empty composite type - is_empty<T> - only strictly implementable if we have is_class_type<T>
namespace _Jm{

template <typename T, bool b>
struct empty_helper{ static const bool value = false; };

template <typename T>
struct empty_helper<T, true>
{
private:
   struct t : public T
   { int i[256]; };
   struct t2 { int i[256]; };
public:
   static const bool value = (sizeof(t) == sizeof(t2));
};

}  // namespace _jm

template <typename T>
struct is_empty
{
   static const bool value = _Jm::empty_helper<T, is_class_type<T>::value>::value;
};

namespace _Jm{
//
// helper class for determining whether a type is a POD,
// when this gets called cv-modifiers have already been stripped
// from type T.
//
template <typename T>
struct POD_logic
{
   static const bool value = is_builtin_type<T>::value
                        || is_pointer<T>::value
                        || is_reference<T>::value
                        || is_enum<T>::value;
};

template <typename T, std::size_t N>
struct POD_logic<T[N]>
{
   // recursion:
   static const bool value = POD_logic<T>::value;
};

} // namspace _Jm

// SGI style type trait information:
template <typename T>
struct has_trivial_constructor
{
   static const bool value = _Jm::POD_logic<typename remove_cv<T>::type>::value
                              || BOOST_HAS_TRIVIAL_CONSTRUCTOR(T);
};
template <typename T>
struct has_trivial_copy
{
   static const bool value = _Jm::POD_logic<typename remove_const<T>::type>::value
                              || BOOST_HAS_TRIVIAL_COPY(T);
};
template <typename T>
struct has_trivial_assign
{
   static const bool value = _Jm::POD_logic<typename remove_const<T>::type>::value
                              || BOOST_HAS_TRIVIAL_ASSIGN(T);
};
template <typename T>
struct has_trivial_destructor
{
   static const bool value = _Jm::POD_logic<typename remove_cv<T>::type>::value
                              || BOOST_HAS_TRIVIAL_DESTRUCTOR(T);
};
template <typename T>
struct is_POD
{
   static const bool value = has_trivial_constructor<T>::value
                              && has_trivial_copy<T>::value
                              && has_trivial_assign<T>::value
                              && has_trivial_destructor<T>::value;
};



} // namespace boost

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

//
// undefine helper macro's:
//
#undef BOOST_IS_ENUM
#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
#undef BOOST_HAS_TRIVIAL_COPY
#undef BOOST_HAS_TRIVIAL_ASSIGN
#undef BOOST_HAS_TRIVIAL_DESTRUCTOR

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

#endif  // include guard



#include <iostream>
#include <typeinfo>

using namespace boost;

#ifdef __BORLANDC__
#pragma option -w-ccc -w-rch -w-eff
#endif

//
// define tests here
unsigned failures = 0;

#define value_test(v, x) if(v == x) /*std::cout << "checking value of " << #x << "...OK" << std::endl*/;\
                         else{++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}

#define type_test(v, x) if(is_same_type<v, x>::value) /*std::cout << "checking type of " << #x << "...OK" << std::endl*/;\
                         else{++failures; std::cout << "checking type of " << #x << "...failed (type was: " << typeid(x).name() << " expected: " << typeid(v).name() << ")" << std::endl;}

struct UDT
{
   UDT();
   ~UDT();
   UDT(const UDT&);
   UDT& operator=(const UDT&);
   int i;

   void f1();
   int f2();
   int f3(int);
   int f4(int, float);
};

enum enum_UDT{ one, two, three };

struct empty_UDT{};



int main()
{
   std::cout << "Checking type operations..." << std::endl << std::endl;

   type_test(int, remove_reference<int>::type)
   type_test(const int, remove_reference<const int>::type)
   type_test(int, remove_reference<int&>::type)
   type_test(const int, remove_reference<const int&>::type)
   //type_test(volatile int, remove_reference<volatile int&>::type)
   //type_test(int, remove_reference<int&const>::type)
   //type_test(int, remove_reference<int&volatile>::type)
   type_test(int, remove_const<const int>::type)
   type_test(volatile int, remove_const<volatile int>::type)
   type_test(volatile int, remove_const<const volatile int>::type)
   type_test(int, remove_const<int>::type)
   type_test(int*, remove_const<int* const>::type)
   type_test(int, remove_volatile<volatile int>::type)
   type_test(const int, remove_volatile<const int>::type)
   type_test(const int, remove_volatile<const volatile int>::type)
   type_test(int, remove_volatile<int>::type)
   type_test(int*, remove_volatile<int* volatile>::type)
   type_test(int, remove_cv<volatile int>::type)
   type_test(int, remove_cv<const int>::type)
   type_test(int, remove_cv<const volatile int>::type)
   type_test(int, remove_cv<int>::type)
   type_test(int*, remove_cv<int* volatile>::type)
   type_test(int*, remove_cv<int* const>::type)
   type_test(int*, remove_cv<int* const volatile>::type)
   type_test(int, remove_bounds<int>::type)
   type_test(int*, remove_bounds<int*>::type)
   type_test(int, remove_bounds<int[3]>::type)
   type_test(int[3], remove_bounds<int[2][3]>::type)

   std::cout << std::endl << "Checking type properties..." << std::endl << std::endl;

   value_test(false, is_fundamental_type<UDT>::value)
   value_test(true, is_fundamental_type<char>::value)
   value_test(true, is_fundamental_type<signed char>::value)
   value_test(true, is_fundamental_type<unsigned char>::value)
   value_test(true, is_fundamental_type<wchar_t>::value)
   value_test(true, is_fundamental_type<short>::value)
   value_test(true, is_fundamental_type<unsigned short>::value)
   value_test(true, is_fundamental_type<int>::value)
   value_test(true, is_fundamental_type<unsigned int>::value)
   value_test(true, is_fundamental_type<long>::value)
   value_test(true, is_fundamental_type<unsigned long>::value)
   value_test(true, is_fundamental_type<float>::value)
   value_test(true, is_fundamental_type<double>::value)
   value_test(true, is_fundamental_type<long double>::value)
   value_test(true, is_fundamental_type<bool>::value)

   value_test(true, is_void<void>::value)
   value_test(false, is_void<int>::value)

   value_test(false, is_builtin_type<UDT>::value)
   value_test(true, is_builtin_type<char>::value)
   value_test(true, is_builtin_type<signed char>::value)
   value_test(true, is_builtin_type<unsigned char>::value)
   value_test(true, is_builtin_type<wchar_t>::value)
   value_test(true, is_builtin_type<short>::value)
   value_test(true, is_builtin_type<unsigned short>::value)
   value_test(true, is_builtin_type<int>::value)
   value_test(true, is_builtin_type<unsigned int>::value)
   value_test(true, is_builtin_type<long>::value)
   value_test(true, is_builtin_type<unsigned long>::value)
   value_test(true, is_builtin_type<float>::value)
   value_test(true, is_builtin_type<double>::value)
   value_test(true, is_builtin_type<long double>::value)
   value_test(true, is_builtin_type<bool>::value)
   #ifdef ULLONG_MAX
   value_test(true, is_builtin_type<long long>::value)
   value_test(true, is_builtin_type<unsigned long long>::value)
   #endif
   #if defined(__BORLANDC__) || defined(_MSC_VER)
   value_test(true, is_builtin_type<__int64>::value)
   value_test(true, is_builtin_type<unsigned __int64>::value)
   #endif

   value_test(false, is_reference<bool>::value)
   value_test(true, is_reference<int&>::value)
   value_test(true, is_reference<const int&>::value)
   value_test(true, is_reference<volatile int &>::value)

   value_test(false, is_pointer<int>::value)
   value_test(false, is_pointer<int&>::value)
   value_test(true, is_pointer<int*>::value)
   value_test(true, is_pointer<int*const>::value)
   value_test(true, is_pointer<int*volatile>::value)
   value_test(true, is_pointer<int*const volatile>::value)
   typedef void(*f1)();
   typedef int(*f2)(int);
   typedef int(*f3)(int, bool);
   typedef void (UDT::*mf1)();
   typedef int (UDT::*mf2)();
   typedef int (UDT::*mf3)(int);
   typedef int (UDT::*mf4)(int, float);

   value_test(true, is_pointer<f1>::value)
   value_test(true, is_pointer<f2>::value)
   value_test(true, is_pointer<f3>::value)
   value_test(true, is_pointer<mf1>::value)
   value_test(true, is_pointer<mf2>::value)
   value_test(true, is_pointer<mf3>::value)
   value_test(true, is_pointer<mf4>::value)
   #ifdef __BORLANDC__
   typedef void (__closure *cf1)();
   typedef int (__closure *cf2)();
   typedef int (__closure *cf3)(int);
   typedef int (__closure *cf4)(int, float);
   value_test(true, is_pointer<cf1>::value)
   value_test(true, is_pointer<cf2>::value)
   value_test(true, is_pointer<cf3>::value)
   value_test(true, is_pointer<cf4>::value)
   #endif
   value_test(false, is_member_pointer<f1>::value)
   value_test(false, is_member_pointer<f2>::value)
   value_test(false, is_member_pointer<f3>::value)
   value_test(true, is_member_pointer<mf1>::value)
   value_test(true, is_member_pointer<mf2>::value)
   value_test(true, is_member_pointer<mf3>::value)
   value_test(true, is_member_pointer<mf4>::value)
   value_test(false, is_array<int>::value)
   value_test(false, is_array<int*>::value)
   value_test(true, is_array<int[2]>::value)
   value_test(true, is_array<int[2][3]>::value)
   value_test(true, is_array<UDT[2]>::value)

   value_test(false, is_enum<int>::value)
   value_test(true, is_enum<enum_UDT>::value)   // this will fail

   value_test(false, is_class_type<int>::value)
   value_test(false, is_class_type<const int>::value)
   value_test(false, is_class_type<volatile int>::value)
   value_test(false, is_class_type<int*>::value)
   value_test(false, is_class_type<int* const>::value)
   value_test(false, is_class_type<int[2]>::value)
   value_test(false, is_class_type<int&>::value)
   value_test(false, is_class_type<mf4>::value)
   value_test(false, is_class_type<f1>::value)
   value_test(false, is_class_type<enum_UDT>::value) // this will fail
   value_test(true, is_class_type<UDT>::value)
   value_test(true, is_class_type<UDT const>::value)
   value_test(true, is_class_type<UDT volatile>::value)
   value_test(true, is_class_type<empty_UDT>::value)
   value_test(true, is_class_type<std::iostream>::value)
   value_test(false, is_class_type<UDT*>::value)
   value_test(false, is_class_type<UDT[2]>::value)
   value_test(false, is_class_type<UDT&>::value)

   value_test(false, is_empty<int>::value)
   value_test(false, is_empty<int*>::value)
   value_test(false, is_empty<int&>::value)
   value_test(false, is_empty<int[2]>::value)
   value_test(false, is_empty<f1>::value)
   value_test(false, is_empty<mf1>::value)
   value_test(false, is_empty<UDT>::value)
   value_test(false, is_empty<std::iostream>::value)
   value_test(true, is_empty<empty_UDT>::value)   // this may fail on some compilers
   //value_test(false, is_empty<enum_UDT>::value)   // !!! this doesn't compile

   value_test(true, has_trivial_constructor<int>::value)
   value_test(true, has_trivial_constructor<int*>::value)
   value_test(true, has_trivial_constructor<int&>::value)
   value_test(true, has_trivial_constructor<int*const>::value)
   value_test(true, has_trivial_constructor<const int>::value)
   value_test(true, has_trivial_constructor<volatile int>::value)
   value_test(true, has_trivial_constructor<const int&>::value)
   value_test(true, has_trivial_constructor<int[2]>::value)
   value_test(true, has_trivial_constructor<int[3][2]>::value)
   value_test(true, has_trivial_constructor<int[2][4][5][6][3]>::value)
   value_test(true, has_trivial_constructor<f1>::value)
   value_test(true, has_trivial_constructor<mf2>::value)
   value_test(false, has_trivial_constructor<UDT>::value)
   value_test(true, has_trivial_constructor<empty_UDT>::value)  // this will fail
   value_test(true, has_trivial_constructor<enum_UDT>::value)  // this will fail

   value_test(true, has_trivial_copy<int>::value)
   value_test(true, has_trivial_copy<int*>::value)
   value_test(true, has_trivial_copy<int&>::value)
   value_test(true, has_trivial_copy<int*const>::value)
   value_test(true, has_trivial_copy<const int>::value)
   value_test(false, has_trivial_copy<volatile int>::value)
   value_test(true, has_trivial_copy<const int&>::value)
   value_test(true, has_trivial_copy<int[2]>::value)
   value_test(true, has_trivial_copy<int[3][2]>::value)
   value_test(true, has_trivial_copy<int[2][4][5][6][3]>::value)
   value_test(true, has_trivial_copy<f1>::value)
   value_test(true, has_trivial_copy<mf2>::value)
   value_test(false, has_trivial_copy<UDT>::value)
   value_test(true, has_trivial_copy<empty_UDT>::value)  // this will fail
   value_test(true, has_trivial_copy<enum_UDT>::value)  // this will fail

   value_test(true, has_trivial_assign<int>::value)
   value_test(true, has_trivial_assign<int*>::value)
   value_test(true, has_trivial_assign<int&>::value)
   value_test(true, has_trivial_assign<int*const>::value)
   value_test(true, has_trivial_assign<const int>::value)
   value_test(false, has_trivial_assign<volatile int>::value)
   value_test(true, has_trivial_assign<const int&>::value)
   value_test(true, has_trivial_assign<int[2]>::value)
   value_test(true, has_trivial_assign<int[3][2]>::value)
   value_test(true, has_trivial_assign<int[2][4][5][6][3]>::value)
   value_test(true, has_trivial_assign<f1>::value)
   value_test(true, has_trivial_assign<mf2>::value)
   value_test(false, has_trivial_assign<UDT>::value)
   value_test(true, has_trivial_assign<empty_UDT>::value)  // this will fail
   value_test(true, has_trivial_assign<enum_UDT>::value)  // this will fail

   value_test(true, has_trivial_destructor<int>::value)
   value_test(true, has_trivial_destructor<int*>::value)
   value_test(true, has_trivial_destructor<int&>::value)
   value_test(true, has_trivial_destructor<int*const>::value)
   value_test(true, has_trivial_destructor<const int>::value)
   value_test(true, has_trivial_destructor<volatile int>::value)
   value_test(true, has_trivial_destructor<const int&>::value)
   value_test(true, has_trivial_destructor<int[2]>::value)
   value_test(true, has_trivial_destructor<int[3][2]>::value)
   value_test(true, has_trivial_destructor<int[2][4][5][6][3]>::value)
   value_test(true, has_trivial_destructor<f1>::value)
   value_test(true, has_trivial_destructor<mf2>::value)
   value_test(false, has_trivial_destructor<UDT>::value)
   value_test(true, has_trivial_destructor<empty_UDT>::value)  // this will fail
   value_test(true, has_trivial_destructor<enum_UDT>::value)  // this will fail

   value_test(true, is_POD<int>::value)
   value_test(true, is_POD<int*>::value)
   value_test(true, is_POD<int&>::value)
   value_test(true, is_POD<int*const>::value)
   value_test(true, is_POD<const int>::value)
   value_test(false, is_POD<volatile int>::value)
   value_test(true, is_POD<const int&>::value)
   value_test(true, is_POD<int[2]>::value)
   value_test(true, is_POD<int[3][2]>::value)
   value_test(true, is_POD<int[2][4][5][6][3]>::value)
   value_test(true, is_POD<f1>::value)
   value_test(true, is_POD<mf2>::value)
   value_test(false, is_POD<UDT>::value)
   value_test(true, is_POD<empty_UDT>::value)  // this will fail
   value_test(true, is_POD<enum_UDT>::value)  // this will fail

   std::cout << std::endl << "Tests completed (" << failures << " failures)... press any key to exit";
   std::cin.get();
}