Subscription.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <utility>
#include <vector>
 
namespace eve {
 
class EVENGINE_API_FOUNDATION Subscription {
public:
    using Cancel = std::function<void()>;
 
    Subscription() noexcept = default;
 
    explicit Subscription(Cancel cancel);
 
    Subscription(const Subscription &)            = delete;
    Subscription &operator=(const Subscription &) = delete;
    Subscription(Subscription &&other) noexcept;
    Subscription &operator=(Subscription &&other) noexcept;
    ~Subscription();
 
    void dispose() noexcept;
 
    bool disposed() const noexcept { return disposed_; }
 
    bool isDisposed() const noexcept { return disposed(); }
 
private:
    Cancel cancel_;
    bool   disposed_ = true;
};
 
template <typename... Args>
class Observer {
public:
    using Callback = std::function<void(const Args &...)>;
 
    Observer() : state_(std::make_shared<State>()) {}
    Observer(const Observer &)            = delete;
    Observer &operator=(const Observer &) = delete;
    Observer(Observer &&)                 = delete;
    Observer &operator=(Observer &&)      = delete;
    ~Observer()                           = default;
 
    [[nodiscard("retain Subscription or explicitly dispose it")]] Subscription subscribe(Callback callback) {
        compactInactive();
        if (!callback) return {};
 
        auto entry      = std::make_shared<Entry>();
        entry->id       = state_->nextId++;
        entry->callback = std::move(callback);
        state_->entries.push_back(entry);
 
        const std::weak_ptr<State> weakState = state_;
        return Subscription([weakState, entry]() noexcept {
            entry->active = false;
            if (const auto state = weakState.lock()) {
                std::erase_if(state->entries,
                              [&entry](const std::shared_ptr<Entry> &candidate) { return candidate == entry; });
            }
        });
    }
 
    void notify(const Args &...args) {
        const auto snapshot = state_->entries;
        for (const auto &entry : snapshot) {
            if (!entry->active || !entry->callback) continue;
            // Copy outside any registry lock (the registry deliberately has no
            // lock) so callback destruction/re-entrancy cannot invalidate the
            // callable being invoked.
            Callback callback = entry->callback;
            if (entry->active && callback) callback(args...);
        }
    }
 
    template <typename FailureHandler>
    [[nodiscard]] std::size_t notifyChecked(FailureHandler &&onFailure, const Args &...args) {
        const auto  snapshot = state_->entries;
        std::size_t failures = 0;
        for (const auto &entry : snapshot) {
            if (!entry->active || !entry->callback) continue;
            Callback callback = entry->callback;
            if (!entry->active || !callback) continue;
            try {
                callback(args...);
            } catch (...) {
                ++failures;
                std::forward<FailureHandler>(onFailure)();
            }
        }
        return failures;
    }
 
    std::size_t size() const noexcept {
        std::size_t count = 0;
        for (const auto &entry : state_->entries)
            if (entry->active) ++count;
        return count;
    }
 
    void compactInactive() {
        std::erase_if(state_->entries, [](const std::shared_ptr<Entry> &entry) { return !entry->active; });
    }
 
private:
    struct Entry {
        std::uint64_t id = 0;
        Callback      callback;
        bool          active = true;
    };
 
    struct State {
        std::uint64_t                       nextId = 1;
        std::vector<std::shared_ptr<Entry>> entries;
    };
 
    std::shared_ptr<State> state_;
};
 
}  // namespace eve