include/gmock/gmock-matchers.h

1447       : matcher_(matcher) {}
1450     return !matcher_.MatchAndExplain(x, listener);
1454     matcher_.DescribeNegationTo(os);
1458     matcher_.DescribeTo(os);
1462   const Matcher<T> matcher_;
1472   explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
1478     return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
1482   InnerMatcher matcher_;
1798   explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
1808     // We let matcher_ commit to a particular type here instead of
1813     // If we write Matcher<T>(matcher_).Matches(x) here, it won't
1814     // compile when matcher_ has type Matcher<const T&>; if we write
1815     // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
1816     // when matcher_ has type Matcher<T>; if we just write
1817     // matcher_.Matches(x), it won't compile when matcher_ is
1822     return MatcherCast<const T&>(matcher_).Matches(x);
1826   M matcher_;
1836   explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
1843     // We convert matcher_ to a Matcher<const T&> *now* instead of
1845     // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
1849     // We write SafeMatcherCast<const T&>(matcher_) instead of
1850     // Matcher<const T&>(matcher_), as the latter won't compile when
1851     // matcher_ has type Matcher<T> (e.g. An<int>()).
1854     const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
1868   const M matcher_;
2045   explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
2057     return MakeMatcher(new Impl<Pointer>(matcher_));
2069         : matcher_(MatcherCast<const Pointee&>(matcher)) {}
2073       matcher_.DescribeTo(os);
2078       matcher_.DescribeTo(os);
2087       return MatchPrintAndExplain(*pointer, matcher_, listener);
2091     const Matcher<const Pointee&> matcher_;
2096   const InnerMatcher matcher_;
2111       : matcher_(matcher) {}
2115     matcher_.DescribeTo(os);
2120     matcher_.DescribeNegationTo(os);
2124   const Matcher<To> matcher_;
2154     return MatchPrintAndExplain(to, this->matcher_, listener);
2174     return MatchPrintAndExplain(*to, this->matcher_, listener);
2185       : field_(field), matcher_(matcher) {}
2189     matcher_.DescribeTo(os);
2194     matcher_.DescribeNegationTo(os);
2212     return MatchPrintAndExplain(obj.*field_, matcher_, listener);
2228   const Matcher<const FieldType&> matcher_;
2246       : property_(property), matcher_(matcher) {}
2250     matcher_.DescribeTo(os);
2255     matcher_.DescribeNegationTo(os);
2282     return MatchPrintAndExplain(result, matcher_, listener);
2299   const Matcher<RefToConstProperty> matcher_;
2342       : callable_(callable), matcher_(matcher) {
2348     return Matcher<T>(new Impl<T>(callable_, matcher_));
2358         : callable_(callable), matcher_(matcher) {}
2362       matcher_.DescribeTo(os);
2367       matcher_.DescribeNegationTo(os);
2376       return MatchPrintAndExplain(result, matcher_, listener);
2386     const Matcher<ResultType> matcher_;
2392   const Matcher<ResultType> matcher_;
2617       : comparator_(comparator), matcher_(matcher) {}
2621     return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
2637         : comparator_(comparator), matcher_(matcher) {}
2641       matcher_.DescribeTo(os);
2646       matcher_.DescribeNegationTo(os);
2660         return matcher_.Matches(sorted_container);
2668       const bool match = matcher_.MatchAndExplain(sorted_container,
2676     const Matcher<const ::std::vector<LhsValue>&> matcher_;
2683   const ContainerMatcher matcher_;