utils_signal.hpp

#ifndef LXGUI_UTILS_SIGNAL_HPP
#define LXGUI_UTILS_SIGNAL_HPP
 
#include "lxgui/utils.hpp"
#include "lxgui/utils_observer.hpp"
#include "lxgui/utils_view.hpp"
 
#include <algorithm>
#include <functional>
#include <memory>
#include <vector>
 
namespace lxgui::utils {
 
namespace signal_impl {
 
struct slot_base {
    bool disconnected = false;
};
 
} // namespace signal_impl
 
class connection {
    template<typename T>
    friend class signal;
 
    explicit connection(utils::observer_ptr<signal_impl::slot_base> slot) noexcept :
        slot_(std::move(slot)) {}
 
public:
    connection() = default;
 
    // Copiable, movable.
    connection(const connection&) = default;
    connection(connection&&)      = default;
    connection& operator=(const connection&) = default;
    connection& operator=(connection&&) = default;
 
    void disconnect() noexcept {
        if (auto* raw = slot_.get()) {
            raw->disconnected = true;
            slot_             = nullptr;
        }
    }
 
    [[nodiscard]] bool connected() const noexcept {
        if (auto* raw = slot_.get())
            return !raw->disconnected;
        else
            return false;
    }
 
private:
    utils::observer_ptr<signal_impl::slot_base> slot_;
};
 
class scoped_connection : private connection {
public:
    scoped_connection() = default;
 
    scoped_connection(connection c) noexcept : connection(std::move(c)) {}
 
    ~scoped_connection() noexcept {
        disconnect();
    }
 
    // Non-copiable, movable.
    scoped_connection(const scoped_connection&) = delete;
    scoped_connection(scoped_connection&&)      = default;
    scoped_connection& operator=(const scoped_connection&) = delete;
    scoped_connection& operator=(scoped_connection&&) = default;
 
    using connection::disconnect;
 
    using connection::connected;
};
 
template<typename T>
class signal {
public:
    using function_type = std::function<T>;
 
private:
    struct slot : signal_impl::slot_base {
        explicit slot(function_type func) noexcept : callback(std::move(func)) {}
 
        function_type callback;
    };
 
    template<typename U>
    using container_type = std::vector<U>;
 
    using slot_list = container_type<utils::owner_ptr<slot>>;
 
    template<typename BaseIterator>
    struct slot_dereferencer {
        using data_type = const function_type&;
        static data_type dereference(const BaseIterator& iter) noexcept {
            return (*iter)->callback;
        }
    };
 
    template<typename BaseIterator>
    struct non_disconnected_filter {
        static bool is_included(const BaseIterator& iter) noexcept {
            return !(*iter)->disconnected;
        }
    };
 
public:
    using slot_list_view =
        utils::view::adaptor<slot_list, slot_dereferencer, non_disconnected_filter>;
 
    signal() : impl_(std::make_shared<implementation>()) {}
 
    ~signal() {
        // Mark all slots as disconnected, in case the destructor
        // is called midway through the signal being emitted.
        disconnect_all();
    }
 
    // Non-copiable, movable.
    signal(const signal&) = delete;
    signal(signal&&)      = default;
    signal& operator=(const signal&) = delete;
    signal& operator=(signal&&) = default;
 
    void disconnect_all() noexcept {
        if (impl_->recursion == 0u) {
            impl_->slots.clear();
            return;
        }
 
        // We are in the middle of an iteration; just mark slot as
        // disconnected. The slots will not be called, however they still
        // occupy a spot in the slot list. This is done to avoid invalidating
        // iterators while iterating over the slot list, if one of the
        // slot happens to disconnect itself. The memory will be cleared
        // up when the signal is no longer being iterated on.
        for (auto& slt : impl_->slots)
            slt->disconnected = true;
    }
 
    [[nodiscard]] bool empty() const noexcept {
        const auto& slots = impl_->slots;
        return std::none_of(
            slots.begin(), slots.end(), [](const auto& slt) { return !slt->disconnected; });
    }
 
    [[nodiscard]] slot_list_view slots() const noexcept {
        return slot_list_view(impl_->slots);
    }
 
    connection connect(function_type function) {
        impl_->slots.push_back(utils::make_owned<slot>(std::move(function)));
        return connection(impl_->slots.back());
    }
 
    template<typename... Args>
    void operator()(Args&&... args) {
        // Make a shared-ownership copy of the slot list, so that the list
        // survives even if this signal is destroyed midway during a slot.
        // To support this, we must not use any member variable or member
        // function of the signal object, which may be destroyed at any time.
        [[maybe_unused]] const auto impl_copy_ptr = impl_;
        auto&                       impl          = *impl_;
        const auto&                 slots         = impl.slots;
        auto&                       recursion     = impl.recursion;
 
        ++recursion;
 
        // Call the slots
        // NB: Cache the size here, so new slots connected will not trigger
        // NB: Use integer-based iteration since iterators may be invalidated on insertion
        const std::size_t num_slots = slots.size();
        for (std::size_t i = 0; i < num_slots; ++i) {
            auto& slt = *slots[i];
            if (!slt.disconnected)
                slt.callback(args...);
        }
 
        --recursion;
 
        if (recursion == 0u)
            impl.garbage_collect();
    }
 
private:
    struct implementation {
        slot_list   slots;
        std::size_t recursion = 0u;
 
        void garbage_collect() noexcept {
            auto iter = std::remove_if(
                slots.begin(), slots.end(), [](const auto& slt) { return slt->disconnected; });
 
            slots.erase(iter, slots.end());
        }
    };
 
    std::shared_ptr<implementation> impl_;
};
 
} // namespace lxgui::utils
 
#endif