nerix
0f11a9050a
* fix: take handler for `sol_lua_check` as function reference * changelog * fix: includes * uintptr type * fix: ub and eq
83 lines
2.4 KiB
C++
83 lines
2.4 KiB
C++
#pragma once
|
|
|
|
#include <concepts>
|
|
#include <cstdint>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
namespace chatterino {
|
|
|
|
/// A non-owning, type-erased reference to a callable. Callables can be lambdas,
|
|
/// functions, or std::functions.
|
|
///
|
|
/// It is intended to be used for functions taking a callback that is called
|
|
/// immediately (such as filter/map functions). Since this doesn't own the
|
|
/// callable, it's not safe to store.
|
|
///
|
|
/// This is based on llvm::function_ref (updated for C++ 20).
|
|
template <typename Fn>
|
|
class FunctionRef;
|
|
|
|
template <typename Ret, typename... Params>
|
|
class FunctionRef<Ret(Params...)>
|
|
{
|
|
public:
|
|
FunctionRef() = default;
|
|
FunctionRef(std::nullptr_t)
|
|
{
|
|
}
|
|
|
|
template <typename Callable>
|
|
FunctionRef(Callable &&callable) // NOLINT
|
|
requires
|
|
// This is not the copy-constructor.
|
|
(!std::same_as<std::remove_cvref_t<Callable>, FunctionRef>) &&
|
|
// Functor must be callable and return a suitable type.
|
|
(std::is_void_v<Ret> ||
|
|
std::convertible_to<
|
|
decltype(std::declval<Callable>()(std::declval<Params>()...)),
|
|
Ret>)
|
|
: callback(callTrampoline<std::remove_reference_t<Callable>>)
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
|
|
, callable(reinterpret_cast<uintptr_t>(&callable))
|
|
{
|
|
}
|
|
|
|
Ret operator()(Params... params) const
|
|
{
|
|
return this->callback(this->callable, std::forward<Params>(params)...);
|
|
}
|
|
|
|
explicit operator bool() const
|
|
{
|
|
return this->callback != nullptr;
|
|
}
|
|
|
|
bool operator==(const FunctionRef &other) const
|
|
{
|
|
return this->callback == other.callback &&
|
|
this->callable == other.callable;
|
|
}
|
|
|
|
bool operator!=(const FunctionRef &other) const = default;
|
|
|
|
private:
|
|
// same signature as callTrampoline
|
|
using Callback = Ret(uintptr_t, Params...);
|
|
|
|
/// Pointer to the call trampoline that, given the callable, calls the target function.
|
|
Callback *callback = nullptr;
|
|
/// Pointer to the actual function
|
|
uintptr_t callable = 0;
|
|
|
|
template <typename Callable>
|
|
static Ret callTrampoline(uintptr_t callable, Params... params)
|
|
{
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
|
|
return (*reinterpret_cast<Callable *>(callable))(
|
|
std::forward<Params>(params)...);
|
|
}
|
|
};
|
|
|
|
} // namespace chatterino
|