1 /* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 * 7 * 8 * This header provides some of the helpers (std::integral_constant) and 9 * type transformations (std::conditional) which will become available with 10 * C++11 in the type_traits header. 11 * 12 * Because we lack constexpr, we cannot mimic 13 * std::integral_constant::'constexpr operator T()'. 14 * As a result we introduce SkTBool and SkTIf similar to Boost in order to 15 * minimize the visual noise of many uses of '::value'. 16 */ 17 18 #ifndef SkTLogic_DEFINED 19 #define SkTLogic_DEFINED 20 21 /** Represents a templated integer constant. 22 * Pre-C++11 version of std::integral_constant. 23 */ 24 template <typename T, T v> struct SkTIntegralConstant { 25 static const T value = v; 26 typedef T value_type; 27 typedef SkTIntegralConstant<T, v> type; 28 }; 29 30 /** Convenience specialization of SkTIntegralConstant. */ 31 template <bool b> struct SkTBool : SkTIntegralConstant<bool, b> { }; 32 33 /** Pre-C++11 version of std::is_empty<T>. */ 34 template <typename T> 35 class SkTIsEmpty { 36 struct Derived : public T { char unused; }; 37 public: 38 static const bool value = sizeof(Derived) == sizeof(char); 39 }; 40 41 /** Pre-C++11 version of std::true_type. */ 42 typedef SkTBool<true> SkTrue; 43 44 /** Pre-C++11 version of std::false_type. */ 45 typedef SkTBool<false> SkFalse; 46 47 /** SkTIf_c::type = (condition) ? T : F; 48 * Pre-C++11 version of std::conditional. 49 */ 50 template <bool condition, typename T, typename F> struct SkTIf_c { 51 typedef F type; 52 }; 53 template <typename T, typename F> struct SkTIf_c<true, T, F> { 54 typedef T type; 55 }; 56 57 /** SkTIf::type = (Condition::value) ? T : F; */ 58 template <typename Condition, typename T, typename F> struct SkTIf { 59 typedef typename SkTIf_c<static_cast<bool>(Condition::value), T, F>::type type; 60 }; 61 62 /** SkTMux::type = (a && b) ? Both : (a) ? A : (b) ? B : Neither; */ 63 template <typename a, typename b, typename Both, typename A, typename B, typename Neither> 64 struct SkTMux { 65 typedef typename SkTIf<a, typename SkTIf<b, Both, A>::type, 66 typename SkTIf<b, B, Neither>::type>::type type; 67 }; 68 69 /** SkTEnableIf_c::type = (condition) ? T : [does not exist]; */ 70 template <bool condition, class T = void> struct SkTEnableIf_c { }; 71 template <class T> struct SkTEnableIf_c<true, T> { 72 typedef T type; 73 }; 74 75 /** SkTEnableIf::type = (Condition::value) ? T : [does not exist]; */ 76 template <class Condition, class T = void> struct SkTEnableIf 77 : public SkTEnableIf_c<static_cast<bool>(Condition::value), T> { }; 78 79 /** Use as a return type to enable a function only when cond_type::value is true, 80 * like C++14's std::enable_if_t. E.g. (N.B. this is a dumb example.) 81 * SK_WHEN(SkTrue, int) f(void* ptr) { return 1; } 82 * SK_WHEN(!SkTrue, int) f(void* ptr) { return 2; } 83 */ 84 #define SK_WHEN(cond_prefix, T) typename SkTEnableIf_c<cond_prefix::value, T>::type 85 #define SK_WHEN_C(cond, T) typename SkTEnableIf_c<cond, T>::type 86 87 // See http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector 88 #define SK_CREATE_MEMBER_DETECTOR(member) \ 89 template <typename T> \ 90 class HasMember_##member { \ 91 struct Fallback { int member; }; \ 92 struct Derived : T, Fallback {}; \ 93 template <typename U, U> struct Check; \ 94 template <typename U> static uint8_t func(Check<int Fallback::*, &U::member>*); \ 95 template <typename U> static uint16_t func(...); \ 96 public: \ 97 typedef HasMember_##member type; \ 98 static const bool value = sizeof(func<Derived>(NULL)) == sizeof(uint16_t); \ 99 } 100 101 // Same sort of thing as SK_CREATE_MEMBER_DETECTOR, but checks for the existence of a nested type. 102 #define SK_CREATE_TYPE_DETECTOR(type) \ 103 template <typename T> \ 104 class HasType_##type { \ 105 template <typename U> static uint8_t func(typename U::type*); \ 106 template <typename U> static uint16_t func(...); \ 107 public: \ 108 static const bool value = sizeof(func<T>(NULL)) == sizeof(uint8_t); \ 109 } 110 111 #endif 112