//
// Copyright (c) 2002 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.
//

// "typeof" operator implementation
//
// Described in CUJ 20(8, 10, and 12), August, October, and December 2002:  "A Bit-Wise Typeof"
// This version is a re-write of the original implementation that employs the typeint implementation
// of extended precision compile time arithmetic.  Typeints are described in CUJ online experts
// column, February 2003.
// 

#ifndef UTILS_H
#define UTILS_H

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

//
//	Type qualifier utilities.
//

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 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; };

#endif