Move all GrTFlagsMask operators into bitfield macro definitions.
This removes the templated versions of these operators. This should help
the case where clients would get compiler errors in their code with
errors claiming failed matches to these ganesh operators. The errors were
correct, but would be confusing for clients to see. Now with this change
the various operators are defined for specific types so a client shouldn't
get errors for their own enums anymore.
Bug: chromium:1204688
Change-Id: Ie3450834da7734a161af303ca6c8f458dd173513
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/403596
Commit-Queue: Greg Daniel <egdaniel@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index 0b29a10..f30fa8a 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -334,6 +334,14 @@
# endif
#endif
+#if !defined(SK_MAYBE_UNUSED)
+# if defined(__clang__) || defined(__GNUC__)
+# define SK_MAYBE_UNUSED [[maybe_unused]]
+# else
+# define SK_MAYBE_UNUSED
+# endif
+#endif
+
/**
* If your judgment is better than the compiler's (i.e. you've profiled it),
* you can use SK_ALWAYS_INLINE to force inlining. E.g.
diff --git a/include/gpu/GrTypes.h b/include/gpu/GrTypes.h
index d556a15..9888c9f 100644
--- a/include/gpu/GrTypes.h
+++ b/include/gpu/GrTypes.h
@@ -70,62 +70,57 @@
const int fValue;
};
-// Or-ing a mask always returns another mask.
-template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(GrTFlagsMask<TFlags> a,
- GrTFlagsMask<TFlags> b) {
- return GrTFlagsMask<TFlags>(a.value() | b.value());
-}
-template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(GrTFlagsMask<TFlags> a,
- TFlags b) {
- return GrTFlagsMask<TFlags>(a.value() | static_cast<int>(b));
-}
-template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(TFlags a,
- GrTFlagsMask<TFlags> b) {
- return GrTFlagsMask<TFlags>(static_cast<int>(a) | b.value());
-}
-template<typename TFlags> inline GrTFlagsMask<TFlags>& operator|=(GrTFlagsMask<TFlags>& a,
- GrTFlagsMask<TFlags> b) {
- return (a = a | b);
-}
-
-// And-ing two masks returns another mask; and-ing one with regular flags returns flags.
-template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator&(GrTFlagsMask<TFlags> a,
- GrTFlagsMask<TFlags> b) {
- return GrTFlagsMask<TFlags>(a.value() & b.value());
-}
-template<typename TFlags> constexpr TFlags operator&(GrTFlagsMask<TFlags> a, TFlags b) {
- return static_cast<TFlags>(a.value() & static_cast<int>(b));
-}
-template<typename TFlags> constexpr TFlags operator&(TFlags a, GrTFlagsMask<TFlags> b) {
- return static_cast<TFlags>(static_cast<int>(a) & b.value());
-}
-template<typename TFlags> inline TFlags& operator&=(TFlags& a, GrTFlagsMask<TFlags> b) {
- return (a = a & b);
-}
-
/**
* Defines bitwise operators that make it possible to use an enum class as a
* basic bitfield.
*/
#define GR_MAKE_BITFIELD_CLASS_OPS(X) \
- constexpr GrTFlagsMask<X> operator~(X a) { \
+ SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator~(X a) { \
return GrTFlagsMask<X>(~static_cast<int>(a)); \
} \
- constexpr X operator|(X a, X b) { \
+ SK_MAYBE_UNUSED constexpr X operator|(X a, X b) { \
return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
} \
- inline X& operator|=(X& a, X b) { \
+ SK_MAYBE_UNUSED inline X& operator|=(X& a, X b) { \
return (a = a | b); \
} \
- constexpr bool operator&(X a, X b) { \
+ SK_MAYBE_UNUSED constexpr bool operator&(X a, X b) { \
return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
} \
+ SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
+ return GrTFlagsMask<X>(a.value() | b.value()); \
+ } \
+ SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, X b) { \
+ return GrTFlagsMask<X>(a.value() | static_cast<int>(b)); \
+ } \
+ SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(X a, GrTFlagsMask<X> b) { \
+ return GrTFlagsMask<X>(static_cast<int>(a) | b.value()); \
+ } \
+ SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
+ return static_cast<X>(a.value() & b.value()); \
+ } \
+ SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, X b) { \
+ return static_cast<X>(a.value() & static_cast<int>(b)); \
+ } \
+ SK_MAYBE_UNUSED constexpr X operator&(X a, GrTFlagsMask<X> b) { \
+ return static_cast<X>(static_cast<int>(a) & b.value()); \
+ } \
+ SK_MAYBE_UNUSED inline X& operator&=(X& a, GrTFlagsMask<X> b) { \
+ return (a = a & b); \
+ } \
#define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
friend constexpr GrTFlagsMask<X> operator ~(X); \
friend constexpr X operator |(X, X); \
friend X& operator |=(X&, X); \
- friend constexpr bool operator &(X, X)
+ friend constexpr bool operator &(X, X); \
+ friend constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X>, GrTFlagsMask<X>); \
+ friend constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X>, X); \
+ friend constexpr GrTFlagsMask<X> operator|(X, GrTFlagsMask<X>); \
+ friend constexpr X operator&(GrTFlagsMask<X>, GrTFlagsMask<X>); \
+ friend constexpr X operator&(GrTFlagsMask<X>, X); \
+ friend constexpr X operator&(X, GrTFlagsMask<X>); \
+ friend X& operator &=(X&, GrTFlagsMask<X>)
///////////////////////////////////////////////////////////////////////////////
