invoker.hpp

Go to the documentation of this file.

 
#ifndef LELY_UTIL_INVOKER_HPP_
#define LELY_UTIL_INVOKER_HPP_
 
#include <lely/libc/functional.hpp>
#include <lely/libc/utility.hpp>
 
#include <tuple>
#include <utility>
 
namespace lely {
namespace util {
 
namespace detail {
 
template <class Tuple>
class invoker {
  Tuple tuple_;
 
  template <::std::size_t... I>
  auto
  invoke_(compat::index_sequence<I...>) noexcept(
      noexcept(compat::invoke(::std::get<I>(::std::move(tuple_))...)))
      -> decltype(compat::invoke(::std::get<I>(::std::move(tuple_))...)) {
    return compat::invoke(::std::get<I>(::std::move(tuple_))...);
  }
 
  using sequence_ =
      compat::make_index_sequence<::std::tuple_size<Tuple>::value>;
 
 public:
  template <class F, class... Args,
            class = typename ::std::enable_if<!::std::is_same<
                typename ::std::decay<F>::type, invoker>::value>::type>
  explicit invoker(F&& f, Args&&... args)
      : tuple_{::std::forward<F>(f), ::std::forward<Args>(args)...} {}
 
  auto
  operator()() noexcept(
      noexcept(::std::declval<invoker&>().invoke_(sequence_{})))
      -> decltype(::std::declval<invoker&>().invoke_(sequence_{})) {
    return invoke_(sequence_{});
  }
};
 
}  // namespace detail

template <class F, class... Args>
using invoker_t =
    detail::invoker<::std::tuple<typename ::std::decay<F>::type,
                                 typename ::std::decay<Args>::type...>>;

template <class F, class... Args>
inline invoker_t<F, Args...>
make_invoker(F&& f, Args&&... args) {
  return invoker_t<F, Args...>{::std::forward<F>(f),
                               ::std::forward<Args>(args)...};
}
 
}  // namespace util
}  // namespace lely
 
#endif  // !LELY_UTIL_INVOKER_HPP_