FastDelegate.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <cstddef>
#include <new> // IWYU pragma: keep
#include <type_traits>
#include <utility>
 
namespace corium {
namespace internal {
 
template <typename EventType, std::size_t InlineSize = 32>
class EventHandlerDelegate {
    using StubFn = void (*)(void* instance, const EventType& event);
    using DestroyFn = void (*)(void* instance) noexcept;
    using MoveFn = void (*)(void* destStorage, void*& destInstance, void*& srcInstance) noexcept;
 
public:
    EventHandlerDelegate() noexcept = default;
 
    template <
        typename Handler,
        typename Decayed = std::decay_t<Handler>,
        typename = std::enable_if_t<
            !std::is_same_v<Decayed, EventHandlerDelegate> &&
            std::is_invocable_r_v<void, Decayed&, const EventType&>
        >
    >
    explicit EventHandlerDelegate(Handler&& handler)
    {
        static_assert(
            std::is_nothrow_destructible_v<Decayed>,
            "Handler destructor must be noexcept"
        );
        static_assert(
            sizeof(Decayed) <= InlineSize,
            "Handler size exceeds FastDelegate inline storage size! Reduce captured state or increase InlineSize."
        );
        static_assert(
            alignof(Decayed) <= alignof(std::max_align_t),
            "Handler alignment requirement exceeds inline storage alignment."
        );
        static_assert(
            std::is_nothrow_move_constructible_v<Decayed>,
            "Handler must be nothrow move constructible."
        );
 
        void* storage = static_cast<void*>(_inlineStorage);
        ::new (storage) Decayed(std::forward<Handler>(handler));
        _instance = storage;
 
        _destroy = [](void* instance) noexcept {
            reinterpret_cast<Decayed*>(instance)->~Decayed();
        };
 
        _move = [](void* destStorage, void*& destInstance, void*& srcInstance) noexcept {
            auto* src = reinterpret_cast<Decayed*>(srcInstance);
            ::new (destStorage) Decayed(std::move(*src));
            src->~Decayed();
            destInstance = destStorage;
            srcInstance = nullptr;
        };
 
        _stub = [](void* instance, const EventType& event) {
            (*reinterpret_cast<Decayed*>(instance))(event);
        };
    }
 
    EventHandlerDelegate(
        void* srcObj,
        void (*stub)(void* instance, const EventType& event),
        void (*moveFn)(void* destStorage, void*& destInstance, void*& srcInstance) noexcept,
        void (*destroyFn)(void* instance) noexcept
    ) noexcept
    {
        void* storage = static_cast<void*>(_inlineStorage);
        _destroy = destroyFn;
        _move = moveFn;
        _stub = stub;
        if (_move) {
            _move(storage, _instance, srcObj);
        }
    }
 
    ~EventHandlerDelegate()
    {
        reset();
    }
 
    EventHandlerDelegate(EventHandlerDelegate&& rhs) noexcept
    {
        moveFrom(std::move(rhs));
    }
 
    EventHandlerDelegate& operator=(EventHandlerDelegate&& rhs) noexcept
    {
        if (this != &rhs) {
            reset();
            moveFrom(std::move(rhs));
        }
 
        return *this;
    }
 
    EventHandlerDelegate(const EventHandlerDelegate&) = delete;
    EventHandlerDelegate& operator=(const EventHandlerDelegate&) = delete;
 
    void invoke(const EventType& event) const
    {
        assert(_stub && "Invoking an empty EventHandlerDelegate");
 
        if (!_stub) {
            return;
        }
 
        _stub(_instance, event);
    }
 
    void operator()(const EventType& event) const
    {
        invoke(event);
    }
 
    explicit operator bool() const noexcept
    {
        return _stub != nullptr;
    }
 
    void reset() noexcept
    {
        if (_destroy) {
            _destroy(_instance);
        }
 
        _instance = nullptr;
        _stub = nullptr;
        _destroy = nullptr;
        _move = nullptr;
    }
 
private:
    void moveFrom(EventHandlerDelegate&& rhs) noexcept
    {
        _stub = rhs._stub;
        _destroy = rhs._destroy;
        _move = rhs._move;
 
        if (_move) {
            _move(
                static_cast<void*>(_inlineStorage),
                _instance,
                rhs._instance
            );
        } else {
            _instance = nullptr;
        }
 
        rhs._stub = nullptr;
        rhs._destroy = nullptr;
        rhs._move = nullptr;
    }
 
private:
    alignas(std::max_align_t) std::byte _inlineStorage[InlineSize > 0 ? InlineSize : 1]{};
 
    void* _instance = nullptr;
    StubFn _stub = nullptr;
    DestroyFn _destroy = nullptr;
    MoveFn _move = nullptr;
};
 
template <typename EventType, std::size_t InlineSize = 32>
using FastDelegate = EventHandlerDelegate<EventType, InlineSize>;
 
} // namespace internal
 
using internal::EventHandlerDelegate;
using internal::FastDelegate;
 
} // namespace corium