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 */ 24template <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. */ 31template <bool b> struct SkTBool : SkTIntegralConstant<bool, b> { }; 32 33/** Pre-C++11 version of std::is_empty<T>. */ 34template <typename T> 35class SkTIsEmpty { 36 struct Derived : public T { char unused; }; 37public: 38 static const bool value = sizeof(Derived) == sizeof(char); 39}; 40 41/** Pre-C++11 version of std::true_type. */ 42typedef SkTBool<true> SkTrue; 43 44/** Pre-C++11 version of std::false_type. */ 45typedef SkTBool<false> SkFalse; 46 47/** SkTIf_c::type = (condition) ? T : F; 48 * Pre-C++11 version of std::conditional. 49 */ 50template <bool condition, typename T, typename F> struct SkTIf_c { 51 typedef F type; 52}; 53template <typename T, typename F> struct SkTIf_c<true, T, F> { 54 typedef T type; 55}; 56 57/** SkTIf::type = (Condition::value) ? T : F; */ 58template <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; */ 63template <typename a, typename b, typename Both, typename A, typename B, typename Neither> 64struct 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]; */ 70template <bool condition, class T = void> struct SkTEnableIf_c { }; 71template <class T> struct SkTEnableIf_c<true, T> { 72 typedef T type; 73}; 74 75/** SkTEnableIf::type = (Condition::value) ? T : [does not exist]; */ 76template <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 86// See http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector 87#define SK_CREATE_MEMBER_DETECTOR(member) \ 88template <typename T> \ 89class HasMember_##member { \ 90 struct Fallback { int member; }; \ 91 struct Derived : T, Fallback {}; \ 92 template <typename U, U> struct Check; \ 93 template <typename U> static uint8_t func(Check<int Fallback::*, &U::member>*); \ 94 template <typename U> static uint16_t func(...); \ 95public: \ 96 typedef HasMember_##member type; \ 97 static const bool value = sizeof(func<Derived>(NULL)) == sizeof(uint16_t); \ 98} 99 100// Same sort of thing as SK_CREATE_MEMBER_DETECTOR, but checks for the existence of a nested type. 101#define SK_CREATE_TYPE_DETECTOR(type) \ 102template <typename T> \ 103class HasType_##type { \ 104 template <typename U> static uint8_t func(typename U::type*); \ 105 template <typename U> static uint16_t func(...); \ 106public: \ 107 static const bool value = sizeof(func<T>(NULL)) == sizeof(uint8_t); \ 108} 109 110#endif 111