#ifndef UTILS_H
#define UTILS_H

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

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

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

template <typename A, typename B>
struct Select<true,A,B> {
	typedef A 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 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 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;
};

#endif