testing::internal::DoAllAction< InitialAction, OtherActions... > Class Template Reference

#include <gmock-actions.h>

Inheritance diagram for testing::internal::DoAllAction< InitialAction, OtherActions... >:

Collaboration diagram for testing::internal::DoAllAction< InitialAction, OtherActions... >:

Classes
struct	UserConstructorTag

Public Member Functions
template<typename T , typename... U>
	DoAllAction (UserConstructorTag, T &&initial_action, U &&... other_actions)
template<typename R , typename... Args, typename std::enable_if< conjunction< std::is_convertible< InitialAction, OnceAction< void(InitialActionArgType< Args >...)>>, std::is_convertible< Base, OnceAction< R(Args...)>>>::value, int >::type = 0>
	operator OnceAction< R (Args...)>() &&
template<typename R , typename... Args, typename std::enable_if< conjunction< std::is_convertible< const InitialAction &, Action< void(InitialActionArgType< Args >...)>>, std::is_convertible< const Base &, Action< R(Args...)>>>::value, int >::type = 0>
	operator Action< R (Args...)>() const

Detailed Description

template<typename InitialAction, typename... OtherActions>
class testing::internal::DoAllAction< InitialAction, OtherActions... >

Definition at line 1516 of file gmock-actions.h.

Constructor & Destructor Documentation

DoAllAction()

template<typename InitialAction , typename... OtherActions>

template<typename T , typename... U>

testing::internal::DoAllAction< InitialAction, OtherActions... >::DoAllAction ( UserConstructorTag  , T &&  initial_action, U &&...  other_actions  )

inlineexplicit

Definition at line 1574 of file gmock-actions.h.

      : Base({}, std::forward<U>(other_actions)...),
        initial_action_(std::forward<T>(initial_action)) {}

Member Function Documentation

operator Action< R()

template<typename InitialAction , typename... OtherActions>

template<typename R , typename... Args, typename std::enable_if< conjunction< std::is_convertible< const InitialAction &, Action< void(InitialActionArgType< Args >...)>>, std::is_convertible< const Base &, Action< R(Args...)>>>::value, int >::type = 0>

testing::internal::DoAllAction< InitialAction, OtherActions... >::operator Action< R ( Args...  ) const

inline

Definition at line 1621 of file gmock-actions.h.

                                      {  // NOLINT
    // Return an action that first calls the initial action with arguments
    // filtered through InitialActionArgType, then forwards arguments directly
    // to the base class to deal with the remaining actions.
    struct OA {
      Action<void(InitialActionArgType<Args>...)> initial_action;
      Action<R(Args...)> remaining_actions;

      R operator()(Args... args) const {
        initial_action.Perform(std::forward_as_tuple(
            static_cast<InitialActionArgType<Args>>(args)...));

        return remaining_actions.Perform(
            std::forward_as_tuple(std::forward<Args>(args)...));
      }
    };

    return OA{
        initial_action_,
        static_cast<const Base&>(*this),
    };
  }

operator OnceAction< R()

template<typename InitialAction , typename... OtherActions>

template<typename R , typename... Args, typename std::enable_if< conjunction< std::is_convertible< InitialAction, OnceAction< void(InitialActionArgType< Args >...)>>, std::is_convertible< Base, OnceAction< R(Args...)>>>::value, int >::type = 0>

testing::internal::DoAllAction< InitialAction, OtherActions... >::operator OnceAction< R ( Args...  ) &&

inline

Definition at line 1589 of file gmock-actions.h.

                                       {  // NOLINT
    // Return an action that first calls the initial action with arguments
    // filtered through InitialActionArgType, then forwards arguments directly
    // to the base class to deal with the remaining actions.
    struct OA {
      OnceAction<void(InitialActionArgType<Args>...)> initial_action;
      OnceAction<R(Args...)> remaining_actions;

      R operator()(Args... args) && {
        std::move(initial_action)
            .Call(static_cast<InitialActionArgType<Args>>(args)...);

        return std::move(remaining_actions).Call(std::forward<Args>(args)...);
      }
    };

    return OA{
        std::move(initial_action_),
        std::move(static_cast<Base&>(*this)),
    };
  }

---

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

• googletest/googlemock/include/gmock/gmock-actions.h