From 292c5a35b7ec7fb3d25222ccaceb2eaa05f1bd79 Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Mon, 13 Apr 2015 22:56:02 +0100
Subject: [PATCH] moar traits + strip qualifiers first

---
 octa/traits.h | 90 ++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 71 insertions(+), 19 deletions(-)

diff --git a/octa/traits.h b/octa/traits.h
index e1f5735..d0e42af 100644
--- a/octa/traits.h
+++ b/octa/traits.h
@@ -9,6 +9,37 @@
 #include "octa/types.h"
 
 namespace octa {
+    /* conditional */
+
+    template<bool cond, typename T, typename U>
+    struct Conditional {
+        typedef T type;
+    };
+
+    template<typename T, typename U>
+    struct Conditional<false, T, U> {
+        typedef U type;
+    };
+
+    /* removers */
+
+    template<typename T> struct RemoveReference      { typedef T type; };
+    template<typename T> struct RemoveReference<T&>  { typedef T type; };
+    template<typename T> struct RemoveReference<T&&> { typedef T type; };
+
+    template<typename T> struct RemoveConst          { typedef T type; };
+    template<typename T> struct RemoveConst<const T> { typedef T type; };
+
+    template<typename T> struct RemoveVolatile             { typedef T type; };
+    template<typename T> struct RemoveVolatile<volatile T> { typedef T type; };
+
+    template<typename T>
+    struct RemoveConstVolatile {
+        typedef typename RemoveVolatile<typename RemoveConst<T>::type>::type type;
+    };
+
+    /* integral constant */
+
     template<typename T, T val>
     struct IntegralConstant {
         static const T value = val;
@@ -22,33 +53,54 @@ namespace octa {
 
     template<typename T, T val> const T IntegralConstant<T, val>::value;
 
-    template<typename T> struct IsInteger: false_t {};
-    template<typename T> struct IsFloat  : false_t {};
-    template<typename T> struct IsPointer: false_t {};
+    /* is integer */
 
-    template<> struct IsInteger<bool  >: true_t {};
-    template<> struct IsInteger<char  >: true_t {};
-    template<> struct IsInteger<uchar >: true_t {};
-    template<> struct IsInteger<schar >: true_t {};
-    template<> struct IsInteger<short >: true_t {};
-    template<> struct IsInteger<ushort>: true_t {};
-    template<> struct IsInteger<int   >: true_t {};
-    template<> struct IsInteger<uint  >: true_t {};
-    template<> struct IsInteger<long  >: true_t {};
-    template<> struct IsInteger<ulong >: true_t {};
-    template<> struct IsInteger<llong >: true_t {};
-    template<> struct IsInteger<ullong>: true_t {};
+    template<typename T> struct IsIntegerBase: false_t {};
 
-    template<> struct IsFloat<float>: true_t {};
-    template<> struct IsFloat<double>: true_t {};
-    template<> struct IsFloat<ldouble>: true_t {};
+    template<> struct IsIntegerBase<bool  >: true_t {};
+    template<> struct IsIntegerBase<char  >: true_t {};
+    template<> struct IsIntegerBase<uchar >: true_t {};
+    template<> struct IsIntegerBase<schar >: true_t {};
+    template<> struct IsIntegerBase<short >: true_t {};
+    template<> struct IsIntegerBase<ushort>: true_t {};
+    template<> struct IsIntegerBase<int   >: true_t {};
+    template<> struct IsIntegerBase<uint  >: true_t {};
+    template<> struct IsIntegerBase<long  >: true_t {};
+    template<> struct IsIntegerBase<ulong >: true_t {};
+    template<> struct IsIntegerBase<llong >: true_t {};
+    template<> struct IsIntegerBase<ullong>: true_t {};
 
-    template<> struct IsPointer<T *>: true_t {};
+    template<typename T>
+    struct IsInteger: IsIntegerBase<typename RemoveConstVolatile<T>::type> {};
+
+    /* is floating point */
+
+    template<typename T> struct IsFloatBase  : false_t {};
+
+    template<> struct IsFloatBase<float>: true_t {};
+    template<> struct IsFloatBase<double>: true_t {};
+    template<> struct IsFloatBase<ldouble>: true_t {};
+
+    template<typename T>
+    struct IsFloat: IsFloatBase<typename RemoveConstVolatile<T>::type> {};
+
+    /* is pointer */
+
+    template<typename T> struct IsPointerBase: false_t {};
+
+    template<> struct IsPointerBase<T *>: true_t {};
+
+    template<typename T>
+    struct IsPointer: IsPointerBase<typename RemoveConstVolatile<T>::type> {};
+
+    /* is POD: currently wrong */
 
     template<typename T> struct IsPOD: IntegralConstant<bool,
         (IsInteger<T>::value || IsFloat<T>::value || IsPointer<T>::value)
     > {};
 
+    /* type equality */
+
     template<typename, typename>
     struct IsEqual {
         static const bool value = false;