Wrapper for both lambdas and std::function

Question

I want to create a function which takes a lambda, std::function or regular function as input and wraps it into something like the next function:

void original_function(const int x, float y) { 
    // do smth ...
}
...
using WrapperType = std::function<void(const QVariantList &)>;
WrapperType original_function_wrapper = [original_function](const QVariantList &vl) { 
    original_function(vl.value(0).value<int>(), vl.value(1).value<float>());
};

So I created few helpers to deal with my problem:

template<size_t index, typename T>
T unpackFromVariant(const QVariantList &v) {
    return qvariant_cast<T>(v.value(static_cast<int>(index)));
};


template<typename T>
struct function_traits;

template<typename Ret, typename... Args>
struct function_traits<Ret(Args...)> {
    enum { ArgumentCount = sizeof...(Args) };

    using ArgumentTypes = std::tuple<Args...>;
    using ReturnType = Ret;
};

template<typename Ret, typename... Args>
struct function_traits<std::function<Ret(Args...)>> {
    enum { ArgumentCount = sizeof...(Args) };

    using ArgumentTypes = std::tuple<Args...>;
    using ReturnType = Ret;
};

template<size_t index, typename T>
struct type_of {
    using Type = typename std::remove_reference<decltype(std::get<index>(T()))>::type;
};


using WrapperFunctionType = std::function<void(const QVariantList &)>;

template<typename FT, typename T, size_t... I>
WrapperFunctionType createWrapperImpl(T &&functor, std::index_sequence<I...>) {
    return [ff = std::forward<T>(functor)](const QVariantList &vl) {
        ff(unpackFromVariant<I, typename type_of<I, typename FT::ArgumentTypes>::Type>(vl) ...);
    };
};

template<typename T>
WrapperFunctionType createWrapper(T &&functor) {
    using TT = typename std::remove_reference<T>::type;
    using FunctionTraits = function_traits<TT>;
    using Indices = std::make_index_sequence<FunctionTraits::ArgumentCount>;

    return createWrapperImpl<FunctionTraits>(std::forward<T>(functor), Indices());
}

It works well with std::function and regular functions, but it's useless with lambdas (it means that each time I want to pass lambda-function as argument I must wrap it with std::function(RET_VAL(ARGS)) firstly). Is there any ways to specialize function_traits template to deduce lambda argument types?

What should it do with `[&](auto&&...args){return sizeof...(args);}`? In general, lambdas and function objects do not have a fixed signature; assuming they do is often a bad idea. Deducing a fixed signature if it exists is possible, simple start with `template struct function_traits:function_traits{};` or somesuch. — Yakk - Adam Nevraumont, Apr 18 '17 at 03:53

score 1 · Accepted Answer · edited May 23 '17 at 12:32

I would start with:

template<class...Args, class F>
std::result_of_t<F(Args&&...)>
apply_variant( F&& f, QVariantList& list ){
  auto indexer=index_upto<sizeof...(Args)>();
  return indexer([&](auto...Is)->decltype(auto){
    return std::forward<F>(f)( list.value(Is).value<Args>()... );
  };
}

where here is index_upto.

Now we step back:

template<class...Args, class F>
WrapperFunctionType createWrapper(F&& f){
  return [f=std::forward<F>(f)](auto& list)mutable->decltype(auto){
    return apply_variant<Args...>( f, list );
  };
}
template<class R, class...Args>
WrapperFunctionType createWrapper(std::function<R(Args...)> f){
  return [f=std::move(f)](auto& list)mutable->decltype(auto){
    return apply_variant<Args...>( f, list );
  };
}
template<class R, class...Args>
WrapperFunctionType createWrapper(R(*f)(Args...)){
  return [f=std::move(f)](auto& list)mutable->decltype(auto){
    return apply_variant<Args...>( f, list );
  };
}

Now, this version you have to pass the types you expect to call the function object with.

We could do the ill advised one:

namespace details{
  template<class T>struct tag_t{};
  template<class...Args, class R, class U, class F>
  WrapperFunctionType createWrapper(tag_t<R(U::*)(Args...)>, F&& f){
    return [f=std::forward<F>(f)](auto& list)mutable->decltype(auto){
      return apply_variant<std::remove_reference_t<Args>...>( f, list );
    };
  }
}
template<class F>
WrapperFunctionType createWrapper(F&& f){
  using dF=std::decay_t<F>;
  using sig_t = details::tag_t<decltype(&dF::operator())>;
  return details::createWrapper( sig_t{}, std::forward<F>(f) );
}

or somesuch.

Code not compiled.

Thank you for reply. In my code I've just added `struct function_traits` and then `struct function_traits : public function_traits` as you suggested earlier and that resolved a problem. — BBQ, Apr 18 '17 at 04:15

Wrapper for both lambdas and std::function

1 Answers1