EditingExtension.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "editing/EditingIds.h"
#include "editing/EditingResult.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::editing {
 
enum class ThreadAffinity { Main, Render, Worker, Any };
 
struct ExtensionDescriptor {
    std::string id;
    std::uint32_t schemaVersion = 1;
    std::vector<CapabilityId> capabilities;
    std::vector<std::string> requiredModules;
    ThreadAffinity affinity = ThreadAffinity::Main;
    bool callbacksReentrant = false;
};
 
struct ProviderHandle {
    std::string id;
    std::uint64_t generation = 0;
    friend bool operator==(const ProviderHandle&, const ProviderHandle&) = default;
};
 
class IEditingExtensionProvider {
public:
    virtual ~IEditingExtensionProvider() = default;
    [[nodiscard]] virtual Result<void> activate() = 0;
    [[nodiscard]] virtual Result<void> beginUnload() = 0;
    virtual void deactivate() noexcept = 0;
    virtual void* query(const CapabilityId& capability) noexcept = 0;
};
 
class ProviderLease {
public:
    ProviderLease() = default;
    const ProviderHandle& handle() const { return handle_; }
    explicit operator bool() const { return provider_ != nullptr; }
    void* query(const CapabilityId& capability) const noexcept {
        return provider_ ? provider_->query(capability) : nullptr;
    }
private:
    friend class ExtensionProviderRegistry;
    ProviderLease(ProviderHandle handle, std::shared_ptr<IEditingExtensionProvider> provider)
        : handle_(std::move(handle)), provider_(std::move(provider)) {}
    ProviderHandle handle_;
    std::shared_ptr<IEditingExtensionProvider> provider_;
};
 
class EVENGINE_API_PLATFORM ExtensionProviderRegistry {
public:
    ExtensionProviderRegistry();
    ~ExtensionProviderRegistry();
    ExtensionProviderRegistry(const ExtensionProviderRegistry&) = delete;
    ExtensionProviderRegistry& operator=(const ExtensionProviderRegistry&) = delete;
 
    [[nodiscard]] Result<ProviderHandle> registerProvider(
        ExtensionDescriptor descriptor, std::shared_ptr<IEditingExtensionProvider> provider);
    [[nodiscard]] Result<ProviderLease> acquire(const ProviderHandle& handle) const;
    [[nodiscard]] Result<ProviderLease> acquire(const std::string& id) const;
    [[nodiscard]] Result<void> unload(const ProviderHandle& handle);
    std::vector<ExtensionDescriptor> descriptors() const;
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
[[nodiscard]] EVENGINE_API_PLATFORM Result<ProviderHandle> registerStaticProvider(ExtensionProviderRegistry& registry,
                                                                                  ExtensionDescriptor        descriptor,
                                                                                  CapabilityId               capability,
                                                                                  std::shared_ptr<void> implementation);
 
}  // namespace eve::editing