Invoke.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_TEMPLE_INVOKE_H
#define INCLUDE_MOLASSEMBLER_TEMPLE_INVOKE_H

#include <boost/tuple/tuple.hpp>

#include <tuple>
#include <functional>

namespace Scine {
namespace Molassembler {

namespace Temple {
namespace Detail {

template<typename TupleType, typename Function, size_t ... Inds>
auto boostTupleInvokeHelper(
  Function&& function,
  const TupleType& tuple,
  std::index_sequence<Inds...> /* indices */
) {
  return function(
    boost::get<Inds>(tuple)...
  );
}

} // namespace Detail

template<
  typename HT,
  typename TT,
  typename Function
> auto invoke(
  Function&& function,
  const boost::tuples::cons<HT, TT>& tuple
) {
  return Detail::boostTupleInvokeHelper(
    function,
    tuple,
    std::make_index_sequence<
      //std::tuple_size<TupleType>::value
      boost::tuples::length<
        boost::tuples::cons<HT, TT>
      >::value
    >()
  );
}

namespace Detail {

template<class> struct sfinae_true : std::true_type {};

template<typename Function, typename TupleType, size_t ... Inds>
auto invokeHelper(
  Function&& function,
  const TupleType& tuple,
  std::index_sequence<Inds...> /* indices */
) {
  return function(
    std::get<Inds>(tuple)...
  );
}

struct InvokeTester {
  template<typename Function, typename TupleType, std::size_t ... Inds>
  constexpr auto operator() (
    Function&& function,
    const TupleType& tuple,
    std::index_sequence<Inds...> /* inds */
  ) -> decltype(
    function(
      std::declval<
        std::tuple_element_t<Inds, TupleType>
      >()...
    )
  );
};

template<typename Function, typename TupleType>
static auto isTupleCallableTest(int) -> sfinae_true<
  decltype(
    std::declval<InvokeTester>()(
      std::declval<Function>(),
      std::declval<TupleType>(),
      std::make_index_sequence<std::tuple_size<TupleType>::value>()
    )
  )
>;

template<typename Function, typename TupleType, typename... Args>
static auto isTupleCallableTest(long) -> std::false_type;

template<typename Function, typename TupleType, typename... Args>
struct isTupleCallable : decltype(isTupleCallableTest<Function, TupleType, Args...>(0)) {};

} // namespace Detail

template<
  typename Function,
  typename TupleType,
  std::enable_if_t<
    Detail::isTupleCallable<Function, TupleType>::value,
    int
  > = 0
> auto invoke(
  Function&& function,
  const TupleType& tuple
) {
  return Detail::invokeHelper(
    std::forward<Function>(function),
    tuple,
    std::make_index_sequence<
      std::tuple_size<TupleType>::value
    >()
  );
}

template<
  typename Fn,
  typename... Args,
  std::enable_if_t<
    !(sizeof...(Args) == 1 && Detail::isTupleCallable<Fn, Args...>::value)
    && std::is_member_pointer<std::decay_t<Fn>>{},
    int
  > = 0
> constexpr decltype(auto) invoke(Fn&& f, Args&&... args)
noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
{
  return std::mem_fn(f)(std::forward<Args>(args)...);
}

template<
  typename Fn,
  typename... Args,
  std::enable_if_t<
    !(sizeof...(Args) == 1 && Detail::isTupleCallable<Fn, Args...>::value)
    && !std::is_member_pointer<std::decay_t<Fn>>{},
    int
  > = 0
> constexpr decltype(auto) invoke(Fn&& f, Args&&... args)
    noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
{
  return std::forward<Fn>(f)(std::forward<Args>(args)...);
}

namespace Detail {

template<typename Functor>
struct Invoker {
  Functor function;

  Invoker(Functor&& passFunction) : function(passFunction) {}

  template<typename TupleType>
  constexpr auto operator() (const TupleType& tuple) const noexcept(noexcept(invoke(function, tuple))) {
    return invoke(function, tuple);
  }
};

} // namespace Detail

template<typename Functor>
auto make_tuple_callable(Functor&& functor) {
  return Detail::Invoker<Functor>(std::forward<Functor>(functor));
}

} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif