googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h

// GOOGLETEST_CM0002 DO NOT DELETE
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_

#include "gmock/internal/gmock-port.h"
#if GTEST_GOOGLE3_MODE_

#include <memory>
#include <type_traits>

#include "base/callback.h"
#include "gmock/gmock-actions.h"

namespace testing {
namespace internal {

// Implements the Invoke(callback) action.
template <typename CallbackType, typename Signature>
class InvokeCallbackAction;

template <typename CallbackType, typename R, typename... Args>
class InvokeCallbackAction<CallbackType, R(Args...)> {
 public:
  // The c'tor takes ownership of the callback.
  explicit InvokeCallbackAction(CallbackType* callback) : callback_(callback) {
    callback->CheckIsRepeatable();  // Makes sure the callback is permanent.
  }

  R operator()(Args... args) const {
    return callback_->Run(std::forward<Args>(args)...);
  }

 private:
  const std::shared_ptr<CallbackType> callback_;
};

// Implements the InvokeWithoutArgs(callback) action.
template <typename CallbackType>
class InvokeCallbackWithoutArgsAction {
  const std::shared_ptr<CallbackType> callback_;

 public:
  // The c'tor takes ownership of the callback.
  explicit InvokeCallbackWithoutArgsAction(CallbackType* callback)
      : callback_(callback) {
    callback->CheckIsRepeatable();  // Makes sure the callback is permanent.
  }

  template <typename... Args>
  auto operator()(const Args&...) -> decltype(this->callback_->Run()) {
    return callback_->Run();
  }
};

template <typename T>
struct TypeIdentity {
  using type = T;
};

inline TypeIdentity<void()> CallbackSignatureImpl(Closure*);
template <typename R>
TypeIdentity<R()> CallbackSignatureImpl(ResultCallback<R>*);

template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback1<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback1<R, Args...>*);

template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback2<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback2<R, Args...>*);

template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback3<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback3<R, Args...>*);

template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback4<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback4<R, Args...>*);

template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback5<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback5<R, Args...>*);

template <typename T>
using CallbackSignature = typename decltype(
    internal::CallbackSignatureImpl(std::declval<T*>()))::type;

// Specialization for protocol buffers.
// We support setting a proto2::Message, which doesn't have an assignment
// operator.
template <size_t N, typename A>
struct SetArgumentPointeeAction<
    N, A,
    typename std::enable_if<std::is_base_of<proto2::Message, A>::value>::type> {
  A value;

  template <typename... Args>
  void operator()(const Args&... args) const {
    ::std::get<N>(std::tie(args...))->CopyFrom(value);
  }
};

// Add Invoke overloads for google3 Callback types.

template <typename C, typename... Args,
          typename = internal::CallbackSignature<C>>
auto InvokeArgument(C* cb, Args... args) -> decltype(cb->Run(args...)) {
  return cb->Run(args...);
}

}  // namespace internal

// Add Invoke overloads for google3 Callback types.

// Creates an action that invokes the given callback with the mock
// function's arguments.  The action takes ownership of the callback
// and verifies that it's permanent.
//
// google3 doesn't support callbacks with more than 5
// arguments yet, so we only support invoking callbacks with up to
// 5 arguments.

template <typename Callback>
internal::InvokeCallbackAction<Callback, internal::CallbackSignature<Callback>>
Invoke(Callback* callback) {
  return internal::InvokeCallbackAction<Callback,
                                        internal::CallbackSignature<Callback>>(
      callback);
}

// Creates an action that invokes the given callback with no argument.
// The action takes ownership of the callback and verifies that it's
// permanent.
template <typename Callback, typename = internal::CallbackSignature<Callback>>
internal::InvokeCallbackWithoutArgsAction<Callback> InvokeWithoutArgs(
    Callback* callback) {
  return internal::InvokeCallbackWithoutArgsAction<Callback>(callback);
}

}  // namespace testing

#endif  // GTEST_GOOGLE3_MODE_

#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_