TypeTraits.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
/* Template-based metaprogramming and type-testing facilities. */
 
#ifndef mozilla_TypeTraits_h
#define mozilla_TypeTraits_h
 
#include "Types.h"
 
/*
 * These traits are approximate copies of the traits and semantics from C++11's
 * <type_traits> header.  Don't add traits not in that header!  When all
 * platforms provide that header, we can convert all users and remove this one.
 */
 
#include <wchar.h>
 
namespace mozilla {
 
/* Forward declarations. */
 
template<typename> struct RemoveCV;
 
/* 20.9.3 Helper classes [meta.help] */
 
template<typename T, T Value>
struct IntegralConstant
{
  static const T value = Value;
  typedef T ValueType;
  typedef IntegralConstant<T, Value> Type;
};
 
typedef IntegralConstant<bool, true> TrueType;
typedef IntegralConstant<bool, false> FalseType;
 
/* 20.9.4 Unary type traits [meta.unary] */
 
/* 20.9.4.1 Primary type categories [meta.unary.cat] */
 
namespace detail {
 
template<typename T>
struct IsVoidHelper : FalseType {};
 
template<>
struct IsVoidHelper<void> : TrueType {};
 
} // namespace detail
 
template<typename T>
struct IsVoid : detail::IsVoidHelper<typename RemoveCV<T>::Type> {};
 
namespace detail {
 
template <typename T>
struct IsIntegralHelper : FalseType {};
 
template<> struct IsIntegralHelper<char>               : TrueType {};
template<> struct IsIntegralHelper<signed char>        : TrueType {};
template<> struct IsIntegralHelper<unsigned char>      : TrueType {};
template<> struct IsIntegralHelper<short>              : TrueType {};
template<> struct IsIntegralHelper<unsigned short>     : TrueType {};
template<> struct IsIntegralHelper<int>                : TrueType {};
template<> struct IsIntegralHelper<unsigned int>       : TrueType {};
template<> struct IsIntegralHelper<long>               : TrueType {};
template<> struct IsIntegralHelper<unsigned long>      : TrueType {};
template<> struct IsIntegralHelper<long long>          : TrueType {};
template<> struct IsIntegralHelper<unsigned long long> : TrueType {};
template<> struct IsIntegralHelper<bool>               : TrueType {};
template<> struct IsIntegralHelper<wchar_t>            : TrueType {};
#ifdef MOZ_CHAR16_IS_NOT_WCHAR
template<> struct IsIntegralHelper<char16_t>           : TrueType {};
#endif
 
} /* namespace detail */
 
template<typename T>
struct IsIntegral : detail::IsIntegralHelper<typename RemoveCV<T>::Type>
{};
 
template<typename T, typename U>
struct IsSame;
 
namespace detail {
 
template<typename T>
struct IsFloatingPointHelper
  : IntegralConstant<bool,
                     IsSame<T, float>::value ||
                     IsSame<T, double>::value ||
                     IsSame<T, long double>::value>
{};
 
} // namespace detail
 
template<typename T>
struct IsFloatingPoint
  : detail::IsFloatingPointHelper<typename RemoveCV<T>::Type>
{};
 
namespace detail {
 
template<typename T>
struct IsArrayHelper : FalseType {};
 
template<typename T, decltype(sizeof(1)) N>
struct IsArrayHelper<T[N]> : TrueType {};
 
template<typename T>
struct IsArrayHelper<T[]> : TrueType {};
 
} // namespace detail
 
template<typename T>
struct IsArray : detail::IsArrayHelper<typename RemoveCV<T>::Type>
{};
 
namespace detail {
 
template<typename T>
struct IsPointerHelper : FalseType {};
 
template<typename T>
struct IsPointerHelper<T*> : TrueType {};
 
} // namespace detail
 
template<typename T>
struct IsPointer : detail::IsPointerHelper<typename RemoveCV<T>::Type>
{};
 
template<typename T>
struct IsLvalueReference : FalseType {};
 
template<typename T>
struct IsLvalueReference<T&> : TrueType {};
 
template<typename T>
struct IsRvalueReference : FalseType {};
 
template<typename T>
struct IsRvalueReference<T&&> : TrueType {};
 
namespace detail {
 
// __is_enum is a supported extension across all of our supported compilers.
template<typename T>
struct IsEnumHelper
  : IntegralConstant<bool, __is_enum(T)>
{};
 
} // namespace detail
 
template<typename T>
struct IsEnum
  : detail::IsEnumHelper<typename RemoveCV<T>::Type>
{};
 
namespace detail {
 
// __is_class is a supported extension across all of our supported compilers:
// http://llvm.org/releases/3.0/docs/ClangReleaseNotes.html
// http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/Type-Traits.html#Type-Traits
// http://msdn.microsoft.com/en-us/library/ms177194%28v=vs.100%29.aspx
template<typename T>
struct IsClassHelper
  : IntegralConstant<bool, __is_class(T)>
{};
 
} // namespace detail
 
template<typename T>
struct IsClass
  : detail::IsClassHelper<typename RemoveCV<T>::Type>
{};
 
/* 20.9.4.2 Composite type traits [meta.unary.comp] */
 
template<typename T>
struct IsReference
  : IntegralConstant<bool,
                     IsLvalueReference<T>::value || IsRvalueReference<T>::value>
{};
 
template<typename T>
struct IsArithmetic
  : IntegralConstant<bool, IsIntegral<T>::value || IsFloatingPoint<T>::value>
{};
 
/* 20.9.4.3 Type properties [meta.unary.prop] */
 
template<typename T>
struct IsConst : FalseType {};
 
template<typename T>
struct IsConst<const T> : TrueType {};
 
template<typename T>
struct IsVolatile : FalseType {};
 
template<typename T>
struct IsVolatile<volatile T> : TrueType {};
 
template<typename T>
struct IsPod : public FalseType {};
 
template<> struct IsPod<char>               : TrueType {};
template<> struct IsPod<signed char>        : TrueType {};
template<> struct IsPod<unsigned char>      : TrueType {};
template<> struct IsPod<short>              : TrueType {};
template<> struct IsPod<unsigned short>     : TrueType {};
template<> struct IsPod<int>                : TrueType {};
template<> struct IsPod<unsigned int>       : TrueType {};
template<> struct IsPod<long>               : TrueType {};
template<> struct IsPod<unsigned long>      : TrueType {};
template<> struct IsPod<long long>          : TrueType {};
template<> struct IsPod<unsigned long long> : TrueType {};
template<> struct IsPod<bool>               : TrueType {};
template<> struct IsPod<float>              : TrueType {};
template<> struct IsPod<double>             : TrueType {};
template<> struct IsPod<wchar_t>            : TrueType {};
#ifdef MOZ_CHAR16_IS_NOT_WCHAR
template<> struct IsPod<char16_t>           : TrueType {};
#endif
template<typename T> struct IsPod<T*>       : TrueType {};
 
namespace detail {
 
// __is_empty is a supported extension across all of our supported compilers:
// http://llvm.org/releases/3.0/docs/ClangReleaseNotes.html
// http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/Type-Traits.html#Type-Traits
// http://msdn.microsoft.com/en-us/library/ms177194%28v=vs.100%29.aspx
template<typename T>
struct IsEmptyHelper
  : IntegralConstant<bool, IsClass<T>::value && __is_empty(T)>
{};
 
} // namespace detail
 
template<typename T>
struct IsEmpty : detail::IsEmptyHelper<typename RemoveCV<T>::Type>
{};
 
 
namespace detail {
 
template<typename T,
         bool = IsFloatingPoint<T>::value,
         bool = IsIntegral<T>::value,
         typename NoCV = typename RemoveCV<T>::Type>
struct IsSignedHelper;
 
// Floating point is signed.
template<typename T, typename NoCV>
struct IsSignedHelper<T, true, false, NoCV> : TrueType {};
 
// Integral is conditionally signed.
template<typename T, typename NoCV>
struct IsSignedHelper<T, false, true, NoCV>
  : IntegralConstant<bool, bool(NoCV(-1) < NoCV(1))>
{};
 
// Non-floating point, non-integral is not signed.
template<typename T, typename NoCV>
struct IsSignedHelper<T, false, false, NoCV> : FalseType {};
 
} // namespace detail
 
template<typename T>
struct IsSigned : detail::IsSignedHelper<T> {};
 
namespace detail {
 
template<typename T,
         bool = IsFloatingPoint<T>::value,
         bool = IsIntegral<T>::value,
         typename NoCV = typename RemoveCV<T>::Type>
struct IsUnsignedHelper;
 
// Floating point is not unsigned.
template<typename T, typename NoCV>
struct IsUnsignedHelper<T, true, false, NoCV> : FalseType {};
 
// Integral is conditionally unsigned.
template<typename T, typename NoCV>
struct IsUnsignedHelper<T, false, true, NoCV>
  : IntegralConstant<bool,
                     (IsSame<NoCV, bool>::value || bool(NoCV(1) < NoCV(-1)))>
{};
 
// Non-floating point, non-integral is not unsigned.
template<typename T, typename NoCV>
struct IsUnsignedHelper<T, false, false, NoCV> : FalseType {};
 
} // namespace detail
 
template<typename T>
struct IsUnsigned : detail::IsUnsignedHelper<T> {};
 
/* 20.9.5 Type property queries [meta.unary.prop.query] */
 
/* 20.9.6 Relationships between types [meta.rel] */
 
template<typename T, typename U>
struct IsSame : FalseType {};
 
template<typename T>
struct IsSame<T, T> : TrueType {};
 
namespace detail {
 
#if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
 
template<class Base, class Derived>
struct BaseOfTester : IntegralConstant<bool, __is_base_of(Base, Derived)> {};
 
#else
 
// The trickery used to implement IsBaseOf here makes it possible to use it for
// the cases of private and multiple inheritance.  This code was inspired by the
// sample code here:
//
// http://stackoverflow.com/questions/2910979/how-is-base-of-works
template<class Base, class Derived>
struct BaseOfHelper
{
public:
  operator Base*() const;
  operator Derived*();
};
 
template<class Base, class Derived>
struct BaseOfTester
{
private:
  template<class T>
  static char test(Derived*, T);
  static int test(Base*, int);
 
public:
  static const bool value =
    sizeof(test(BaseOfHelper<Base, Derived>(), int())) == sizeof(char);
};
 
template<class Base, class Derived>
struct BaseOfTester<Base, const Derived>
{
private:
  template<class T>
  static char test(Derived*, T);
  static int test(Base*, int);
 
public:
  static const bool value =
    sizeof(test(BaseOfHelper<Base, Derived>(), int())) == sizeof(char);
};
 
template<class Base, class Derived>
struct BaseOfTester<Base&, Derived&> : FalseType {};
 
template<class Type>
struct BaseOfTester<Type, Type> : TrueType {};
 
template<class Type>
struct BaseOfTester<Type, const Type> : TrueType {};
 
#endif
 
} /* namespace detail */
 
/*
 * IsBaseOf allows to know whether a given class is derived from another.
 *
 * Consider the following class definitions:
 *
 *   class A {};
 *   class B : public A {};
 *   class C {};
 *
 * mozilla::IsBaseOf<A, B>::value is true;
 * mozilla::IsBaseOf<A, C>::value is false;
 */
template<class Base, class Derived>
struct IsBaseOf
  : IntegralConstant<bool, detail::BaseOfTester<Base, Derived>::value>
{};
 
namespace detail {
 
template<typename From, typename To>
struct ConvertibleTester
{
private:
  static From create();
 
  template<typename From1, typename To1>
  static char test(To to);
 
  template<typename From1, typename To1>
  static int test(...);
 
public:
  static const bool value =
    sizeof(test<From, To>(create())) == sizeof(char);
};
 
} // namespace detail
 
template<typename From, typename To>
struct IsConvertible
  : IntegralConstant<bool, detail::ConvertibleTester<From, To>::value>
{};
 
template<typename B>
struct IsConvertible<void, B>
  : IntegralConstant<bool, IsVoid<B>::value>
{};
 
template<typename A>
struct IsConvertible<A, void>
  : IntegralConstant<bool, IsVoid<A>::value>
{};
 
template<>
struct IsConvertible<void, void>
  : TrueType
{};
 
/* 20.9.7 Transformations between types [meta.trans] */
 
/* 20.9.7.1 Const-volatile modifications [meta.trans.cv] */
 
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 RemoveCV
{
  typedef typename RemoveConst<typename RemoveVolatile<T>::Type>::Type Type;
};
 
/* 20.9.7.2 Reference modifications [meta.trans.ref] */
 
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<bool Condition, typename A, typename B>
struct Conditional;
 
namespace detail {
 
enum Voidness { TIsVoid, TIsNotVoid };
 
template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
struct AddLvalueReferenceHelper;
 
template<typename T>
struct AddLvalueReferenceHelper<T, TIsVoid>
{
  typedef void Type;
};
 
template<typename T>
struct AddLvalueReferenceHelper<T, TIsNotVoid>
{
  typedef T& Type;
};
 
} // namespace detail
 
template<typename T>
struct AddLvalueReference
  : detail::AddLvalueReferenceHelper<T>
{};
 
namespace detail {
 
template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
struct AddRvalueReferenceHelper;
 
template<typename T>
struct AddRvalueReferenceHelper<T, TIsVoid>
{
  typedef void Type;
};
 
template<typename T>
struct AddRvalueReferenceHelper<T, TIsNotVoid>
{
  typedef T&& Type;
};
 
} // namespace detail
 
template<typename T>
struct AddRvalueReference
  : detail::AddRvalueReferenceHelper<T>
{};
 
/* 20.2.4 Function template declval [declval] */
 
template<typename T>
typename AddRvalueReference<T>::Type DeclVal();
 
/* 20.9.7.3 Sign modifications [meta.trans.sign] */
 
template<bool B, typename T = void>
struct EnableIf;
 
namespace detail {
 
template<bool MakeConst, typename T>
struct WithC : Conditional<MakeConst, const T, T>
{};
 
template<bool MakeVolatile, typename T>
struct WithV : Conditional<MakeVolatile, volatile T, T>
{};
 
 
template<bool MakeConst, bool MakeVolatile, typename T>
struct WithCV : WithC<MakeConst, typename WithV<MakeVolatile, T>::Type>
{};
 
template<typename T>
struct CorrespondingSigned;
 
template<>
struct CorrespondingSigned<char> { typedef signed char Type; };
template<>
struct CorrespondingSigned<unsigned char> { typedef signed char Type; };
template<>
struct CorrespondingSigned<unsigned short> { typedef short Type; };
template<>
struct CorrespondingSigned<unsigned int> { typedef int Type; };
template<>
struct CorrespondingSigned<unsigned long> { typedef long Type; };
template<>
struct CorrespondingSigned<unsigned long long> { typedef long long Type; };
 
template<typename T,
         typename CVRemoved = typename RemoveCV<T>::Type,
         bool IsSignedIntegerType = IsSigned<CVRemoved>::value &&
                                    !IsSame<char, CVRemoved>::value>
struct MakeSigned;
 
template<typename T, typename CVRemoved>
struct MakeSigned<T, CVRemoved, true>
{
  typedef T Type;
};
 
template<typename T, typename CVRemoved>
struct MakeSigned<T, CVRemoved, false>
  : WithCV<IsConst<T>::value, IsVolatile<T>::value,
           typename CorrespondingSigned<CVRemoved>::Type>
{};
 
} // namespace detail
 
template<typename T>
struct MakeSigned
  : EnableIf<IsIntegral<T>::value &&
             !IsSame<bool, typename RemoveCV<T>::Type>::value,
             typename detail::MakeSigned<T>
            >::Type
{};
 
namespace detail {
 
template<typename T>
struct CorrespondingUnsigned;
 
template<>
struct CorrespondingUnsigned<char> { typedef unsigned char Type; };
template<>
struct CorrespondingUnsigned<signed char> { typedef unsigned char Type; };
template<>
struct CorrespondingUnsigned<short> { typedef unsigned short Type; };
template<>
struct CorrespondingUnsigned<int> { typedef unsigned int Type; };
template<>
struct CorrespondingUnsigned<long> { typedef unsigned long Type; };
template<>
struct CorrespondingUnsigned<long long> { typedef unsigned long long Type; };
 
 
template<typename T,
         typename CVRemoved = typename RemoveCV<T>::Type,
         bool IsUnsignedIntegerType = IsUnsigned<CVRemoved>::value &&
                                      !IsSame<char, CVRemoved>::value>
struct MakeUnsigned;
 
template<typename T, typename CVRemoved>
struct MakeUnsigned<T, CVRemoved, true>
{
  typedef T Type;
};
 
template<typename T, typename CVRemoved>
struct MakeUnsigned<T, CVRemoved, false>
  : WithCV<IsConst<T>::value, IsVolatile<T>::value,
           typename CorrespondingUnsigned<CVRemoved>::Type>
{};
 
} // namespace detail
 
template<typename T>
struct MakeUnsigned
  : EnableIf<IsIntegral<T>::value &&
             !IsSame<bool, typename RemoveCV<T>::Type>::value,
             typename detail::MakeUnsigned<T>
            >::Type
{};
 
/* 20.9.7.4 Array modifications [meta.trans.arr] */
 
template<typename T>
struct RemoveExtent
{
  typedef T Type;
};
 
template<typename T>
struct RemoveExtent<T[]>
{
  typedef T Type;
};
 
template<typename T, decltype(sizeof(1)) N>
struct RemoveExtent<T[N]>
{
  typedef T Type;
};
 
/* 20.9.7.5 Pointer modifications [meta.trans.ptr] */
 
namespace detail {
 
template<typename T, typename CVRemoved>
struct RemovePointerHelper
{
  typedef T Type;
};
 
template<typename T, typename Pointee>
struct RemovePointerHelper<T, Pointee*>
{
  typedef Pointee Type;
};
 
} // namespace detail
 
template<typename T>
struct RemovePointer
  : detail::RemovePointerHelper<T, typename RemoveCV<T>::Type>
{};
 
/* 20.9.7.6 Other transformations [meta.trans.other] */
 
template<bool B, typename T>
struct EnableIf
{};
 
template<typename T>
struct EnableIf<true, T>
{
  typedef T Type;
};
 
template<bool Condition, typename A, typename B>
struct Conditional
{
  typedef A Type;
};
 
template<class A, class B>
struct Conditional<false, A, B>
{
  typedef B Type;
};
 
} /* namespace mozilla */
 
#endif /* mozilla_TypeTraits_h */