testing::internal::MatcherCastImpl< T, M > Class Template Reference

#include <gmock-matchers.h>

Static Public Member Functions
static Matcher< T >	Cast (const M &polymorphic_matcher_or_value)
static Matcher< T >	Cast (const M &polymorphic_matcher_or_value)
static Matcher< T >	Cast (const M &polymorphic_matcher_or_value)

Static Private Member Functions
static Matcher< T >	CastImpl (const M &value, BooleanConstant< false >)
static Matcher< T >	CastImpl (const M &polymorphic_matcher_or_value, BooleanConstant< true >)
static Matcher< T >	CastImpl (const M &value, BooleanConstant< false >)
static Matcher< T >	CastImpl (const M &polymorphic_matcher_or_value, BooleanConstant< true >)
static Matcher< T >	CastImpl (const M &value, BooleanConstant< false >)
static Matcher< T >	CastImpl (const M &polymorphic_matcher_or_value, BooleanConstant< true >)

Detailed Description

template<typename T, typename M>
class testing::internal::MatcherCastImpl< T, M >

Definition at line 515 of file gmock-matchers.h.

Member Function Documentation

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::Cast ( const M &  polymorphic_matcher_or_value )

inlinestatic

Definition at line 517 of file gmock-matchers.h.

References M, and value.

Referenced by testing::internal::MatcherCastImpl< T, Matcher< T > >::Cast(), testing::SafeMatcherCastImpl< T >::Cast(), and testing::MatcherCast().

                                                                {
    // M can be a polymorhic matcher, in which case we want to use
    // its conversion operator to create Matcher<T>.  Or it can be a value
    // that should be passed to the Matcher<T>'s constructor.
    //
    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
    // polymorphic matcher because it'll be ambiguous if T has an implicit
    // constructor from M (this usually happens when T has an implicit
    // constructor from any type).
    //
    // It won't work to unconditionally implict_cast
    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
    // a user-defined conversion from M to T if one exists (assuming M is
    // a value).
    return CastImpl(
        polymorphic_matcher_or_value,
        BooleanConstant<
            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::Cast ( const M &  polymorphic_matcher_or_value )

inlinestatic

Definition at line 517 of file gmock-matchers.h.

References M, and value.

                                                                {
    // M can be a polymorhic matcher, in which case we want to use
    // its conversion operator to create Matcher<T>.  Or it can be a value
    // that should be passed to the Matcher<T>'s constructor.
    //
    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
    // polymorphic matcher because it'll be ambiguous if T has an implicit
    // constructor from M (this usually happens when T has an implicit
    // constructor from any type).
    //
    // It won't work to unconditionally implict_cast
    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
    // a user-defined conversion from M to T if one exists (assuming M is
    // a value).
    return CastImpl(
        polymorphic_matcher_or_value,
        BooleanConstant<
            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::Cast ( const M &  polymorphic_matcher_or_value )

inlinestatic

Definition at line 517 of file gmock-matchers.h.

References M, and value.

                                                                {
    // M can be a polymorhic matcher, in which case we want to use
    // its conversion operator to create Matcher<T>.  Or it can be a value
    // that should be passed to the Matcher<T>'s constructor.
    //
    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
    // polymorphic matcher because it'll be ambiguous if T has an implicit
    // constructor from M (this usually happens when T has an implicit
    // constructor from any type).
    //
    // It won't work to unconditionally implict_cast
    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
    // a user-defined conversion from M to T if one exists (assuming M is
    // a value).
    return CastImpl(
        polymorphic_matcher_or_value,
        BooleanConstant<
            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::CastImpl ( const M &  value, BooleanConstant< false >    )

inlinestaticprivate

Definition at line 538 of file gmock-matchers.h.

References value.

                                                                     {
    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
    // matcher.  It must be a value then.  Use direct initialization to create
    // a matcher.
    return Matcher<T>(ImplicitCast_<T>(value));
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::CastImpl ( const M &  value, BooleanConstant< false >    )

inlinestaticprivate

Definition at line 538 of file gmock-matchers.h.

References value.

                                                                     {
    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
    // matcher.  It must be a value then.  Use direct initialization to create
    // a matcher.
    return Matcher<T>(ImplicitCast_<T>(value));
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::CastImpl ( const M &  value, BooleanConstant< false >    )

inlinestaticprivate

Definition at line 538 of file gmock-matchers.h.

References value.

                                                                     {
    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
    // matcher.  It must be a value then.  Use direct initialization to create
    // a matcher.
    return Matcher<T>(ImplicitCast_<T>(value));
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::CastImpl ( const M &  polymorphic_matcher_or_value, BooleanConstant< true >    )

inlinestaticprivate

Definition at line 545 of file gmock-matchers.h.

                                                    {
    // M is implicitly convertible to Matcher<T>, which means that either
    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
    // from M.  In both cases using the implicit conversion will produce a
    // matcher.
    //
    // Even if T has an implicit constructor from M, it won't be called because
    // creating Matcher<T> would require a chain of two user-defined conversions
    // (first to create T from M and then to create Matcher<T> from T).
    return polymorphic_matcher_or_value;
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::CastImpl ( const M &  polymorphic_matcher_or_value, BooleanConstant< true >    )

inlinestaticprivate

Definition at line 545 of file gmock-matchers.h.

                                                    {
    // M is implicitly convertible to Matcher<T>, which means that either
    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
    // from M.  In both cases using the implicit conversion will produce a
    // matcher.
    //
    // Even if T has an implicit constructor from M, it won't be called because
    // creating Matcher<T> would require a chain of two user-defined conversions
    // (first to create T from M and then to create Matcher<T> from T).
    return polymorphic_matcher_or_value;
  }

template<typename T , typename M >

static Matcher<T> testing::internal::MatcherCastImpl< T, M >::CastImpl ( const M &  polymorphic_matcher_or_value, BooleanConstant< true >    )

inlinestaticprivate

Definition at line 545 of file gmock-matchers.h.

                                                    {
    // M is implicitly convertible to Matcher<T>, which means that either
    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
    // from M.  In both cases using the implicit conversion will produce a
    // matcher.
    //
    // Even if T has an implicit constructor from M, it won't be called because
    // creating Matcher<T> would require a chain of two user-defined conversions
    // (first to create T from M and then to create Matcher<T> from T).
    return polymorphic_matcher_or_value;
  }

---

The documentation for this class was generated from the following file:

• proxygen/fizz/build_/gtest/src/gtest/googlemock/include/gmock/gmock-matchers.h