a89f55198b
Some of this is transitive, like SkRecords.h used by SkMiniRecorder.h used by (public) SkPictureRecorder.h. BUG=skia: Review URL: https://codereview.chromium.org/1217293004
112 lines
4.5 KiB
C++
112 lines
4.5 KiB
C++
/*
|
|
* Copyright 2013 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*
|
|
*
|
|
* This header provides some of the helpers (std::integral_constant) and
|
|
* type transformations (std::conditional) which will become available with
|
|
* C++11 in the type_traits header.
|
|
*
|
|
* Because we lack constexpr, we cannot mimic
|
|
* std::integral_constant::'constexpr operator T()'.
|
|
* As a result we introduce SkTBool and SkTIf similar to Boost in order to
|
|
* minimize the visual noise of many uses of '::value'.
|
|
*/
|
|
|
|
#ifndef SkTLogic_DEFINED
|
|
#define SkTLogic_DEFINED
|
|
|
|
/** Represents a templated integer constant.
|
|
* Pre-C++11 version of std::integral_constant.
|
|
*/
|
|
template <typename T, T v> struct SkTIntegralConstant {
|
|
static const T value = v;
|
|
typedef T value_type;
|
|
typedef SkTIntegralConstant<T, v> type;
|
|
};
|
|
|
|
/** Convenience specialization of SkTIntegralConstant. */
|
|
template <bool b> struct SkTBool : SkTIntegralConstant<bool, b> { };
|
|
|
|
/** Pre-C++11 version of std::is_empty<T>. */
|
|
template <typename T>
|
|
class SkTIsEmpty {
|
|
struct Derived : public T { char unused; };
|
|
public:
|
|
static const bool value = sizeof(Derived) == sizeof(char);
|
|
};
|
|
|
|
/** Pre-C++11 version of std::true_type. */
|
|
typedef SkTBool<true> SkTrue;
|
|
|
|
/** Pre-C++11 version of std::false_type. */
|
|
typedef SkTBool<false> SkFalse;
|
|
|
|
/** SkTIf_c::type = (condition) ? T : F;
|
|
* Pre-C++11 version of std::conditional.
|
|
*/
|
|
template <bool condition, typename T, typename F> struct SkTIf_c {
|
|
typedef F type;
|
|
};
|
|
template <typename T, typename F> struct SkTIf_c<true, T, F> {
|
|
typedef T type;
|
|
};
|
|
|
|
/** SkTIf::type = (Condition::value) ? T : F; */
|
|
template <typename Condition, typename T, typename F> struct SkTIf {
|
|
typedef typename SkTIf_c<static_cast<bool>(Condition::value), T, F>::type type;
|
|
};
|
|
|
|
/** SkTMux::type = (a && b) ? Both : (a) ? A : (b) ? B : Neither; */
|
|
template <typename a, typename b, typename Both, typename A, typename B, typename Neither>
|
|
struct SkTMux {
|
|
typedef typename SkTIf<a, typename SkTIf<b, Both, A>::type,
|
|
typename SkTIf<b, B, Neither>::type>::type type;
|
|
};
|
|
|
|
/** SkTEnableIf_c::type = (condition) ? T : [does not exist]; */
|
|
template <bool condition, class T = void> struct SkTEnableIf_c { };
|
|
template <class T> struct SkTEnableIf_c<true, T> {
|
|
typedef T type;
|
|
};
|
|
|
|
/** SkTEnableIf::type = (Condition::value) ? T : [does not exist]; */
|
|
template <class Condition, class T = void> struct SkTEnableIf
|
|
: public SkTEnableIf_c<static_cast<bool>(Condition::value), T> { };
|
|
|
|
/** Use as a return type to enable a function only when cond_type::value is true,
|
|
* like C++14's std::enable_if_t. E.g. (N.B. this is a dumb example.)
|
|
* SK_WHEN(SkTrue, int) f(void* ptr) { return 1; }
|
|
* SK_WHEN(!SkTrue, int) f(void* ptr) { return 2; }
|
|
*/
|
|
#define SK_WHEN(cond_prefix, T) typename SkTEnableIf_c<cond_prefix::value, T>::type
|
|
#define SK_WHEN_C(cond, T) typename SkTEnableIf_c<cond, T>::type
|
|
|
|
// See http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
|
|
#define SK_CREATE_MEMBER_DETECTOR(member) \
|
|
template <typename T> \
|
|
class HasMember_##member { \
|
|
struct Fallback { int member; }; \
|
|
struct Derived : T, Fallback {}; \
|
|
template <typename U, U> struct Check; \
|
|
template <typename U> static uint8_t func(Check<int Fallback::*, &U::member>*); \
|
|
template <typename U> static uint16_t func(...); \
|
|
public: \
|
|
typedef HasMember_##member type; \
|
|
static const bool value = sizeof(func<Derived>(NULL)) == sizeof(uint16_t); \
|
|
}
|
|
|
|
// Same sort of thing as SK_CREATE_MEMBER_DETECTOR, but checks for the existence of a nested type.
|
|
#define SK_CREATE_TYPE_DETECTOR(type) \
|
|
template <typename T> \
|
|
class HasType_##type { \
|
|
template <typename U> static uint8_t func(typename U::type*); \
|
|
template <typename U> static uint16_t func(...); \
|
|
public: \
|
|
static const bool value = sizeof(func<T>(NULL)) == sizeof(uint8_t); \
|
|
}
|
|
|
|
#endif
|