Lines Matching refs:Args
351 template <typename F, typename... Args>
352 using call_result_t = decltype(std::declval<F>()(std::declval<Args>()...));
354 template <typename Void, typename R, typename F, typename... Args>
360 template <typename R, typename F, typename... Args>
361 struct is_callable_r_impl<void_t<call_result_t<F, Args...>>, R, F, Args...>
365 is_implicitly_convertible<call_result_t<F, Args...>, R>>::type {};
369 template <typename R, typename F, typename... Args>
370 using is_callable_r = is_callable_r_impl<void, R, F, Args...>;
419 template <typename Result, typename... Args>
420 class OnceAction<Result(Args...)> final {
430 Args...>>;
491 Result Call(Args... args) && {
492 return function_(std::forward<Args>(args)...);
549 internal::call_result_t<Callable> operator()(Args&&...) {
556 std::function<Result(Args...)> function_;
722 // An Action<R(Args...)> is a copyable and IMMUTABLE (except by assignment)
724 // R(Args...) is called. The implementation of Action<T> is just a
728 template <typename R, typename... Args>
729 class Action<R(Args...)> {
731 using F = R(Args...);
805 R operator()(Args... args) && {
807 std::forward_as_tuple(std::forward<Args>(args)...));
928 template <typename U, typename... Args,
935 operator OnceAction<U(Args...)>() && { // NOLINT
939 template <typename U, typename... Args,
946 operator Action<U(Args...)>() const { // NOLINT
1232 template <typename... Args>
1233 T operator()(Args&&...) const {
1307 template <typename... Args>
1308 void operator()(const Args&... args) const {
1319 template <typename... Args>
1320 auto operator()(Args&&... args) const
1321 -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
1322 return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
1336 template <typename... Args>
1337 auto operator()(const Args&...) -> decltype(function_impl()) {
1351 template <typename... Args>
1352 ReturnType operator()(const Args&...) const {
1413 template <typename R, typename... Args>
1415 R(typename std::tuple_element<I, std::tuple<Args...>>::type...);
1423 template <typename R, typename... Args,
1434 I, std::tuple<Args...>>...)>>::value,
1436 operator OnceAction<R(Args...)>() && { // NOLINT
1438 OnceAction<InnerSignature<R, Args...>> inner_action;
1440 R operator()(Args&&... args) && {
1443 std::forward_as_tuple(std::forward<Args>(args)...))...);
1450 template <typename R, typename... Args,
1461 I, std::tuple<Args...>>...)>>::value,
1463 operator Action<R(Args...)>() const { // NOLINT
1464 Action<InnerSignature<R, Args...>> converted(inner_action);
1466 return [converted](Args&&... args) -> R {
1468 std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
1492 template <typename R, typename... Args,
1494 std::is_convertible<FinalAction, OnceAction<R(Args...)>>::value,
1496 operator OnceAction<R(Args...)>() && { // NOLINT
1501 typename R, typename... Args,
1503 std::is_convertible<const FinalAction&, Action<R(Args...)>>::value,
1505 operator Action<R(Args...)>() const { // NOLINT
1579 template <typename R, typename... Args,
1586 OnceAction<void(InitialActionArgType<Args>...)>>,
1587 std::is_convertible<Base, OnceAction<R(Args...)>>>::value,
1589 operator OnceAction<R(Args...)>() && { // NOLINT
1594 OnceAction<void(InitialActionArgType<Args>...)> initial_action;
1595 OnceAction<R(Args...)> remaining_actions;
1597 R operator()(Args... args) && {
1599 .Call(static_cast<InitialActionArgType<Args>>(args)...);
1601 return std::move(remaining_actions).Call(std::forward<Args>(args)...);
1612 typename R, typename... Args,
1618 Action<void(InitialActionArgType<Args>...)>>,
1619 std::is_convertible<const Base&, Action<R(Args...)>>>::value,
1621 operator Action<R(Args...)>() const { // NOLINT
1626 Action<void(InitialActionArgType<Args>...)> initial_action;
1627 Action<R(Args...)> remaining_actions;
1629 R operator()(Args... args) const {
1631 static_cast<InitialActionArgType<Args>>(args)...));
1634 std::forward_as_tuple(std::forward<Args>(args)...));
1662 template <typename... Args,
1663 typename = typename std::enable_if<(k < sizeof...(Args))>::type>
1664 auto operator()(Args&&... args) const -> decltype(std::get<k>(
1665 std::forward_as_tuple(std::forward<Args>(args)...))) {
1666 return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...));
1674 template <typename... Args>
1675 void operator()(const Args&... args) const {
1684 template <typename... Args>
1685 void operator()(const Args&... args) const {
1694 template <typename... Args>
1695 void operator()(Args&&... args) const {
1697 typename ::std::tuple_element<k, std::tuple<Args...>>::type;
1709 template <typename... Args>
1710 void operator()(const Args&... args) const {
1720 template <typename... Args>
1721 void operator()(const Args&... args) const {
1729 template <typename... Args>
1730 auto operator()(const Args&...) const -> decltype(*pointer) {
1740 template <typename R, typename... Args>
1741 operator Action<R(Args...)>() const { // NOLINT
1743 return [copy](Args...) -> R { throw copy; };
2105 template <typename R, typename... Args, typename Impl>
2106 struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
2108 using function_type = R(Args...);
2109 using args_type = std::tuple<Args...>;
2114 R operator()(Args&&... arg) const {
2116 sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
2119 args_type{std::forward<Args>(arg)...});