Add pattern matchers for SkRecord

src/utils/SkTLogic.h

 /*
  * 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.
@@ skipping 71 matching lines @@
     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);      \
 }
 
+/** SK_WHEN_TYPE is type T if cond_type exists, otherwise it does not exist.
+ *  You can use this to enable specializations conditioned on whether a type exists.
+ */
+#define SK_WHEN_TYPE(cond_type, T) typename SkWhenType<cond_type, T>::type
+template <typename cond_type, typename T>
+struct SkWhenType { typedef T type; };
+

[bungeman-skia, 2014/05/05 19:37:51]

So it seems the 'normal' way to do this would be to have a member type trait
detector like

#define SK_CREATE_TYPEDEF_DETECTOR(type) \
template <typename T> \
class HasTypedef_##type { \
    template <typename C> static uint8_t func(typename C::foobar*); \
    template <typename> static uint16_t func(...); \
public: \
    static const bool value = sizeof(func<T>(NULL)) == sizeof(uint8_t); \
}

and then

SK_CREATE_TYPEDEF_DETECTOR(type);
SK_WHEN(HasTypedef_type<MyType>, void)

Of course, this is also more complex and less flexible. It is more complex in
that it converts the existence to a bool and then picks T or nothing based on
the bool, as opposed to directly picking T or nothing based on the existence of
the type directly. It also introduces the extra HasTypedef_type name. It does
not handle top level typedefs (though I'm not sure one would want to do that,
maybe that limitation is a feature). On the other hand, it's more uniform to
current usage and removes the SkWhenType and SK_WHEN_TYPE names.

[mtklein, 2014/05/05 20:05:12]

Strongly agreed and done.

 #endif