Lines Matching refs:Action
59 // 2. a factory function that creates an Action object from a
64 // management as Action objects can now be copied like plain values.
347 // An Action<F> is a copyable and IMMUTABLE (except by assignment)
349 // of type F is called. The implementation of Action<T> is just a
351 // Don't inherit from Action!
354 // concrete action (including its current state), and an Action<F>
357 class Action {
362 // Constructs a null Action. Needed for storing Action objects in
364 Action() {}
367 // Construct an Action from a specified callable.
368 // This cannot take std::function directly, because then Action would not be
373 Action(G&& fun) : fun_(::std::forward<G>(fun)) {} // NOLINT
376 // Constructs an Action from its implementation.
377 explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
379 // This constructor allows us to turn an Action<Func> object into an
380 // Action<F>, as long as F's arguments can be implicitly converted
384 explicit Action(const Action<Func>& action);
397 // is that a const Action<F> means that it cannot be re-bound to
418 friend class Action;
420 // In C++11, Action can be implemented either as a generic functor (through
459 operator Action<F>() const {
460 return Action<F>(new MonomorphicImpl<F>(impl_));
487 // Creates an Action from its implementation and returns it. The
488 // created Action object owns the implementation.
490 Action<F> MakeAction(ActionInterface<F>* impl) {
491 return Action<F>(impl);
508 // Allows an Action<F2> object to pose as an Action<F1>, as long as F2
516 explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
541 // Function<F>::Result when this action is cast to Action<F> rather than
557 // statement, and conversion of the result of Return to Action<T(U)> is a
574 operator Action<F>() const {
587 return Action<F>(new Impl<R, F>(value_));
692 operator Action<F>() const {
699 return Action<F>(new Impl<F>(ref_));
740 operator Action<F>() const {
748 return Action<F>(new Impl<F>(value_));
782 operator Action<F>() const { return Action<F>(); } // NOLINT
878 // Action<F> as long as f's type is compatible with F (i.e. f can be
947 operator Action<F>() const {
961 return Action<F>(new Impl<F>(action_));
984 const Action<OriginalFunction> action_;
1032 operator Action<F>() const {
1033 return Action<F>(new Impl<F>(action1_, action2_));
1045 Impl(const Action<VoidResult>& action1, const Action<F>& action2)
1054 const Action<VoidResult> action1_;
1055 const Action<F> action2_;
1100 // This constructor allows us to turn an Action<From> object into an
1101 // Action<To>, as long as To's arguments can be implicitly converted
1106 Action<To>::Action(const Action<From>& from)