CapabilityOwned.h

浏览该文件的文档.

#pragma once
 
#include "common/Capability.h"
#include "common/Diagnostic.h"
#include "common/Export.h"
#include "common/Result.h"
#include "common/Status.h"
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
 
namespace eve::cap {
 
struct OwnedProviderHandle {
    std::string   id;
    std::uint64_t generation = 0;
 
    [[nodiscard]] friend bool operator==(const OwnedProviderHandle&, const OwnedProviderHandle&) = default;
};
 
template <class I>
class OwnedProviderLease {
public:
    OwnedProviderLease() = default;
 
    [[nodiscard]] const OwnedProviderHandle& handle() const noexcept { return handle_; }
    [[nodiscard]] explicit operator bool() const noexcept { return static_cast<bool>(provider_); }
    [[nodiscard]] I* get() const noexcept { return provider_.get(); }
    [[nodiscard]] I& operator*() const noexcept { return *provider_; }
    [[nodiscard]] I* operator->() const noexcept { return provider_.get(); }
 
private:
    template <class>
    friend class OwnedProviderRegistry;
 
    OwnedProviderLease(OwnedProviderHandle handle, std::shared_ptr<I> provider)
        : handle_(std::move(handle)), provider_(std::move(provider)) {}
 
    OwnedProviderHandle handle_;
    std::shared_ptr<I>  provider_;
};
 
namespace detail {
 
struct OwnedEntryBase {
    virtual ~OwnedEntryBase() = default;
    virtual void* raw() noexcept = 0;
    virtual std::shared_ptr<void> shared() const noexcept = 0;
};
 
template <class I>
struct OwnedEntry final : OwnedEntryBase {
    explicit OwnedEntry(std::shared_ptr<I> provider) : provider(std::move(provider)) {}
    void* raw() noexcept override { return provider.get(); }
    std::shared_ptr<void> shared() const noexcept override { return provider; }
    std::shared_ptr<I> provider;
};
 
struct OwnedSlot {
    OwnedProviderHandle             handle;
    std::unique_ptr<OwnedEntryBase> entry;
};
 
EVENGINE_API_FOUNDATION std::mutex& ownedMutex();
EVENGINE_API_FOUNDATION std::unordered_map<std::string, OwnedSlot>& ownedSlots(const char* capabilityName);
EVENGINE_API_FOUNDATION std::unordered_map<std::string, std::uint64_t>& ownedGenerations(const char* capabilityName);
EVENGINE_API_FOUNDATION void clearOwnedRaw();
 
}  // namespace detail
 
template <class I>
class OwnedProviderRegistry {
public:
    [[nodiscard]] static Result<OwnedProviderHandle> provide(std::string id, std::shared_ptr<I> provider) {
        if (id.empty() || !provider) {
            return Result<OwnedProviderHandle>::failure(Diagnostic::error(
                DiagnosticCode::InvalidArgument, "owned capability requires id and implementation", "id"));
        }
        std::scoped_lock lock(detail::ownedMutex());
        auto&            slots = detail::ownedSlots(I::capabilityName);
        if (slots.contains(id)) {
            return Result<OwnedProviderHandle>::failure(Diagnostic::error(
                DiagnosticCode::Conflict, "owned capability id is already published", "id"));
        }
        auto& generations = detail::ownedGenerations(I::capabilityName);
        OwnedProviderHandle handle{id, ++generations[id]};
        auto [it, inserted] =
            slots.emplace(std::move(id), detail::OwnedSlot{handle, std::make_unique<detail::OwnedEntry<I>>(
                                                                         std::move(provider))});
        (void)inserted;
        // Also expose the current generation through the borrowed single-provider slot so
        // existing `query` / `ProviderRef` consumers see the same instance.
        detail::provideRaw(I::capabilityName, it->second.entry->raw());
        return Result<OwnedProviderHandle>::success(std::move(handle), Status::success(StatusCode::Applied));
    }
 
    [[nodiscard]] static Result<OwnedProviderLease<I>> acquire(const OwnedProviderHandle& handle) {
        std::scoped_lock lock(detail::ownedMutex());
        auto&            slots = detail::ownedSlots(I::capabilityName);
        const auto       found = slots.find(handle.id);
        if (found == slots.end()) {
            const auto& generations = detail::ownedGenerations(I::capabilityName);
            const bool  seen        = generations.contains(handle.id);
            return Result<OwnedProviderLease<I>>::failure(Diagnostic::error(
                seen ? DiagnosticCode::Conflict : DiagnosticCode::Unsupported,
                seen ? "owned capability handle is stale" : "owned capability provider is not available", "handle"));
        }
        if (found->second.handle != handle) {
            return Result<OwnedProviderLease<I>>::failure(
                Diagnostic::error(DiagnosticCode::Conflict, "owned capability handle is stale", "handle"));
        }
        auto typed = std::static_pointer_cast<I>(found->second.entry->shared());
        return Result<OwnedProviderLease<I>>::success(OwnedProviderLease<I>(handle, std::move(typed)),
                                                      Status::success(StatusCode::Applied));
    }
 
    [[nodiscard]] static Result<OwnedProviderLease<I>> acquire(std::string_view id) {
        std::scoped_lock lock(detail::ownedMutex());
        auto&            slots = detail::ownedSlots(I::capabilityName);
        const auto       found = slots.find(std::string(id));
        if (found == slots.end()) {
            return Result<OwnedProviderLease<I>>::failure(Diagnostic::error(
                DiagnosticCode::Unsupported, "owned capability provider is not available", "id"));
        }
        auto typed = std::static_pointer_cast<I>(found->second.entry->shared());
        return Result<OwnedProviderLease<I>>::success(
            OwnedProviderLease<I>(found->second.handle, std::move(typed)), Status::success(StatusCode::Applied));
    }
 
    [[nodiscard]] static Result<void> unload(const OwnedProviderHandle& handle) {
        std::shared_ptr<void> keepAlive;
        {
            std::scoped_lock lock(detail::ownedMutex());
            auto&            slots = detail::ownedSlots(I::capabilityName);
            const auto       found = slots.find(handle.id);
            if (found == slots.end() || found->second.handle != handle) {
                return Result<void>::failure(
                    Diagnostic::error(DiagnosticCode::Conflict, "owned capability handle is stale", "handle"));
            }
            // Use auto (not void*) so the local is not linted as a public pointer API.
            const auto borrowed = found->second.entry->raw();
            keepAlive = found->second.entry->shared();
            slots.erase(found);
            detail::revokeRaw(I::capabilityName, borrowed);
        }
        (void)keepAlive;
        return Result<void>::success(Status::success(StatusCode::Applied));
    }
};
 
}  // namespace eve::cap