eson/googletest
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remove Nokia's Symbian compiler workaround: SafeMatcherCastImpl

Browse Source
This commit is contained in:
Krystian Kuzniarek 2019-11-22 15:19:25 +01:00
parent e0c80b0a6e
commit bbbc5d8a4b
1 changed files with 36 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
googlemock/include/gmock/gmock-matchers.h
View File

@ -247,31 +247,24 @@ inline Matcher<T> MatcherCast(const M& matcher) {
return internal::MatcherCastImpl<T, M>::Cast(matcher); return internal::MatcherCastImpl<T, M>::Cast(matcher);
} }
// Implements SafeMatcherCast(). // This overload handles polymorphic matchers and values only since
// // monomorphic matchers are handled by the next one.
// FIXME: The intermediate SafeMatcherCastImpl class was introduced as a template <typename T, typename M>
// workaround for a compiler bug, and can now be removed. inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
template <typename T>
class SafeMatcherCastImpl {
public:
// This overload handles polymorphic matchers and values only since
// monomorphic matchers are handled by the next one.
template <typename M>
static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
return MatcherCast<T>(polymorphic_matcher_or_value); return MatcherCast<T>(polymorphic_matcher_or_value);
} }
// This overload handles monomorphic matchers. // This overload handles monomorphic matchers.
// //
// In general, if type T can be implicitly converted to type U, we can // In general, if type T can be implicitly converted to type U, we can
// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is // safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
// contravariant): just keep a copy of the original Matcher<U>, convert the // contravariant): just keep a copy of the original Matcher<U>, convert the
// argument from type T to U, and then pass it to the underlying Matcher<U>. // argument from type T to U, and then pass it to the underlying Matcher<U>.
// The only exception is when U is a reference and T is not, as the // The only exception is when U is a reference and T is not, as the
// underlying Matcher<U> may be interested in the argument's address, which // underlying Matcher<U> may be interested in the argument's address, which
// is not preserved in the conversion from T to U. // is not preserved in the conversion from T to U.
template <typename U> template <typename T, typename U>
static inline Matcher<T> Cast(const Matcher<U>& matcher) { inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
// Enforce that T can be implicitly converted to U. // Enforce that T can be implicitly converted to U.
GTEST_COMPILE_ASSERT_((std::is_convertible<T, U>::value), GTEST_COMPILE_ASSERT_((std::is_convertible<T, U>::value),
"T must be implicitly convertible to U"); "T must be implicitly convertible to U");
@ -284,19 +277,13 @@ class SafeMatcherCastImpl {
// conversion is not lossy. // conversion is not lossy.
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT; typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU; typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther; constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther; constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
GTEST_COMPILE_ASSERT_( GTEST_COMPILE_ASSERT_(
kTIsOther || kUIsOther || kTIsOther || kUIsOther ||
(internal::LosslessArithmeticConvertible<RawT, RawU>::value), (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
conversion_of_arithmetic_types_must_be_lossless); conversion_of_arithmetic_types_must_be_lossless);
return MatcherCast<T>(matcher); return MatcherCast<T>(matcher);
}
};
template <typename T, typename M>
inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
} }
// A<T>() returns a matcher that matches any value of type T. // A<T>() returns a matcher that matches any value of type T.