mfbt/TypeTraits.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 /* Template-based metaprogramming and type-testing facilities. */
   6
   7 #ifndef mozilla_TypeTraits_h_
   8 #define mozilla_TypeTraits_h_
   9
  10 /*
  11  * These traits are approximate copies of the traits and semantics from C++11's
  12  * <type_traits> header.  Don't add traits not in that header!  When all
  13  * platforms provide that header, we can convert all users and remove this one.
  14  */
  15
  16 #include <wchar.h>
  17
  18 namespace mozilla {
  19
  20 /* 20.9.3 Helper classes [meta.help] */
  21
  22 /**
  23  * Helper class used as a base for various type traits, exposed publicly
  24  * because <type_traits> exposes it as well.
  25  */
  26 template<typename T, T Value>
  27 struct IntegralConstant
  28 {
  29     static const T value = Value;
  30     typedef T ValueType;
  31     typedef IntegralConstant<T, Value> Type;
  32 };
  33
  34 /** Convenient aliases. */
  35 typedef IntegralConstant<bool, true> TrueType;
  36 typedef IntegralConstant<bool, false> FalseType;
  37
  38 /* 20.9.4 Unary type traits [meta.unary] */
  39
  40 /* 20.9.4.1 Primary type categories [meta.unary.cat] */
  41
  42 /**
  43  * IsPointer determines whether a type is a pointer type (but not a pointer-to-
  44  * member type).
  45  *
  46  * mozilla::IsPointer<struct S*>::value is true;
  47  * mozilla::IsPointer<int**>::value is true;
  48  * mozilla::IsPointer<void (*)(void)>::value is true;
  49  * mozilla::IsPointer<int>::value is false;
  50  * mozilla::IsPointer<struct S>::value is false.
  51  */
  52 template<typename T>
  53 struct IsPointer : FalseType {};
  54
  55 template<typename T>
  56 struct IsPointer<T*> : TrueType {};
  57
  58 /* 20.9.4.2 Composite type traits [meta.unary.comp] */
  59
  60 /* 20.9.4.3 Type properties [meta.unary.prop] */
  61
  62 /**
  63  * Traits class for identifying POD types.  Until C++11 there's no automatic
  64  * way to detect PODs, so for the moment this is done manually.  Users may
  65  * define specializations of this class that inherit from mozilla::TrueType and
  66  * mozilla::FalseType (or equivalently mozilla::IntegralConstant<bool, true or
  67  * false>, or conveniently from mozilla::IsPod for composite types) as needed to
  68  * ensure correct IsPod behavior.
  69  */
  70 template<typename T>
  71 struct IsPod : public FalseType {};
  72
  73 template<> struct IsPod<char>               : TrueType {};
  74 template<> struct IsPod<signed char>        : TrueType {};
  75 template<> struct IsPod<unsigned char>      : TrueType {};
  76 template<> struct IsPod<short>              : TrueType {};
  77 template<> struct IsPod<unsigned short>     : TrueType {};
  78 template<> struct IsPod<int>                : TrueType {};
  79 template<> struct IsPod<unsigned int>       : TrueType {};
  80 template<> struct IsPod<long>               : TrueType {};
  81 template<> struct IsPod<unsigned long>      : TrueType {};
  82 template<> struct IsPod<long long>          : TrueType {};
  83 template<> struct IsPod<unsigned long long> : TrueType {};
  84 template<> struct IsPod<bool>               : TrueType {};
  85 template<> struct IsPod<float>              : TrueType {};
  86 template<> struct IsPod<double>             : TrueType {};
  87 template<> struct IsPod<wchar_t>            : TrueType {};
  88 template<typename T> struct IsPod<T*>       : TrueType {};
  89
  90 /* 20.9.5 Type property queries [meta.unary.prop.query] */
  91
  92 /* 20.9.6 Relationships between types [meta.rel] */
  93
  94 /**
  95  * IsSame tests whether two types are the same type.
  96  *
  97  * mozilla::IsSame<int, int>::value is true;
  98  * mozilla::IsSame<int*, int*>::value is true;
  99  * mozilla::IsSame<int, unsigned int>::value is false;
 100  * mozilla::IsSame<void, void>::value is true;
 101  * mozilla::IsSame<const int, int>::value is false;
 102  * mozilla::IsSame<struct S, struct S>::value is true.
 103  */
 104 template<typename T, typename U>
 105 struct IsSame : FalseType {};
 106
 107 template<typename T>
 108 struct IsSame<T, T> : TrueType {};
 109
 110 namespace detail {
 111
 112 // The trickery used to implement IsBaseOf here makes it possible to use it for
 113 // the cases of private and multiple inheritance.  This code was inspired by the
 114 // sample code here:
 115 //
 116 // http://stackoverflow.com/questions/2910979/how-is-base-of-works
 117 template<class Base, class Derived>
 118 struct BaseOfHelper
 119 {
 120   public:
 121     operator Base*() const;
 122     operator Derived*();
 123 };
 124
 125 template<class Base, class Derived>
 126 struct BaseOfTester
 127 {
 128   private:
 129     template<class T>
 130     static char test(Derived*, T);
 131     static int test(Base*, int);
 132
 133   public:
 134     static const bool value =
 135       sizeof(test(BaseOfHelper<Base, Derived>(), int())) == sizeof(char);
 136 };
 137
 138 template<class Base, class Derived>
 139 struct BaseOfTester<Base, const Derived>
 140 {
 141   private:
 142     template<class T>
 143     static char test(Derived*, T);
 144     static int test(Base*, int);
 145
 146   public:
 147     static const bool value =
 148       sizeof(test(BaseOfHelper<Base, Derived>(), int())) == sizeof(char);
 149 };
 150
 151 template<class Base, class Derived>
 152 struct BaseOfTester<Base&, Derived&> : FalseType {};
 153
 154 template<class Type>
 155 struct BaseOfTester<Type, Type> : TrueType {};
 156
 157 template<class Type>
 158 struct BaseOfTester<Type, const Type> : TrueType {};
 159
 160 } /* namespace detail */
 161
 162 /*
 163  * IsBaseOf allows to know whether a given class is derived from another.
 164  *
 165  * Consider the following class definitions:
 166  *
 167  *   class A {};
 168  *   class B : public A {};
 169  *   class C {};
 170  *
 171  * mozilla::IsBaseOf<A, B>::value is true;
 172  * mozilla::IsBaseOf<A, C>::value is false;
 173  */
 174 template<class Base, class Derived>
 175 struct IsBaseOf
 176   : IntegralConstant<bool, detail::BaseOfTester<Base, Derived>::value>
 177 {};
 178
 179 namespace detail {
 180
 181 template<typename From, typename To>
 182 struct ConvertibleTester
 183 {
 184   private:
 185     static From create();
 186
 187     template<typename From1, typename To1>
 188     static char test(To to);
 189
 190     template<typename From1, typename To1>
 191     static int test(...);
 192
 193   public:
 194     static const bool value =
 195       sizeof(test<From, To>(create())) == sizeof(char);
 196 };
 197
 198 } // namespace detail
 199
 200 /**
 201  * IsConvertible determines whether a value of type From will implicitly convert
 202  * to a value of type To.  For example:
 203  *
 204  *   struct A {};
 205  *   struct B : public A {};
 206  *   struct C {};
 207  *
 208  * mozilla::IsConvertible<A, A>::value is true;
 209  * mozilla::IsConvertible<A*, A*>::value is true;
 210  * mozilla::IsConvertible<B, A>::value is true;
 211  * mozilla::IsConvertible<B*, A*>::value is true;
 212  * mozilla::IsConvertible<C, A>::value is false;
 213  * mozilla::IsConvertible<A, C>::value is false;
 214  * mozilla::IsConvertible<A*, C*>::value is false;
 215  * mozilla::IsConvertible<C*, A*>::value is false.
 216  *
 217  * For obscure reasons, you can't use IsConvertible when the types being tested
 218  * are related through private inheritance, and you'll get a compile error if
 219  * you try.  Just don't do it!
 220  */
 221 template<typename From, typename To>
 222 struct IsConvertible
 223   : IntegralConstant<bool, detail::ConvertibleTester<From, To>::value>
 224 {};
 225
 226 /* 20.9.7 Transformations between types [meta.trans] */
 227
 228 /* 20.9.7.1 Const-volatile modifications [meta.trans.cv] */
 229
 230 /* 20.9.7.2 Reference modifications [meta.trans.ref] */
 231
 232 /* 20.9.7.3 Sign modifications [meta.trans.sign] */
 233
 234 /* 20.9.7.4 Array modifications [meta.trans.arr] */
 235
 236 /* 20.9.7.5 Pointer modifications [meta.trans.ptr] */
 237
 238 /* 20.9.7.6 Other transformations [meta.trans.other] */
 239
 240 /**
 241  * EnableIf is a struct containing a typedef of T if and only if B is true.
 242  *
 243  * mozilla::EnableIf<true, int>::Type is int;
 244  * mozilla::EnableIf<false, int>::Type is a compile-time error.
 245  *
 246  * Use this template to implement SFINAE-style (Substitution Failure Is not An
 247  * Error) requirements.  For example, you might use it to impose a restriction
 248  * on a template parameter:
 249  *
 250  *   template<typename T>
 251  *   class PodVector // vector optimized to store POD (memcpy-able) types
 252  *   {
 253  *      EnableIf<IsPod<T>::value, T>::Type* vector;
 254  *      size_t length;
 255  *      ...
 256  *   };
 257  */
 258 template<bool B, typename T = void>
 259 struct EnableIf
 260 {};
 261
 262 template<typename T>
 263 struct EnableIf<true, T>
 264 {
 265     typedef T Type;
 266 };
 267
 268 /**
 269  * Conditional selects a class between two, depending on a given boolean value.
 270  *
 271  * mozilla::Conditional<true, A, B>::Type is A;
 272  * mozilla::Conditional<false, A, B>::Type is B;
 273  */
 274 template<bool Condition, typename A, typename B>
 275 struct Conditional
 276 {
 277     typedef A Type;
 278 };
 279
 280 template<class A, class B>
 281 struct Conditional<false, A, B>
 282 {
 283     typedef B Type;
 284 };
 285
 286 } /* namespace mozilla */
 287
 288 #endif  /* mozilla_TypeTraits_h_ */