Lines Matching refs:Impl
1198 // Constructs an Action from its implementation. A NULL impl is
1200 explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
1260 template <typename Impl>
1263 explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
1277 explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
1284 Impl impl_;
1289 Impl impl_;
1297 Action<F> MakeAction(ActionInterface<F>* impl) {
1298 return Action<F>(impl);
1302 // easier to use than the PolymorphicAction<Impl> constructor as it
1308 template <typename Impl>
1309 inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
1310 return PolymorphicAction<Impl>(impl);
1374 // Impl really belongs in this scope as a local class but can't
1376 // in this case. Until MS fixes that bug we put Impl into the class scope
1378 // in the Impl class. But both definitions must be the same.
1383 return Action<F>(new Impl<F>(value_));
1389 class Impl : public ActionInterface<F> {
1401 explicit Impl(R value)
1411 GTEST_DISALLOW_ASSIGN_(Impl);
1460 return Action<F>(new Impl<F>(ref_));
1466 class Impl : public ActionInterface<F> {
1471 explicit Impl(T& ref) : ref_(ref) {} // NOLINT
1480 GTEST_DISALLOW_ASSIGN_(Impl);
1509 return Action<F>(new Impl<F>(value_));
1515 class Impl : public ActionInterface<F> {
1520 explicit Impl(const T& value) : value_(value) {} // NOLINT
1529 GTEST_DISALLOW_ASSIGN_(Impl);
1690 // Impl really belongs in this scope as a local class but can't
1692 // in this case. Until MS fixes that bug we put Impl into the class scope
1694 // in the Impl class. But both definitions must be the same.
1700 return Action<F>(new Impl<F>(action_));
1705 class Impl : public ActionInterface<F> {
1710 explicit Impl(const A& action) : action_(action) {}
1725 GTEST_DISALLOW_ASSIGN_(Impl);
1772 return Action<F>(new Impl<F>(action1_, action2_));
1778 class Impl : public ActionInterface<F> {
1784 Impl(const Action<VoidResult>& action1, const Action<F>& action2)
1796 GTEST_DISALLOW_ASSIGN_(Impl);
2075 explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
2723 operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
2727 class Impl : public ActionInterface<F> {
2732 explicit Impl(const InnerAction& action) : action_(action) {}
2768 template <typename Result, class Impl>
2771 static Result Perform(Impl* impl, const ::std::tr1::tuple<>& args) {
2773 return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
2780 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0>& args) {
2782 return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
2789 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1>& args) {
2791 return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
2798 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2>& args) {
2800 return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
2807 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2,
2810 return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
2817 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3,
2820 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
2828 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4,
2831 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
2839 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4,
2842 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
2850 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4,
2853 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
2861 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4,
2864 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
2872 static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4,
2875 return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
4922 explicit MatcherBase(const MatcherInterface<T>* impl)
4923 : impl_(impl) {}
4958 explicit Matcher(const MatcherInterface<T>* impl)
4959 : internal::MatcherBase<T>(impl) {}
4975 explicit Matcher(const MatcherInterface<const internal::string&>* impl)
4976 : internal::MatcherBase<const internal::string&>(impl) {}
4992 explicit Matcher(const MatcherInterface<internal::string>* impl)
4993 : internal::MatcherBase<internal::string>(impl) {}
5013 explicit Matcher(const MatcherInterface<const StringPiece&>* impl)
5014 : internal::MatcherBase<const StringPiece&>(impl) {}
5033 explicit Matcher(const MatcherInterface<StringPiece>* impl)
5034 : internal::MatcherBase<StringPiece>(impl) {}
5052 // To define a polymorphic matcher, a user should provide an Impl
5060 template <class Impl>
5063 explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
5067 Impl& mutable_impl() { return impl_; }
5071 const Impl& impl() const { return impl_; }
5082 explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
5097 const Impl impl_;
5102 Impl impl_;
5115 inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
5116 return Matcher<T>(impl);
5120 // easier to use than the PolymorphicMatcher<Impl> constructor as it
5126 template <class Impl>
5127 inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
5128 return PolymorphicMatcher<Impl>(impl);
5197 return Matcher<T>(new Impl(source_matcher));
5201 class Impl : public MatcherInterface<T> {
5203 explicit Impl(const Matcher<U>& source_matcher)
5222 GTEST_DISALLOW_ASSIGN_(Impl);
5539 return MakeMatcher(new Impl<Lhs>(rhs_)); \
5543 class Impl : public MatcherInterface<Lhs> { \
5545 explicit Impl(const Rhs& rhs) : rhs_(rhs) {} \
5560 GTEST_DISALLOW_ASSIGN_(Impl); \
5640 // By passing object_ (type T&) to Impl(), which expects a Super&,
5645 return MakeMatcher(new Impl<Super>(object_));
5650 class Impl : public MatcherInterface<Super&> {
5652 explicit Impl(Super& x) : object_(x) {} // NOLINT
5675 GTEST_DISALLOW_ASSIGN_(Impl);
5982 return MakeMatcher(new Impl< ::std::tr1::tuple<T1, T2> >); \
5986 return MakeMatcher(new Impl<const ::std::tr1::tuple<T1, T2>&>); \
5990 class Impl : public MatcherInterface<Tuple> { \
6491 class Impl : public MatcherInterface<T> {
6493 Impl(FloatType rhs, bool nan_eq_nan, FloatType max_abs_error) :
6570 GTEST_DISALLOW_ASSIGN_(Impl);
6580 return MakeMatcher(new Impl<FloatType>(rhs_, nan_eq_nan_, max_abs_error_));
6585 new Impl<const FloatType&>(rhs_, nan_eq_nan_, max_abs_error_));
6589 return MakeMatcher(new Impl<FloatType&>(rhs_, nan_eq_nan_, max_abs_error_));
6618 return MakeMatcher(new Impl<Pointer>(matcher_));
6624 class Impl : public MatcherInterface<Pointer> {
6629 explicit Impl(const InnerMatcher& matcher)
6654 GTEST_DISALLOW_ASSIGN_(Impl);
6825 return Matcher<T>(new Impl<T>(callable_, matcher_));
6832 class Impl : public MatcherInterface<T> {
6834 Impl(CallableStorageType callable, const Matcher<ResultType>& matcher)
6865 GTEST_DISALLOW_ASSIGN_(Impl);
6866 }; // class Impl
6884 return MakeMatcher(new Impl<Container>(size_matcher_));
6888 class Impl : public MatcherInterface<Container> {
6893 explicit Impl(const SizeMatcher& size_matcher)
6918 GTEST_DISALLOW_ASSIGN_(Impl);
7036 return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
7040 class Impl : public MatcherInterface<LhsContainer> {
7051 Impl(const Comparator& comparator, const ContainerMatcher& matcher)
7093 GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
7126 return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
7130 class Impl : public MatcherInterface<LhsContainer> {
7143 Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
7203 GTEST_DISALLOW_ASSIGN_(Impl);
