TeaSpeak-Client/native/dist/ext_nan/include/NanEventCallback.h
2020-03-18 23:32:57 +01:00

211 lines
6.2 KiB
C++

#pragma once
#include <functional>
#include <tuple>
#include <memory>
#include <mutex>
#include <uv.h>
#include <nan.h>
namespace Nan {
namespace async_helper {
template <typename...>
struct callback_wrap;
template <typename...>
struct lambda_type;
template<typename lambda, class ret, class klass, class... Args>
struct lambda_type<lambda, ret(klass::*)(Args...) const > {
using void_function = std::function<void(Args...)>;
using result = callback_wrap<Args...>;
inline static void_function wrap(const std::shared_ptr<lambda>& lam) {
return [lam](Args&&... args) { (*lam)(std::forward<Args>(args)...); };
}
};
template<typename lambda, class ret, class klass, class... Args>
struct lambda_type<lambda, ret(klass::*)(Args...) > {
using void_function = std::function<void(Args...)>;
using result = callback_wrap<Args...>;
inline static void_function wrap(const std::shared_ptr<lambda>& lam) {
return [lam](Args&&... args) { (*lam)(std::forward<Args>(args)...); };
}
};
// helper class
template<typename R, template<typename...> class Params, typename... Args, std::size_t... I>
inline R call_helper(std::function<R(Args...)> const& func, Params<Args...> const& params, std::index_sequence<I...>) {
return func(std::forward<Args>((Args&&) std::get<I>(params))...);
}
template <typename... Args>
struct callback_args {
uv_async_t handle{};
bool flag_execute = false;
bool destroy_only = false;
bool option_destroy_run = false; /* execute the callback, even if the haven had been destoryed */
std::mutex destroy_lock;
std::function<void(Args...)> callback;
std::tuple<Args...> arguments;
};
template <bool...>
struct _or_ {
constexpr static bool value = false;
};
template <bool T, bool... Args>
struct _or_<T, Args...> {
constexpr static bool value = T || _or_<Args...>::value;
};
template <typename... Args>
struct callback_scoped {
callback_args<Args...>* handle;
std::function<void(Args&&...)> callback;
std::function<void()> destroy;
callback_scoped(
callback_args<Args...>* handle,
const std::function<void(Args &&...)> &callback,
std::function<void()> destroy
) : callback(callback), destroy(std::move(destroy)), handle(handle) {}
~callback_scoped() { destroy(); }
};
template <typename... Args>
struct callback_wrap {
std::shared_ptr<callback_scoped<Args...>> handle;
void call_cpy(Args... args, bool no_throw = false) const {
if(!this->handle) {
if(no_throw)
return;
throw std::bad_function_call();
}
handle->callback(std::forward<Args>(args)...);
}
void call(Args&&... args, bool no_throw = false) const {
if(!this->handle) {
if(no_throw)
return;
throw std::bad_function_call();
}
handle->callback(std::forward<Args>(args)...);
}
void operator()(Args&&... args) const {
if(!this->handle)
throw std::bad_function_call();
handle->callback(std::forward<Args>(args)...);
}
callback_wrap<Args...>& operator=(const callback_wrap<Args...>& other) {
this->handle = other.handle;
return *this;
}
operator bool() const {
return this->handle != nullptr;
}
callback_wrap<Args...>& operator=(nullptr_t) {
this->handle = nullptr;
return *this;
}
/**
* @returns true if the callback will be called even
* if the handle has been destroyed
*/
[[nodiscard]] bool option_destroyed_execute() const {
if(!this->handle)
std::__throw_logic_error("missing handle");
return this->handle->handle->option_destroy_run;
}
/**
* @param flag
* If true then the callback will be called event
* if the handle has already been destroyed
* @return this
*/
callback_wrap<Args...>& option_destroyed_execute(bool flag) {
if(!this->handle)
throw std::logic_error("missing handle");
this->handle->handle->option_destroy_run = flag;
return *this;
}
};
};
template <typename... Args>
using callback_t = async_helper::callback_wrap<Args...>;
template <typename... Args, bool referenced_args = async_helper::_or_<std::is_reference<Args>::value...>::value>
inline async_helper::callback_wrap<Args...> async_callback(std::function<void(Args...)> callback) {
static_assert(!referenced_args, "Argument references aren't allowed");
using callback_t = std::function<void(Args...)>;
using callback_args = async_helper::callback_args<Args...>;
auto args = new callback_args{};
args->callback = std::move(callback);
args->destroy_only = false;
memset(&args->handle, 0, sizeof(args->handle));
args->handle.data = args;
uv_async_init(Nan::GetCurrentEventLoop(), &args->handle, [](uv_async_t* async) {
auto _args = (callback_args*) async->data;
std::unique_lock destroy_lock(_args->destroy_lock); //This may changed after calling the function (deleted while invoking is an example)
if(!_args->destroy_only || (_args->option_destroy_run && _args->flag_execute)) {
_args->flag_execute = false;
auto arguments = std::move(_args->arguments); //Move the tuple now before it get overridden :)
destroy_lock.unlock();
async_helper::call_helper(_args->callback, arguments, std::index_sequence_for<Args...>{});
destroy_lock.lock();
}
if(_args->destroy_only) {
uv_close((uv_handle_t*) (void*) async, [](uv_handle_t* handle) {
delete (callback_args*) handle->data;
});
}
});
return {
std::make_shared<async_helper::callback_scoped<Args...>>(
args,
[args](Args&&... invoker_args) {
std::lock_guard lock(args->destroy_lock);
args->flag_execute = true;
args->arguments = std::tuple<Args...>{std::forward<Args>(invoker_args)...};
uv_async_send(&args->handle);
},
[args]{
std::lock_guard lock(args->destroy_lock);
args->destroy_only = true;
uv_async_send(&args->handle);
}
)
};
}
/* lambda edition */
template <typename lambda,
typename lambda_info = typename async_helper::lambda_type<lambda, decltype(&lambda::operator())>,
typename result = typename lambda_info::result>
inline result async_callback(lambda&& lam) {
auto handle = std::make_shared<lambda>(std::forward<lambda>(lam));
return async_callback(lambda_info::wrap(handle));
}
}