// Semantics Consulting's Tyr Library
// http://www.semantics.org
//
// Copyright (c) 2003 by Stephen C. Dewhurst
//
// Permission to use, copy, modify, distribute, and sell this software
// for any purpose is hereby granted without fee, provided that the above
// copyright notice appears in all copies and that both that copyright
// notice and this permission notice appear in supporting documentation.
// The author makes no representations about the suitability of this
// software for any purpose.  It is provided "as is" without express
// or implied warranty.

#ifndef UTILS_H
#define UTILS_H

//
//	Background utilities.  Lots of them are taken from Alexandrescu's
//	Modern C++ Design, so I'll include the following for good measure:
////////////////////////////////////////////////////////////////////////////////
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// This code accompanies the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
// Permission to use, copy, modify, distribute and sell this software for any 
//     purpose is hereby granted without fee, provided that the above copyright 
//     notice appear in all copies and that both that copyright notice and this 
//     permission notice appear in supporting documentation.
// The author or Addison-Welsey Longman make no representations about the 
//     suitability of this software for any purpose. It is provided "as is" 
//     without express or implied warranty.
////////////////////////////////////////////////////////////////////////////////

#include <iostream>

namespace Tyr {

template <bool, typename A, typename>
struct Select {
	typedef A R;
};

template <typename A, typename B>
struct Select<false,A,B> {
	typedef B R;
};

// A different Select for testing adapters
template <bool, typename A, typename>
struct ForeignSelect {
	typedef A Result;
};

template <typename A, typename B>
struct ForeignSelect<false,A,B> {
	typedef B Result;
};

template <typename A, typename B>
struct IsSame {
	enum { r = false };
};

template <typename A>
struct IsSame<A,A> {
	enum { r = true };
};

// A different IsSame for testing adapters
template <typename A, typename B>
struct ForeignIsSame {
	enum { result = false };
};

template <typename A>
struct ForeignIsSame<A,A> {
	enum { result = true };
};

// Some compilers can't handle Conversion correctly.
typedef char MySmall;
class MyBig { char dummy[2]; };

template <class T, class U>
class Conversion {
	static MySmall Test(U);
	static MyBig Test(...);
	static T MakeT();
  public:
	enum { exists = (sizeof(Test(MakeT())) == sizeof(MySmall)) };
};

#define SUPERSUBCLASS(T, U) \
	(Conversion<const U*, const T*>::exists && \
	!IsSame<const T*, const void*>::r)

#define SUPERSUBCLASS_STRICT(T, U) \
	(SUPERSUBCLASS(T, U) && \
	!IsSame<const T, const U>::r)

template <class A, class B>
struct IsDerivedFrom {
	enum { r = SUPERSUBCLASS_STRICT(A,B) };
};

//XXXXXXXXXX redundant with above
template <typename T1, typename T2>
struct CanConvert {
	typedef char True;
	typedef double False;
	static True canConvert( T2 );
	static False canConvert( ... );
	static T1 makeT1( );
	enum { r = sizeof(canConvert( makeT1( ) )) == sizeof(True) };
};

template <class T>
struct IsTrue { enum { r = true }; };

template <bool b, typename T = void>
struct enable_if {
	typedef T Type;
};

template <typename T>
struct enable_if<false,T>
{};

template <typename T>
struct Dereference {
	typedef T R;
};

template <typename T>
struct Dereference<T &> {
	typedef T R;
};

template <typename T>
struct Deref {
	typedef T R;
};

template <typename T>
struct Deref<T *> {
	typedef T R;
};

template <typename T>
struct Deref<T * const> {
	typedef T R;
};

template <typename T>
struct IsConst {
	enum { r = false };
};

template <typename T>
struct IsConst<const T> {
	enum { r = true };
};

template <typename T>
struct IsRef {
	enum { r = false };
};

template <typename T>
struct IsRef<T &> {
	enum { r = true };
};

template <typename T>
struct IsPcm {
	enum { r = false };
};

template <typename T, typename C>
struct IsPcm<T C::*> {
	enum { r = true };
};

template <typename T, typename C>
struct IsPcm<T C::*const> {
	enum { r = true };
};

template <typename T, typename C>
struct IsPcm<T C::*volatile> {
	enum { r = true };
};

template <typename T, typename C>
struct IsPcm<T C::*const volatile> {
	enum { r = true };
};
//xxx need other cases or an SFINAE solution for cv-quals, member funcs, etc.

template <typename T>
struct IsPtr {
	enum { r = false };
};

template <typename T>
struct IsPtr<T *> {
	enum { r = true };
};

template <typename T>
struct IsPtr<T * const> {
	enum { r = true };
};

template <typename T>
struct IsPtr<T * volatile> {
	enum { r = true };
};

template <typename T>
struct IsPtr<T * const volatile> {
	enum { r = true };
};

template <typename T>
struct IsAry {
	enum { r = false, bound = 0 /* note: must be 0 */ };
};

template <typename T, int n>
struct IsAry<T [n]> {
	enum { r = true, bound = n };
};
//=======================

template <typename T>
struct DeConst {
    typedef T R;
};

template <typename T>
struct DeConst<const T> {
   typedef T R;
};

template <typename T>
struct IsVol {
    enum { r = false }; };

template <typename T>
struct IsVol<volatile T> {
    enum { r = true }; };

template <typename T>
struct DeVol {
    typedef T R; };

template <typename T>
struct DeVol<volatile T> {
    typedef T R; };

template <typename T>
struct IsQual {
    enum { r = IsConst<T>::r || IsVol<T>::r }; };

template <typename T>
struct DeQual {
    typedef typename DeVol<typename DeConst<T>::R>::R R; };

//=======================
template <typename T>
struct Deary {
	// note: other code assumes OK to Deary a non-array, multiple times
	typedef T R;
};

template <typename T, int bound>
struct Deary<T [bound]> {
	typedef T R;
};

template <typename T, int n>
struct DearyN {
	typedef typename  DearyN<typename Deary<T>::R,n-1>::R R;
};

template <typename T>
struct DearyN<T,0> {
	typedef T R;
};

template <typename T, int n>
struct AddAryN {
	typedef typename AddAryN<T,n-1>::R R[1];
};

template <typename T>
struct AddAryN<T,0> {
	typedef T R;
};
//=======================
template <typename T>
struct DePtrAry {
	// note: other code assumes OK to Deary a non-array, multiple times
	typedef T R;
};

template <typename T, int bound>
struct DePtrAry<T (*)[bound]> {
	typedef T R;
};

template <typename T, int n>
struct DePtrAryN {
	typedef typename  DePtrAryN<typename DePtrAry<T>::R,n-1>::R R;
};

template <typename T>
struct DePtrAryN<T,0> {
	typedef T R;
};

template <typename T, int n>
struct AddPtrAryN {
	typedef typename AddPtrAryN<T,n-1>::R (*R)[1];
};

template <typename T>
struct AddPtrAryN<T,0> {
	typedef T R;
};

template <int v>
struct Int2Int {
	enum { value = v };
};

template <class C>
MySmall hasValue_type( typename C::value_type const * );
template <typename T>
MyBig hasValue_type( ... );
#define has_value_type( C ) (sizeof(hasValue_type<C>(0))==sizeof(MySmall))

//
//	Generate an integral encoding of the arguments
//	required to instantiate a template of unknown
//	argument requirements.
//
//XXX what about template template arguments?
//XXX general problem with templates we don't have with typenames
//XXX is that templates are highly combinatoric...
//
//XXX should use typeints here instead of hardcoded...
typedef const unsigned long E;
E e_t = 0x0001;		// typename
E e_tt = 0x0011;
E e_ttt = 0x0111;
E e_tttt = 0x1111;
E e_i = 0x0002;		// int
E e_ii = 0x0022;
E e_iii = 0x0222;
E e_iiii = 0x2222;
E e_itt = 0x0112;	// int,typename,typename
E e_b = 0x0003;		// bool
E e_btt = 0x0113;	// bool,typename,typename
E e_tT1t = 0x091;	// typename, template <typename> class

//XXX Need a way to define a function that can be instantiated with *any* template!

template <template <typename> class> char (*templArgEncoding())[e_t];
template <template <typename,typename> class> char (*templArgEncoding())[e_tt];
template <template <typename,typename,typename> class> char (*templArgEncoding())[e_ttt];
template <template <typename,typename,typename,typename> class> char (*templArgEncoding())[e_tttt];

template <template <int> class> char (*templArgEncoding())[e_i];
template <template <int,int> class> char (*templArgEncoding())[e_ii];
template <template <int,int,int> class> char (*templArgEncoding())[e_iii];
template <template <int,int,int,int> class> char (*templArgEncoding())[e_iiii];

template <template <int,typename,typename> class> char (*templArgEncoding())[e_itt];
template <template <bool> class> char (*templArgEncoding())[e_b];
template <template <bool,typename,typename> class> char (*templArgEncoding())[e_btt];
template <template <typename,template <typename> class> class> char (*templArgEncoding())[e_tT1t];


//XXX useful as a compile time switch for template functionality?
//XXX two versions:  typeint and to_int
#define Tyr_TemplArgEncoding( templateName ) \
	sizeof( *Tyr::templArgEncoding<templateName>() )

//XXX useful to do a compile time check before substituting one container for another?
//XXX can do an IsSame on the typeints, or typeint ==
#define Tyr_TemplatesTakeSameArgs( tname1, tname2 ) \
	(Tyr_TemplArgEncoding(tname1) == Tyr_TemplArgEncoding(tname2))

} // namespace Tyr

#endif