invoke.h

Go to the documentation of this file.

#ifndef __utl_utility_invoke_h__
#define __utl_utility_invoke_h__

#include <utl/core/impl.h>
#include <utl/meta/meta.h>

#include <type_traits>
#include <functional>
#include <utility>

namespace utl {

   namespace detail {

      template <class T>
      struct is_ref_wrapper : meta::false_ {};
      template <class U>
      struct is_ref_wrapper<std::reference_wrapper<U>> : meta::true_ {};

      // 1
      template <class T, class Type, class T1, class... Args,
         meta::enable_if_t<
            std::is_member_function_pointer<std::decay_t<Type T::*>>::value &&
            std::is_base_of<T, std::decay_t<T1>>::value,
            int> =0
      >
      decltype(auto) invoke_impl_(Type T::* f, T1&& t1, Args&&... args) {
         return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...);
      }

      // 2
      template <class T, class Type, class T1, class... Args,
         meta::enable_if_t<
            std::is_member_function_pointer<std::decay_t<Type T::*>>::value &&
            is_ref_wrapper<std::decay_t<T1>>::value,
            int> =0
      >
      decltype(auto) invoke_impl_(Type T::* f, T1&& t1, Args&&... args) {
         return (t1.get().*f)(std::forward<Args>(args)...);
      }

      // 3
      template <class T, class Type, class T1, class... Args,
         meta::enable_if_t<
            std::is_member_function_pointer<std::decay_t<Type T::*>>::value &&
            !std::is_base_of<T, std::decay_t<T1>>::value &&
            !is_ref_wrapper<std::decay_t<T1>>::value,
            int> =0
      >
      decltype(auto) invoke_impl_(Type T::* f, T1&& t1, Args&&... args) {
         return ((*std::forward<T1>(t1)).*f)(std::forward<Args>(args)...);
      }

      // 4
      template <class T, class Type, class T1, class... Args,
         meta::enable_if_t<
            std::is_member_object_pointer<std::decay_t<Type T::*>>::value &&
            std::is_base_of<T, std::decay_t<T1>>::value,
            int> =0
      >
      decltype(auto) invoke_impl_(Type T::* f, T1&& t1, Args&&... args) {
         return std::forward<T1>(t1).*f;
      }

      // 5
      template <class T, class Type, class T1, class... Args,
         meta::enable_if_t<
            std::is_member_object_pointer<std::decay_t<Type T::*>>::value &&
            is_ref_wrapper<std::decay_t<T1>>::value,
            int> =0
      >
      decltype(auto) invoke_impl_(Type T::* f, T1&& t1, Args&&... args) {
         return t1.get().*f;
      }

      // 6
      template <class T, class Type, class T1, class... Args,
         meta::enable_if_t<
            std::is_member_object_pointer<std::decay_t<Type T::*>>::value &&
            !std::is_base_of<T, std::decay_t<T1>>::value &&
            !is_ref_wrapper<std::decay_t<T1>>::value,
            int> =0
      >
      decltype(auto) invoke_impl_(Type T::* f, T1&& t1, Args&&... args) {
         return (*std::forward<T1>(t1)).*f;
      }

      template <class F, class... Args>
      decltype(auto) invoke_impl_(F&& f, Args&&... args) {
         return std::forward<F>(f)(std::forward<Args>(args)...);
      }

   } // namespace detail

   template<typename _Callable, typename... _Args>
   inline decltype(auto) invoke(_Callable&& fn, _Args&&... args) {
      return detail::invoke_impl_(
         std::forward<_Callable>(fn), std::forward<_Args>(args)...
      );
   }

   template <typename F, typename... Args>
   struct is_invocable :
      std::is_constructible<
         std::function<void(Args ...)>,
         std::reference_wrapper<typename std::remove_reference<F>::type>
      > { };

   template <typename R, typename F, typename... Args>
   struct is_invocable_r :
      std::is_constructible<
         std::function<R(Args ...)>,
         std::reference_wrapper<typename std::remove_reference<F>::type>
      > { };

   namespace detail {
      template<typename _Callable, typename... _Args>
      struct try_invoke {
         using type =  decltype (
            detail::invoke_impl_(std::declval<_Callable&&>(), std::declval<_Args&&>()...)
         );
      };

      template<bool B, typename _Callable, typename... _Args>
      struct invoke_result_ {
         using type = meta::nil_;
      };

      template <typename _Callable, typename... _Args>
      struct invoke_result_ <true, _Callable, _Args...> {
         using type = meta::invoke_t<
            meta::quote<try_invoke>, _Callable, _Args...
         >;
      };
   }
   template <typename _Callable, typename... _Args>
   using invoke_result = detail::invoke_result_<
      is_invocable<_Callable, _Args...>::value,
      _Callable,
      _Args...
   >;

   template<typename _Callable, typename... _Args>
   using invoke_result_t = meta::eval <
      invoke_result<_Callable, _Args...>
   >;
}



#endif /* __utl_utility_invoke_h__ */