Module.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
#include "common/Result.h"
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace ssq {
class VM;
class Table;
class Class;
}  // namespace ssq
 
#define SSQ_REG                            \
    static void expose(ssq::Table& table); \
    static void expose(ssq::Class& vm);
 
#define Module_REG(ModuleName)                                                                                     \
    SSQ_REG                                                                                                        \
    virtual std::string getName() const override { return name; }                                                  \

    [[nodiscard("module instance ownership must be retained or explicitly handled")]] static ModuleName* create(); \
    static const char*                                                                                   name
 
#define Module_IMPL(ModuleName, newExpr) \
    ModuleRegister ModuleName##_register(ModuleName::name, \
        (ModuleManager::creator_t)(ModuleName::create), ModuleName::expose); \
    ModuleName* ModuleName::create() { \
        auto* p = ModuleManager::find(name); \
        if (p) return static_cast<ModuleName*>(p); \
        ModuleName* n = newExpr; \
        ModuleManager::insert(name, n); \
        return n; \
    } \
    const char* ModuleName::name = #ModuleName
 
#define getModInst(N,T) eve::ModuleManager::getInstance<N::T>(#T)
#define requireModInst(N,T) eve::ModuleManager::requireInstance<N::T>(#T)
 
namespace eve {
 
class Runtime;
 
class EVENGINE_API_FOUNDATION Module {
public:
    virtual ~Module() {}
    virtual std::string getName() const = 0;
};
 
class EVENGINE_API_FOUNDATION ModuleManager {
public:
    typedef Module* (*creator_t)();
    typedef void    (*exposer_t)(ssq::Table&);
 
    static ModuleManager& inst();
 
    [[nodiscard("module lookup result must be checked before use")]] static Module* find(const char* name);
    static void    insert(const char* name, Module* inst);
 
    static void register_module(const char* name, creator_t c, exposer_t e);
    [[nodiscard("plugin registration outcome must be checked")]] static eve::Result<void> beginPluginRegistration();
    [[nodiscard("plugin registration outcome must be checked")]] static eve::Result<void> finishPluginRegistration(
        bool commit);
    static void expose(Runtime& runtime);
    // Compatibility for embedders that still own their ssq::VM directly.
    static void expose(ssq::VM& vm);
    // Expose modules registered after the initial expose() (e.g. plugins).
    static int  expose_pending();
    static Runtime* runtime();
    static ssq::VM* vm();
    static void detach(Runtime* runtime);
 
    template <typename T>
    [[nodiscard("module lookup result must be checked before use")]] static T* getInstance(const char* name) {
        return static_cast<T*>(getInstanceRaw(name));
    }
 
    template <typename T>
    [[nodiscard("module instance ownership must be retained or explicitly handled")]] static T* requireInstance(
        const char* name) {
        return static_cast<T*>(requireInstanceRaw(name));
    }
 
    static void requireAll();
 
protected:
    static void exposeVM(ssq::VM& vm);
 
private:
    static int ensureScriptEcs();
    static int exposeAllForCompatibility();
 
    // Keep unordered_map lookup and lazy-creation code out of the two public
    // templates. Every module instantiates only the pointer cast; the container
    // implementation is emitted once in Module.cpp.
    static Module* getInstanceRaw(const char* name);
    static Module* requireInstanceRaw(const char* name);
 
protected:
    struct ModuleInfo {
        creator_t creator = nullptr;
        exposer_t exposer = nullptr;
        Module*   instance = nullptr;
        bool      exposed  = false;
    };
 
    std::unordered_map<std::string, ModuleInfo> registered_modules;
    bool plugin_registration_active_ = false;
    std::vector<std::string> plugin_registration_added_;
    std::string plugin_registration_error_;
    Runtime* active_runtime_ = nullptr;
 
    friend struct ModuleBindAccess;
};
 
struct EVENGINE_API_FOUNDATION ModuleRegister {
    ModuleRegister(const char* name, ModuleManager::creator_t c, ModuleManager::exposer_t e);
};
 
 
}  // namespace eve