include/onlineupdate/mozilla/TypeTraits.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* Template-based metaprogramming and type-testing facilities. */
   8
   9 #ifndef mozilla_TypeTraits_h
  10 #define mozilla_TypeTraits_h
  11
  12 #include "Types.h"
  13
  14 /*
  15  * These traits are approximate copies of the traits and semantics from C++11's
  16  * <type_traits> header.  Don't add traits not in that header!  When all
  17  * platforms provide that header, we can convert all users and remove this one.
  18  */
  19
  20 #include <wchar.h>
  21
  22 namespace mozilla {
  23
  24 /* Forward declarations. */
  25
  26 template<typename> struct RemoveCV;
  27
  28 /* 20.9.3 Helper classes [meta.help] */
  29
  30 /**
  31  * Helper class used as a base for various type traits, exposed publicly
  32  * because <type_traits> exposes it as well.
  33  */
  34 template<typename T, T Value>
  35 struct IntegralConstant
  36 {
  37   static const T value = Value;
  38   typedef T ValueType;
  39   typedef IntegralConstant<T, Value> Type;
  40 };
  41
  42 /** Convenient aliases. */
  43 typedef IntegralConstant<bool, true> TrueType;
  44 typedef IntegralConstant<bool, false> FalseType;
  45
  46 /* 20.9.4 Unary type traits [meta.unary] */
  47
  48 /* 20.9.4.1 Primary type categories [meta.unary.cat] */
  49
  50 namespace detail {
  51
  52 template<typename T>
  53 struct IsVoidHelper : FalseType {};
  54
  55 template<>
  56 struct IsVoidHelper<void> : TrueType {};
  57
  58 } // namespace detail
  59
  60 /**
  61  * IsVoid determines whether a type is void.
  62  *
  63  * mozilla::IsVoid<int>::value is false;
  64  * mozilla::IsVoid<void>::value is true;
  65  * mozilla::IsVoid<void*>::value is false;
  66  * mozilla::IsVoid<volatile void>::value is true.
  67  */
  68 template<typename T>
  69 struct IsVoid : detail::IsVoidHelper<typename RemoveCV<T>::Type> {};
  70
  71 namespace detail {
  72
  73 template <typename T>
  74 struct IsIntegralHelper : FalseType {};
  75
  76 template<> struct IsIntegralHelper<char>               : TrueType {};
  77 template<> struct IsIntegralHelper<signed char>        : TrueType {};
  78 template<> struct IsIntegralHelper<unsigned char>      : TrueType {};
  79 template<> struct IsIntegralHelper<short>              : TrueType {};
  80 template<> struct IsIntegralHelper<unsigned short>     : TrueType {};
  81 template<> struct IsIntegralHelper<int>                : TrueType {};
  82 template<> struct IsIntegralHelper<unsigned int>       : TrueType {};
  83 template<> struct IsIntegralHelper<long>               : TrueType {};
  84 template<> struct IsIntegralHelper<unsigned long>      : TrueType {};
  85 template<> struct IsIntegralHelper<long long>          : TrueType {};
  86 template<> struct IsIntegralHelper<unsigned long long> : TrueType {};
  87 template<> struct IsIntegralHelper<bool>               : TrueType {};
  88 template<> struct IsIntegralHelper<wchar_t>            : TrueType {};
  89 #ifdef MOZ_CHAR16_IS_NOT_WCHAR
  90 template<> struct IsIntegralHelper<char16_t>           : TrueType {};
  91 #endif
  92
  93 } /* namespace detail */
  94
  95 /**
  96  * IsIntegral determines whether a type is an integral type.
  97  *
  98  * mozilla::IsIntegral<int>::value is true;
  99  * mozilla::IsIntegral<unsigned short>::value is true;
 100  * mozilla::IsIntegral<const long>::value is true;
 101  * mozilla::IsIntegral<int*>::value is false;
 102  * mozilla::IsIntegral<double>::value is false;
 103  *
 104  * Note that the behavior of IsIntegral on char16_t and char32_t is
 105  * unspecified.
 106  */
 107 template<typename T>
 108 struct IsIntegral : detail::IsIntegralHelper<typename RemoveCV<T>::Type>
 109 {};
 110
 111 template<typename T, typename U>
 112 struct IsSame;
 113
 114 namespace detail {
 115
 116 template<typename T>
 117 struct IsFloatingPointHelper
 118   : IntegralConstant<bool,
 119                      IsSame<T, float>::value ||
 120                      IsSame<T, double>::value ||
 121                      IsSame<T, long double>::value>
 122 {};
 123
 124 } // namespace detail
 125
 126 /**
 127  * IsFloatingPoint determines whether a type is a floating point type (float,
 128  * double, long double).
 129  *
 130  * mozilla::IsFloatingPoint<int>::value is false;
 131  * mozilla::IsFloatingPoint<const float>::value is true;
 132  * mozilla::IsFloatingPoint<long double>::value is true;
 133  * mozilla::IsFloatingPoint<double*>::value is false.
 134  */
 135 template<typename T>
 136 struct IsFloatingPoint
 137   : detail::IsFloatingPointHelper<typename RemoveCV<T>::Type>
 138 {};
 139
 140 namespace detail {
 141
 142 template<typename T>
 143 struct IsArrayHelper : FalseType {};
 144
 145 template<typename T, decltype(sizeof(1)) N>
 146 struct IsArrayHelper<T[N]> : TrueType {};
 147
 148 template<typename T>
 149 struct IsArrayHelper<T[]> : TrueType {};
 150
 151 } // namespace detail
 152
 153 /**
 154  * IsArray determines whether a type is an array type, of known or unknown
 155  * length.
 156  *
 157  * mozilla::IsArray<int>::value is false;
 158  * mozilla::IsArray<int[]>::value is true;
 159  * mozilla::IsArray<int[5]>::value is true.
 160  */
 161 template<typename T>
 162 struct IsArray : detail::IsArrayHelper<typename RemoveCV<T>::Type>
 163 {};
 164
 165 namespace detail {
 166
 167 template<typename T>
 168 struct IsPointerHelper : FalseType {};
 169
 170 template<typename T>
 171 struct IsPointerHelper<T*> : TrueType {};
 172
 173 } // namespace detail
 174
 175 /**
 176  * IsPointer determines whether a type is a possibly-CV-qualified pointer type
 177  * (but not a pointer-to-member type).
 178  *
 179  * mozilla::IsPointer<struct S*>::value is true;
 180  * mozilla::IsPointer<int*>::value is true;
 181  * mozilla::IsPointer<int**>::value is true;
 182  * mozilla::IsPointer<const int*>::value is true;
 183  * mozilla::IsPointer<int* const>::value is true;
 184  * mozilla::IsPointer<int* volatile>::value is true;
 185  * mozilla::IsPointer<void (*)(void)>::value is true;
 186  * mozilla::IsPointer<int>::value is false;
 187  * mozilla::IsPointer<struct S>::value is false.
 188  * mozilla::IsPointer<int(struct S::*)>::value is false
 189  */
 190 template<typename T>
 191 struct IsPointer : detail::IsPointerHelper<typename RemoveCV<T>::Type>
 192 {};
 193
 194 /**
 195  * IsLvalueReference determines whether a type is an lvalue reference.
 196  *
 197  * mozilla::IsLvalueReference<struct S*>::value is false;
 198  * mozilla::IsLvalueReference<int**>::value is false;
 199  * mozilla::IsLvalueReference<void (*)(void)>::value is false;
 200  * mozilla::IsLvalueReference<int>::value is false;
 201  * mozilla::IsLvalueReference<struct S>::value is false;
 202  * mozilla::IsLvalueReference<struct S*&>::value is true;
 203  * mozilla::IsLvalueReference<struct S&&>::value is false.
 204  */
 205 template<typename T>
 206 struct IsLvalueReference : FalseType {};
 207
 208 template<typename T>
 209 struct IsLvalueReference<T&> : TrueType {};
 210
 211 /**
 212  * IsRvalueReference determines whether a type is an rvalue reference.
 213  *
 214  * mozilla::IsRvalueReference<struct S*>::value is false;
 215  * mozilla::IsRvalueReference<int**>::value is false;
 216  * mozilla::IsRvalueReference<void (*)(void)>::value is false;
 217  * mozilla::IsRvalueReference<int>::value is false;
 218  * mozilla::IsRvalueReference<struct S>::value is false;
 219  * mozilla::IsRvalueReference<struct S*&>::value is false;
 220  * mozilla::IsRvalueReference<struct S&&>::value is true.
 221  */
 222 template<typename T>
 223 struct IsRvalueReference : FalseType {};
 224
 225 template<typename T>
 226 struct IsRvalueReference<T&&> : TrueType {};
 227
 228 namespace detail {
 229
 230 // __is_enum is a supported extension across all of our supported compilers.
 231 template<typename T>
 232 struct IsEnumHelper
 233   : IntegralConstant<bool, __is_enum(T)>
 234 {};
 235
 236 } // namespace detail
 237
 238 /**
 239  * IsEnum determines whether a type is an enum type.
 240  *
 241  * mozilla::IsEnum<enum S>::value is true;
 242  * mozilla::IsEnum<enum S*>::value is false;
 243  * mozilla::IsEnum<int>::value is false;
 244  */
 245 template<typename T>
 246 struct IsEnum
 247   : detail::IsEnumHelper<typename RemoveCV<T>::Type>
 248 {};
 249
 250 namespace detail {
 251
 252 // __is_class is a supported extension across all of our supported compilers:
 253 // http://llvm.org/releases/3.0/docs/ClangReleaseNotes.html
 254 // http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/Type-Traits.html#Type-Traits
 255 // http://msdn.microsoft.com/en-us/library/ms177194%28v=vs.100%29.aspx
 256 template<typename T>
 257 struct IsClassHelper
 258   : IntegralConstant<bool, __is_class(T)>
 259 {};
 260
 261 } // namespace detail
 262
 263 /**
 264  * IsClass determines whether a type is a class type (but not a union).
 265  *
 266  * struct S {};
 267  * union U {};
 268  * mozilla::IsClass<int>::value is false;
 269  * mozilla::IsClass<const S>::value is true;
 270  * mozilla::IsClass<U>::value is false;
 271  */
 272 template<typename T>
 273 struct IsClass
 274   : detail::IsClassHelper<typename RemoveCV<T>::Type>
 275 {};
 276
 277 /* 20.9.4.2 Composite type traits [meta.unary.comp] */
 278
 279 /**
 280  * IsReference determines whether a type is an lvalue or rvalue reference.
 281  *
 282  * mozilla::IsReference<struct S*>::value is false;
 283  * mozilla::IsReference<int**>::value is false;
 284  * mozilla::IsReference<int&>::value is true;
 285  * mozilla::IsReference<void (*)(void)>::value is false;
 286  * mozilla::IsReference<const int&>::value is true;
 287  * mozilla::IsReference<int>::value is false;
 288  * mozilla::IsReference<struct S>::value is false;
 289  * mozilla::IsReference<struct S&>::value is true;
 290  * mozilla::IsReference<struct S*&>::value is true;
 291  * mozilla::IsReference<struct S&&>::value is true.
 292  */
 293 template<typename T>
 294 struct IsReference
 295   : IntegralConstant<bool,
 296                      IsLvalueReference<T>::value || IsRvalueReference<T>::value>
 297 {};
 298
 299 /**
 300  * IsArithmetic determines whether a type is arithmetic.  A type is arithmetic
 301  * iff it is an integral type or a floating point type.
 302  *
 303  * mozilla::IsArithmetic<int>::value is true;
 304  * mozilla::IsArithmetic<double>::value is true;
 305  * mozilla::IsArithmetic<long double*>::value is false.
 306  */
 307 template<typename T>
 308 struct IsArithmetic
 309   : IntegralConstant<bool, IsIntegral<T>::value || IsFloatingPoint<T>::value>
 310 {};
 311
 312 /* 20.9.4.3 Type properties [meta.unary.prop] */
 313
 314 /**
 315  * IsConst determines whether a type is const or not.
 316  *
 317  * mozilla::IsConst<int>::value is false;
 318  * mozilla::IsConst<void* const>::value is true;
 319  * mozilla::IsConst<const char*>::value is false.
 320  */
 321 template<typename T>
 322 struct IsConst : FalseType {};
 323
 324 template<typename T>
 325 struct IsConst<const T> : TrueType {};
 326
 327 /**
 328  * IsVolatile determines whether a type is volatile or not.
 329  *
 330  * mozilla::IsVolatile<int>::value is false;
 331  * mozilla::IsVolatile<void* volatile>::value is true;
 332  * mozilla::IsVolatile<volatile char*>::value is false.
 333  */
 334 template<typename T>
 335 struct IsVolatile : FalseType {};
 336
 337 template<typename T>
 338 struct IsVolatile<volatile T> : TrueType {};
 339
 340 /**
 341  * Traits class for identifying POD types.  Until C++11 there's no automatic
 342  * way to detect PODs, so for the moment this is done manually.  Users may
 343  * define specializations of this class that inherit from mozilla::TrueType and
 344  * mozilla::FalseType (or equivalently mozilla::IntegralConstant<bool, true or
 345  * false>, or conveniently from mozilla::IsPod for composite types) as needed to
 346  * ensure correct IsPod behavior.
 347  */
 348 template<typename T>
 349 struct IsPod : public FalseType {};
 350
 351 template<> struct IsPod<char>               : TrueType {};
 352 template<> struct IsPod<signed char>        : TrueType {};
 353 template<> struct IsPod<unsigned char>      : TrueType {};
 354 template<> struct IsPod<short>              : TrueType {};
 355 template<> struct IsPod<unsigned short>     : TrueType {};
 356 template<> struct IsPod<int>                : TrueType {};
 357 template<> struct IsPod<unsigned int>       : TrueType {};
 358 template<> struct IsPod<long>               : TrueType {};
 359 template<> struct IsPod<unsigned long>      : TrueType {};
 360 template<> struct IsPod<long long>          : TrueType {};
 361 template<> struct IsPod<unsigned long long> : TrueType {};
 362 template<> struct IsPod<bool>               : TrueType {};
 363 template<> struct IsPod<float>              : TrueType {};
 364 template<> struct IsPod<double>             : TrueType {};
 365 template<> struct IsPod<wchar_t>            : TrueType {};
 366 #ifdef MOZ_CHAR16_IS_NOT_WCHAR
 367 template<> struct IsPod<char16_t>           : TrueType {};
 368 #endif
 369 template<typename T> struct IsPod<T*>       : TrueType {};
 370
 371 namespace detail {
 372
 373 // __is_empty is a supported extension across all of our supported compilers:
 374 // http://llvm.org/releases/3.0/docs/ClangReleaseNotes.html
 375 // http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/Type-Traits.html#Type-Traits
 376 // http://msdn.microsoft.com/en-us/library/ms177194%28v=vs.100%29.aspx
 377 template<typename T>
 378 struct IsEmptyHelper
 379   : IntegralConstant<bool, IsClass<T>::value && __is_empty(T)>
 380 {};
 381
 382 } // namespace detail
 383
 384 /**
 385  * IsEmpty determines whether a type is a class (but not a union) that is empty.
 386  *
 387  * A class is empty iff it and all its base classes have no non-static data
 388  * members (except bit-fields of length 0) and no virtual member functions, and
 389  * no base class is empty or a virtual base class.
 390  *
 391  * Intuitively, empty classes don't have any data that has to be stored in
 392  * instances of those classes.  (The size of the class must still be non-zero,
 393  * because distinct array elements of any type must have different addresses.
 394  * However, if the Empty Base Optimization is implemented by the compiler [most
 395  * compilers implement it, and in certain cases C++11 requires it], the size of
 396  * a class inheriting from an empty |Base| class need not be inflated by
 397  * |sizeof(Base)|.)  And intuitively, non-empty classes have data members and/or
 398  * vtable pointers that must be stored in each instance for proper behavior.
 399  *
 400  *   static_assert(!mozilla::IsEmpty<int>::value, "not a class => not empty");
 401  *   union U1 { int x; };
 402  *   static_assert(!mozilla::IsEmpty<U1>::value, "not a class => not empty");
 403  *   struct E1 {};
 404  *   struct E2 { int : 0 };
 405  *   struct E3 : E1 {};
 406  *   struct E4 : E2 {};
 407  *   static_assert(mozilla::IsEmpty<E1>::value &&
 408  *                 mozilla::IsEmpty<E2>::value &&
 409  *                 mozilla::IsEmpty<E3>::value &&
 410  *                 mozilla::IsEmpty<E4>::value,
 411  *                 "all empty");
 412  *   union U2 { E1 e1; };
 413  *   static_assert(!mozilla::IsEmpty<U2>::value, "not a class => not empty");
 414  *   struct NE1 { int x; };
 415  *   struct NE2 : virtual E1 {};
 416  *   struct NE3 : E2 { virtual ~NE3() {} };
 417  *   struct NE4 { virtual void f() {} };
 418  *   static_assert(!mozilla::IsEmpty<NE1>::value &&
 419  *                 !mozilla::IsEmpty<NE2>::value &&
 420  *                 !mozilla::IsEmpty<NE3>::value &&
 421  *                 !mozilla::IsEmpty<NE4>::value,
 422  *                 "all empty");
 423  */
 424 template<typename T>
 425 struct IsEmpty : detail::IsEmptyHelper<typename RemoveCV<T>::Type>
 426 {};
 427
 428
 429 namespace detail {
 430
 431 template<typename T,
 432          bool = IsFloatingPoint<T>::value,
 433          bool = IsIntegral<T>::value,
 434          typename NoCV = typename RemoveCV<T>::Type>
 435 struct IsSignedHelper;
 436
 437 // Floating point is signed.
 438 template<typename T, typename NoCV>
 439 struct IsSignedHelper<T, true, false, NoCV> : TrueType {};
 440
 441 // Integral is conditionally signed.
 442 template<typename T, typename NoCV>
 443 struct IsSignedHelper<T, false, true, NoCV>
 444   : IntegralConstant<bool, bool(NoCV(-1) < NoCV(1))>
 445 {};
 446
 447 // Non-floating point, non-integral is not signed.
 448 template<typename T, typename NoCV>
 449 struct IsSignedHelper<T, false, false, NoCV> : FalseType {};
 450
 451 } // namespace detail
 452
 453 /**
 454  * IsSigned determines whether a type is a signed arithmetic type.  |char| is
 455  * considered a signed type if it has the same representation as |signed char|.
 456  *
 457  * mozilla::IsSigned<int>::value is true;
 458  * mozilla::IsSigned<const unsigned int>::value is false;
 459  * mozilla::IsSigned<unsigned char>::value is false;
 460  * mozilla::IsSigned<float>::value is true.
 461  */
 462 template<typename T>
 463 struct IsSigned : detail::IsSignedHelper<T> {};
 464
 465 namespace detail {
 466
 467 template<typename T,
 468          bool = IsFloatingPoint<T>::value,
 469          bool = IsIntegral<T>::value,
 470          typename NoCV = typename RemoveCV<T>::Type>
 471 struct IsUnsignedHelper;
 472
 473 // Floating point is not unsigned.
 474 template<typename T, typename NoCV>
 475 struct IsUnsignedHelper<T, true, false, NoCV> : FalseType {};
 476
 477 // Integral is conditionally unsigned.
 478 template<typename T, typename NoCV>
 479 struct IsUnsignedHelper<T, false, true, NoCV>
 480   : IntegralConstant<bool,
 481                      (IsSame<NoCV, bool>::value || bool(NoCV(1) < NoCV(-1)))>
 482 {};
 483
 484 // Non-floating point, non-integral is not unsigned.
 485 template<typename T, typename NoCV>
 486 struct IsUnsignedHelper<T, false, false, NoCV> : FalseType {};
 487
 488 } // namespace detail
 489
 490 /**
 491  * IsUnsigned determines whether a type is an unsigned arithmetic type.
 492  *
 493  * mozilla::IsUnsigned<int>::value is false;
 494  * mozilla::IsUnsigned<const unsigned int>::value is true;
 495  * mozilla::IsUnsigned<unsigned char>::value is true;
 496  * mozilla::IsUnsigned<float>::value is false.
 497  */
 498 template<typename T>
 499 struct IsUnsigned : detail::IsUnsignedHelper<T> {};
 500
 501 /* 20.9.5 Type property queries [meta.unary.prop.query] */
 502
 503 /* 20.9.6 Relationships between types [meta.rel] */
 504
 505 /**
 506  * IsSame tests whether two types are the same type.
 507  *
 508  * mozilla::IsSame<int, int>::value is true;
 509  * mozilla::IsSame<int*, int*>::value is true;
 510  * mozilla::IsSame<int, unsigned int>::value is false;
 511  * mozilla::IsSame<void, void>::value is true;
 512  * mozilla::IsSame<const int, int>::value is false;
 513  * mozilla::IsSame<struct S, struct S>::value is true.
 514  */
 515 template<typename T, typename U>
 516 struct IsSame : FalseType {};
 517
 518 template<typename T>
 519 struct IsSame<T, T> : TrueType {};
 520
 521 namespace detail {
 522
 523 #if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
 524
 525 template<class Base, class Derived>
 526 struct BaseOfTester : IntegralConstant<bool, __is_base_of(Base, Derived)> {};
 527
 528 #else
 529
 530 // The trickery used to implement IsBaseOf here makes it possible to use it for
 531 // the cases of private and multiple inheritance.  This code was inspired by the
 532 // sample code here:
 533 //
 534 // http://stackoverflow.com/questions/2910979/how-is-base-of-works
 535 template<class Base, class Derived>
 536 struct BaseOfHelper
 537 {
 538 public:
 539   operator Base*() const;
 540   operator Derived*();
 541 };
 542
 543 template<class Base, class Derived>
 544 struct BaseOfTester
 545 {
 546 private:
 547   template<class T>
 548   static char test(Derived*, T);
 549   static int test(Base*, int);
 550
 551 public:
 552   static const bool value =
 553     sizeof(test(BaseOfHelper<Base, Derived>(), int())) == sizeof(char);
 554 };
 555
 556 template<class Base, class Derived>
 557 struct BaseOfTester<Base, const Derived>
 558 {
 559 private:
 560   template<class T>
 561   static char test(Derived*, T);
 562   static int test(Base*, int);
 563
 564 public:
 565   static const bool value =
 566     sizeof(test(BaseOfHelper<Base, Derived>(), int())) == sizeof(char);
 567 };
 568
 569 template<class Base, class Derived>
 570 struct BaseOfTester<Base&, Derived&> : FalseType {};
 571
 572 template<class Type>
 573 struct BaseOfTester<Type, Type> : TrueType {};
 574
 575 template<class Type>
 576 struct BaseOfTester<Type, const Type> : TrueType {};
 577
 578 #endif
 579
 580 } /* namespace detail */
 581
 582 /*
 583  * IsBaseOf allows to know whether a given class is derived from another.
 584  *
 585  * Consider the following class definitions:
 586  *
 587  *   class A {};
 588  *   class B : public A {};
 589  *   class C {};
 590  *
 591  * mozilla::IsBaseOf<A, B>::value is true;
 592  * mozilla::IsBaseOf<A, C>::value is false;
 593  */
 594 template<class Base, class Derived>
 595 struct IsBaseOf
 596   : IntegralConstant<bool, detail::BaseOfTester<Base, Derived>::value>
 597 {};
 598
 599 namespace detail {
 600
 601 template<typename From, typename To>
 602 struct ConvertibleTester
 603 {
 604 private:
 605   static From create();
 606
 607   template<typename From1, typename To1>
 608   static char test(To to);
 609
 610   template<typename From1, typename To1>
 611   static int test(...);
 612
 613 public:
 614   static const bool value =
 615     sizeof(test<From, To>(create())) == sizeof(char);
 616 };
 617
 618 } // namespace detail
 619
 620 /**
 621  * IsConvertible determines whether a value of type From will implicitly convert
 622  * to a value of type To.  For example:
 623  *
 624  *   struct A {};
 625  *   struct B : public A {};
 626  *   struct C {};
 627  *
 628  * mozilla::IsConvertible<A, A>::value is true;
 629  * mozilla::IsConvertible<A*, A*>::value is true;
 630  * mozilla::IsConvertible<B, A>::value is true;
 631  * mozilla::IsConvertible<B*, A*>::value is true;
 632  * mozilla::IsConvertible<C, A>::value is false;
 633  * mozilla::IsConvertible<A, C>::value is false;
 634  * mozilla::IsConvertible<A*, C*>::value is false;
 635  * mozilla::IsConvertible<C*, A*>::value is false.
 636  *
 637  * For obscure reasons, you can't use IsConvertible when the types being tested
 638  * are related through private inheritance, and you'll get a compile error if
 639  * you try.  Just don't do it!
 640  *
 641  * Note - we need special handling for void, which ConvertibleTester doesn't
 642  * handle. The void handling here doesn't handle const/volatile void correctly,
 643  * which could be easily fixed if the need arises.
 644  */
 645 template<typename From, typename To>
 646 struct IsConvertible
 647   : IntegralConstant<bool, detail::ConvertibleTester<From, To>::value>
 648 {};
 649
 650 template<typename B>
 651 struct IsConvertible<void, B>
 652   : IntegralConstant<bool, IsVoid<B>::value>
 653 {};
 654
 655 template<typename A>
 656 struct IsConvertible<A, void>
 657   : IntegralConstant<bool, IsVoid<A>::value>
 658 {};
 659
 660 template<>
 661 struct IsConvertible<void, void>
 662   : TrueType
 663 {};
 664
 665 /* 20.9.7 Transformations between types [meta.trans] */
 666
 667 /* 20.9.7.1 Const-volatile modifications [meta.trans.cv] */
 668
 669 /**
 670  * RemoveConst removes top-level const qualifications on a type.
 671  *
 672  * mozilla::RemoveConst<int>::Type is int;
 673  * mozilla::RemoveConst<const int>::Type is int;
 674  * mozilla::RemoveConst<const int*>::Type is const int*;
 675  * mozilla::RemoveConst<int* const>::Type is int*.
 676  */
 677 template<typename T>
 678 struct RemoveConst
 679 {
 680   typedef T Type;
 681 };
 682
 683 template<typename T>
 684 struct RemoveConst<const T>
 685 {
 686   typedef T Type;
 687 };
 688
 689 /**
 690  * RemoveVolatile removes top-level volatile qualifications on a type.
 691  *
 692  * mozilla::RemoveVolatile<int>::Type is int;
 693  * mozilla::RemoveVolatile<volatile int>::Type is int;
 694  * mozilla::RemoveVolatile<volatile int*>::Type is volatile int*;
 695  * mozilla::RemoveVolatile<int* volatile>::Type is int*.
 696  */
 697 template<typename T>
 698 struct RemoveVolatile
 699 {
 700   typedef T Type;
 701 };
 702
 703 template<typename T>
 704 struct RemoveVolatile<volatile T>
 705 {
 706   typedef T Type;
 707 };
 708
 709 /**
 710  * RemoveCV removes top-level const and volatile qualifications on a type.
 711  *
 712  * mozilla::RemoveCV<int>::Type is int;
 713  * mozilla::RemoveCV<const int>::Type is int;
 714  * mozilla::RemoveCV<volatile int>::Type is int;
 715  * mozilla::RemoveCV<int* const volatile>::Type is int*.
 716  */
 717 template<typename T>
 718 struct RemoveCV
 719 {
 720   typedef typename RemoveConst<typename RemoveVolatile<T>::Type>::Type Type;
 721 };
 722
 723 /* 20.9.7.2 Reference modifications [meta.trans.ref] */
 724
 725 /**
 726  * Converts reference types to the underlying types.
 727  *
 728  * mozilla::RemoveReference<T>::Type is T;
 729  * mozilla::RemoveReference<T&>::Type is T;
 730  * mozilla::RemoveReference<T&&>::Type is T;
 731  */
 732
 733 template<typename T>
 734 struct RemoveReference
 735 {
 736   typedef T Type;
 737 };
 738
 739 template<typename T>
 740 struct RemoveReference<T&>
 741 {
 742   typedef T Type;
 743 };
 744
 745 template<typename T>
 746 struct RemoveReference<T&&>
 747 {
 748   typedef T Type;
 749 };
 750
 751 template<bool Condition, typename A, typename B>
 752 struct Conditional;
 753
 754 namespace detail {
 755
 756 enum Voidness { TIsVoid, TIsNotVoid };
 757
 758 template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
 759 struct AddLvalueReferenceHelper;
 760
 761 template<typename T>
 762 struct AddLvalueReferenceHelper<T, TIsVoid>
 763 {
 764   typedef void Type;
 765 };
 766
 767 template<typename T>
 768 struct AddLvalueReferenceHelper<T, TIsNotVoid>
 769 {
 770   typedef T& Type;
 771 };
 772
 773 } // namespace detail
 774
 775 /**
 776  * AddLvalueReference adds an lvalue & reference to T if one isn't already
 777  * present. (Note: adding an lvalue reference to an rvalue && reference in
 778  * essence replaces the && with a &&, per C+11 reference collapsing rules. For
 779  * example, int&& would become int&.)
 780  *
 781  * The final computed type will only *not* be an lvalue reference if T is void.
 782  *
 783  * mozilla::AddLvalueReference<int>::Type is int&;
 784  * mozilla::AddLvalueRference<volatile int&>::Type is volatile int&;
 785  * mozilla::AddLvalueReference<void*>::Type is void*&;
 786  * mozilla::AddLvalueReference<void>::Type is void;
 787  * mozilla::AddLvalueReference<struct S&&>::Type is struct S&.
 788  */
 789 template<typename T>
 790 struct AddLvalueReference
 791   : detail::AddLvalueReferenceHelper<T>
 792 {};
 793
 794 namespace detail {
 795
 796 template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
 797 struct AddRvalueReferenceHelper;
 798
 799 template<typename T>
 800 struct AddRvalueReferenceHelper<T, TIsVoid>
 801 {
 802   typedef void Type;
 803 };
 804
 805 template<typename T>
 806 struct AddRvalueReferenceHelper<T, TIsNotVoid>
 807 {
 808   typedef T&& Type;
 809 };
 810
 811 } // namespace detail
 812
 813 /**
 814  * AddRvalueReference adds an rvalue && reference to T if one isn't already
 815  * present. (Note: adding an rvalue reference to an lvalue & reference in
 816  * essence keeps the &, per C+11 reference collapsing rules. For example,
 817  * int& would remain int&.)
 818  *
 819  * The final computed type will only *not* be a reference if T is void.
 820  *
 821  * mozilla::AddRvalueReference<int>::Type is int&&;
 822  * mozilla::AddRvalueRference<volatile int&>::Type is volatile int&;
 823  * mozilla::AddRvalueRference<const int&&>::Type is const int&&;
 824  * mozilla::AddRvalueReference<void*>::Type is void*&&;
 825  * mozilla::AddRvalueReference<void>::Type is void;
 826  * mozilla::AddRvalueReference<struct S&>::Type is struct S&.
 827  */
 828 template<typename T>
 829 struct AddRvalueReference
 830   : detail::AddRvalueReferenceHelper<T>
 831 {};
 832
 833 /* 20.2.4 Function template declval [declval] */
 834
 835 /**
 836  * DeclVal simplifies the definition of expressions which occur as unevaluated
 837  * operands. It converts T to a reference type, making it possible to use in
 838  * decltype expressions even if T does not have a default constructor, e.g.:
 839  * decltype(DeclVal<TWithNoDefaultConstructor>().foo())
 840  */
 841 template<typename T>
 842 typename AddRvalueReference<T>::Type DeclVal();
 843
 844 /* 20.9.7.3 Sign modifications [meta.trans.sign] */
 845
 846 template<bool B, typename T = void>
 847 struct EnableIf;
 848
 849 namespace detail {
 850
 851 template<bool MakeConst, typename T>
 852 struct WithC : Conditional<MakeConst, const T, T>
 853 {};
 854
 855 template<bool MakeVolatile, typename T>
 856 struct WithV : Conditional<MakeVolatile, volatile T, T>
 857 {};
 858
 859
 860 template<bool MakeConst, bool MakeVolatile, typename T>
 861 struct WithCV : WithC<MakeConst, typename WithV<MakeVolatile, T>::Type>
 862 {};
 863
 864 template<typename T>
 865 struct CorrespondingSigned;
 866
 867 template<>
 868 struct CorrespondingSigned<char> { typedef signed char Type; };
 869 template<>
 870 struct CorrespondingSigned<unsigned char> { typedef signed char Type; };
 871 template<>
 872 struct CorrespondingSigned<unsigned short> { typedef short Type; };
 873 template<>
 874 struct CorrespondingSigned<unsigned int> { typedef int Type; };
 875 template<>
 876 struct CorrespondingSigned<unsigned long> { typedef long Type; };
 877 template<>
 878 struct CorrespondingSigned<unsigned long long> { typedef long long Type; };
 879
 880 template<typename T,
 881          typename CVRemoved = typename RemoveCV<T>::Type,
 882          bool IsSignedIntegerType = IsSigned<CVRemoved>::value &&
 883                                     !IsSame<char, CVRemoved>::value>
 884 struct MakeSigned;
 885
 886 template<typename T, typename CVRemoved>
 887 struct MakeSigned<T, CVRemoved, true>
 888 {
 889   typedef T Type;
 890 };
 891
 892 template<typename T, typename CVRemoved>
 893 struct MakeSigned<T, CVRemoved, false>
 894   : WithCV<IsConst<T>::value, IsVolatile<T>::value,
 895            typename CorrespondingSigned<CVRemoved>::Type>
 896 {};
 897
 898 } // namespace detail
 899
 900 /**
 901  * MakeSigned produces the corresponding signed integer type for a given
 902  * integral type T, with the const/volatile qualifiers of T.  T must be a
 903  * possibly-const/volatile-qualified integral type that isn't bool.
 904  *
 905  * If T is already a signed integer type (not including char!), then T is
 906  * produced.
 907  *
 908  * Otherwise, if T is an unsigned integer type, the signed variety of T, with
 909  * T's const/volatile qualifiers, is produced.
 910  *
 911  * Otherwise, the integral type of the same size as T, with the lowest rank,
 912  * with T's const/volatile qualifiers, is produced.  (This basically only acts
 913  * to produce signed char when T = char.)
 914  *
 915  * mozilla::MakeSigned<unsigned long>::Type is signed long;
 916  * mozilla::MakeSigned<volatile int>::Type is volatile int;
 917  * mozilla::MakeSigned<const unsigned short>::Type is const signed short;
 918  * mozilla::MakeSigned<const char>::Type is const signed char;
 919  * mozilla::MakeSigned<bool> is an error;
 920  * mozilla::MakeSigned<void*> is an error.
 921  */
 922 template<typename T>
 923 struct MakeSigned
 924   : EnableIf<IsIntegral<T>::value &&
 925              !IsSame<bool, typename RemoveCV<T>::Type>::value,
 926              typename detail::MakeSigned<T>
 927             >::Type
 928 {};
 929
 930 namespace detail {
 931
 932 template<typename T>
 933 struct CorrespondingUnsigned;
 934
 935 template<>
 936 struct CorrespondingUnsigned<char> { typedef unsigned char Type; };
 937 template<>
 938 struct CorrespondingUnsigned<signed char> { typedef unsigned char Type; };
 939 template<>
 940 struct CorrespondingUnsigned<short> { typedef unsigned short Type; };
 941 template<>
 942 struct CorrespondingUnsigned<int> { typedef unsigned int Type; };
 943 template<>
 944 struct CorrespondingUnsigned<long> { typedef unsigned long Type; };
 945 template<>
 946 struct CorrespondingUnsigned<long long> { typedef unsigned long long Type; };
 947
 948
 949 template<typename T,
 950          typename CVRemoved = typename RemoveCV<T>::Type,
 951          bool IsUnsignedIntegerType = IsUnsigned<CVRemoved>::value &&
 952                                       !IsSame<char, CVRemoved>::value>
 953 struct MakeUnsigned;
 954
 955 template<typename T, typename CVRemoved>
 956 struct MakeUnsigned<T, CVRemoved, true>
 957 {
 958   typedef T Type;
 959 };
 960
 961 template<typename T, typename CVRemoved>
 962 struct MakeUnsigned<T, CVRemoved, false>
 963   : WithCV<IsConst<T>::value, IsVolatile<T>::value,
 964            typename CorrespondingUnsigned<CVRemoved>::Type>
 965 {};
 966
 967 } // namespace detail
 968
 969 /**
 970  * MakeUnsigned produces the corresponding unsigned integer type for a given
 971  * integral type T, with the const/volatile qualifiers of T.  T must be a
 972  * possibly-const/volatile-qualified integral type that isn't bool.
 973  *
 974  * If T is already an unsigned integer type (not including char!), then T is
 975  * produced.
 976  *
 977  * Otherwise, if T is a signed integer type, the unsigned variety of T, with
 978  * T's const/volatile qualifiers, is produced.
 979  *
 980  * Otherwise, the unsigned integral type of the same size as T, with the lowest
 981  * rank, with T's const/volatile qualifiers, is produced.  (This basically only
 982  * acts to produce unsigned char when T = char.)
 983  *
 984  * mozilla::MakeUnsigned<signed long>::Type is unsigned long;
 985  * mozilla::MakeUnsigned<volatile unsigned int>::Type is volatile unsigned int;
 986  * mozilla::MakeUnsigned<const signed short>::Type is const unsigned short;
 987  * mozilla::MakeUnsigned<const char>::Type is const unsigned char;
 988  * mozilla::MakeUnsigned<bool> is an error;
 989  * mozilla::MakeUnsigned<void*> is an error.
 990  */
 991 template<typename T>
 992 struct MakeUnsigned
 993   : EnableIf<IsIntegral<T>::value &&
 994              !IsSame<bool, typename RemoveCV<T>::Type>::value,
 995              typename detail::MakeUnsigned<T>
 996             >::Type
 997 {};
 998
 999 /* 20.9.7.4 Array modifications [meta.trans.arr] */
1000
1001 /**
1002  * RemoveExtent produces either the type of the elements of the array T, or T
1003  * itself.
1004  *
1005  * mozilla::RemoveExtent<int>::Type is int;
1006  * mozilla::RemoveExtent<const int[]>::Type is const int;
1007  * mozilla::RemoveExtent<volatile int[5]>::Type is volatile int;
1008  * mozilla::RemoveExtent<long[][17]>::Type is long[17].
1009  */
1010 template<typename T>
1011 struct RemoveExtent
1012 {
1013   typedef T Type;
1014 };
1015
1016 template<typename T>
1017 struct RemoveExtent<T[]>
1018 {
1019   typedef T Type;
1020 };
1021
1022 template<typename T, decltype(sizeof(1)) N>
1023 struct RemoveExtent<T[N]>
1024 {
1025   typedef T Type;
1026 };
1027
1028 /* 20.9.7.5 Pointer modifications [meta.trans.ptr] */
1029
1030 namespace detail {
1031
1032 template<typename T, typename CVRemoved>
1033 struct RemovePointerHelper
1034 {
1035   typedef T Type;
1036 };
1037
1038 template<typename T, typename Pointee>
1039 struct RemovePointerHelper<T, Pointee*>
1040 {
1041   typedef Pointee Type;
1042 };
1043
1044 } // namespace detail
1045
1046 /**
1047  * Produces the pointed-to type if a pointer is provided, else returns the input
1048  * type.  Note that this does not dereference pointer-to-member pointers.
1049  *
1050  * struct S { bool m; void f(); };
1051  * mozilla::RemovePointer<int>::Type is int;
1052  * mozilla::RemovePointer<int*>::Type is int;
1053  * mozilla::RemovePointer<int* const>::Type is int;
1054  * mozilla::RemovePointer<int* volatile>::Type is int;
1055  * mozilla::RemovePointer<const long*>::Type is const long;
1056  * mozilla::RemovePointer<void* const>::Type is void;
1057  * mozilla::RemovePointer<void (S::*)()>::Type is void (S::*)();
1058  * mozilla::RemovePointer<void (*)()>::Type is void();
1059  * mozilla::RemovePointer<bool S::*>::Type is bool S::*.
1060  */
1061 template<typename T>
1062 struct RemovePointer
1063   : detail::RemovePointerHelper<T, typename RemoveCV<T>::Type>
1064 {};
1065
1066 /* 20.9.7.6 Other transformations [meta.trans.other] */
1067
1068 /**
1069  * EnableIf is a struct containing a typedef of T if and only if B is true.
1070  *
1071  * mozilla::EnableIf<true, int>::Type is int;
1072  * mozilla::EnableIf<false, int>::Type is a compile-time error.
1073  *
1074  * Use this template to implement SFINAE-style (Substitution Failure Is not An
1075  * Error) requirements.  For example, you might use it to impose a restriction
1076  * on a template parameter:
1077  *
1078  *   template<typename T>
1079  *   class PodVector // vector optimized to store POD (memcpy-able) types
1080  *   {
1081  *      EnableIf<IsPod<T>::value, T>::Type* vector;
1082  *      size_t length;
1083  *      ...
1084  *   };
1085  */
1086 template<bool B, typename T>
1087 struct EnableIf
1088 {};
1089
1090 template<typename T>
1091 struct EnableIf<true, T>
1092 {
1093   typedef T Type;
1094 };
1095
1096 /**
1097  * Conditional selects a class between two, depending on a given boolean value.
1098  *
1099  * mozilla::Conditional<true, A, B>::Type is A;
1100  * mozilla::Conditional<false, A, B>::Type is B;
1101  */
1102 template<bool Condition, typename A, typename B>
1103 struct Conditional
1104 {
1105   typedef A Type;
1106 };
1107
1108 template<class A, class B>
1109 struct Conditional<false, A, B>
1110 {
1111   typedef B Type;
1112 };
1113
1114 } /* namespace mozilla */
1115
1116 #endif /* mozilla_TypeTraits_h */