include/gmock/gmock-actions.h

57 //   2. a factory function that creates an Action object from a
62 // management as Action objects can now be copied like plain values.
345 // An Action<F> is a copyable and IMMUTABLE (except by assignment)
347 // of type F is called.  The implementation of Action<T> is just a
349 // Don't inherit from Action!
352 // concrete action (including its current state), and an Action<F>
355 class Action {
360   // Constructs a null Action.  Needed for storing Action objects in
362   Action() : impl_(NULL) {}
364   // Constructs an Action from its implementation.  A NULL impl is
366   explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
369   Action(const Action& action) : impl_(action.impl_) {}
371   // This constructor allows us to turn an Action<Func> object into an
372   // Action<F>, as long as F's arguments can be implicitly converted
376   explicit Action(const Action<Func>& action);
383   // is that a const Action<F> means that it cannot be re-bound to
393         "assign the default action to an Action variable and use "
432   operator Action<F>() const {
433     return Action<F>(new MonomorphicImpl<F>(impl_));
460 // Creates an Action from its implementation and returns it.  The
461 // created Action object owns the implementation.
463 Action<F> MakeAction(ActionInterface<F>* impl) {
464   return Action<F>(impl);
481 // Allows an Action<F2> object to pose as an Action<F1>, as long as F2
489   explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
514 // Function<F>::Result when this action is cast to Action<F> rather than
530 // statement, and conversion of the result of Return to Action<T(U)> is a
544   operator Action<F>() const {
557     return Action<F>(new Impl<R, F>(value_));
662   operator Action<F>() const {
669     return Action<F>(new Impl<F>(ref_));
710   operator Action<F>() const {
718     return Action<F>(new Impl<F>(value_));
752   operator Action<F>() const { return Action<F>(NULL); }
848 // Action<F> as long as f's type is compatible with F (i.e. f can be
895   operator Action<F>() const {
909     return Action<F>(new Impl<F>(action_));
932     const Action<OriginalFunction> action_;
980   operator Action<F>() const {
981     return Action<F>(new Impl<F>(action1_, action2_));
993     Impl(const Action<VoidResult>& action1, const Action<F>& action2)
1002     const Action<VoidResult> action1_;
1003     const Action<F> action2_;
1048 // This constructor allows us to turn an Action<From> object into an
1049 // Action<To>, as long as To's arguments can be implicitly converted
1054 Action<To>::Action(const Action<From>& from)