functor2c.hpp

Go to the documentation of this file.

#ifndef __FUNCTOR2C_HPP__
#define __FUNCTOR2C_HPP__
 
#include <functional>
#include <utility>
 
namespace functor2c {
 
namespace detail {

template<bool destroy_on_invoke, typename RetType, typename... Args>
struct destroyable_function {
    struct deleter {
        void operator()(void *userdata) const {
            destroy(userdata);
        }
    };
 
    template<typename Fn>
    destroyable_function(Fn&& fn) : function(std::move(fn)) {}
 
    RetType operator()(Args... args) {
        std::unique_ptr<destroyable_function> destroyer;
        if (destroy_on_invoke) {
            destroyer = std::unique_ptr<destroyable_function>(this);
        }
        return function(std::forward<Args>(args)...);
    }
 
    std::tuple<void*, RetType (*)(void*, Args...)> prefix_invoker() {
        return std::make_tuple(static_cast<void*>(this), invoke_prefix);
    }
    std::tuple<void*, RetType (*)(void*, Args...), void (*)(void*)> prefix_invoker_deleter() {
        return std::make_tuple(static_cast<void*>(this), invoke_prefix, destroy);
    }
    std::tuple<std::unique_ptr<void, deleter>, RetType (*)(void*, Args...)> prefix_invoker_unique() {
        return std::make_tuple(std::unique_ptr<void, deleter>(static_cast<void*>(this)), invoke_prefix);
    }
    std::tuple<std::shared_ptr<void>, RetType (*)(void*, Args...)> prefix_invoker_shared() {
        return std::make_tuple(std::shared_ptr<void>(static_cast<void*>(this), destroy), invoke_prefix);
    }
 
    std::tuple<RetType (*)(Args..., void*), void*> suffix_invoker() {
        return std::make_tuple(invoke_suffix, static_cast<void*>(this));
    }
    std::tuple<RetType (*)(Args..., void*), void*, void (*)(void*)> suffix_invoker_deleter() {
        return std::make_tuple(invoke_suffix, static_cast<void*>(this), destroy);
    }
    std::tuple<RetType (*)(Args..., void*), std::unique_ptr<void, deleter>> suffix_invoker_unique() {
        return std::make_tuple(invoke_suffix, std::unique_ptr<void, deleter>(static_cast<void*>(this)));
    }
    std::tuple<RetType (*)(Args..., void*), std::shared_ptr<void>> suffix_invoker_shared() {
        return std::make_tuple(invoke_suffix, std::shared_ptr<void>(static_cast<void*>(this), destroy));
    }
 
    static RetType invoke_prefix(void *userdata, Args... args) {
        auto self = static_cast<destroyable_function*>(userdata);
        return (*self)(std::forward<Args>(args)...);
    }
 
    static RetType invoke_suffix(Args... args, void *userdata) {
        auto self = static_cast<destroyable_function*>(userdata);
        return (*self)(std::forward<Args>(args)...);
    }
 
    static void destroy(void *userdata) {
        auto self = static_cast<destroyable_function*>(userdata);
        delete self;
    }
 
private:
    std::function<RetType(Args...)> function;
};
 
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<void*, RetType (*)(void*, Args...), void (*)(void*)> prefix_invoker_deleter(Fn&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->prefix_invoker_deleter();
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<void*, RetType (*)(void*, Args...)> prefix_invoker_oneshot(Fn&& fn) {
    return (new detail::destroyable_function<true, RetType, Args...>(std::move(fn)))->prefix_invoker();
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<std::unique_ptr<void, typename detail::destroyable_function<false, RetType, Args...>::deleter>, RetType (*)(void*, Args...)> prefix_invoker_unique(Fn&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->prefix_invoker_unique();
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<std::shared_ptr<void>, RetType (*)(void*, Args...)> prefix_invoker_shared(Fn&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->prefix_invoker_shared();
}
 

template<typename RetType, typename... Args, typename Fn>
std::tuple<void*, RetType (*)(Args..., void*), void (*)(void*)> suffix_invoker_deleter(Fn&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->suffix_invoker_deleter();
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<void*, RetType (*)(Args..., void*)> suffix_invoker_oneshot(Fn&& fn) {
    return (new detail::destroyable_function<true, RetType, Args...>(std::move(fn)))->suffix_invoker();
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<std::unique_ptr<void, typename detail::destroyable_function<false, RetType, Args...>::deleter>, RetType (*)(Args..., void*)> suffix_invoker_unique(Fn&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->suffix_invoker_unique();
}

template<typename RetType, typename... Args, typename Fn>
std::tuple<std::shared_ptr<void>, RetType (*)(Args..., void*)> suffix_invoker_shared(Fn&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->suffix_invoker_shared();
}
 
 
#if __cplusplus >= 201703L

template<typename RetType, typename... Args>
auto prefix_invoker_deleter(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->prefix_invoker_deleter();
}

template<typename Fn>
auto prefix_invoker_deleter(Fn&& fn) {
    return prefix_invoker_deleter(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto prefix_invoker_oneshot(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<true, RetType, Args...>(std::move(fn)))->prefix_invoker();
}

template<typename Fn>
auto prefix_invoker_oneshot(Fn&& fn) {
    return prefix_invoker_oneshot(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto prefix_invoker_unique(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->prefix_invoker_unique();
}

template<typename Fn>
auto prefix_invoker_unique(Fn&& fn) {
    return prefix_invoker_unique(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto prefix_invoker_shared(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->prefix_invoker_shared();
}

template<typename Fn>
auto prefix_invoker_shared(Fn&& fn) {
    return prefix_invoker_shared(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto suffix_invoker_deleter(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->suffix_invoker_deleter();
}

template<typename Fn>
auto suffix_invoker_deleter(Fn&& fn) {
    return suffix_invoker_deleter(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto suffix_invoker_oneshot(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<true, RetType, Args...>(std::move(fn)))->suffix_invoker();
}

template<typename Fn>
auto suffix_invoker_oneshot(Fn&& fn) {
    return suffix_invoker_oneshot(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto suffix_invoker_unique(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->suffix_invoker_unique();
}

template<typename Fn>
auto suffix_invoker_unique(Fn&& fn) {
    return suffix_invoker_unique(std::move(std::function(fn)));
}

template<typename RetType, typename... Args>
auto suffix_invoker_shared(std::function<RetType(Args...)>&& fn) {
    return (new detail::destroyable_function<false, RetType, Args...>(std::move(fn)))->suffix_invoker_shared();
}

template<typename Fn>
auto suffix_invoker_shared(Fn&& fn) {
    return prefix_invoker_shared(std::move(std::function(fn)));
}
 
#endif
 
}
 
#endif  // __FUNCTOR2C_HPP__