EditorScriptProjection.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
#include "common/SquirrelBindContext.h"
#include "common/SquirrelBinding.h"
#include "common/SquirrelOwnership.h"
#include "common/Value.h"
#include "editor/EditorWorkspace.h"
 
#include <simplesquirrel/simplesquirrel.hpp>
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <utility>
 
namespace eve::editor {
 
[[nodiscard]] inline ssq::Table project(HSQUIRRELVM vm, const eve::Result<void>& result) {
    return script::projectStatusResult(vm, result.status());
}
 
template <class T>
[[nodiscard]] inline ssq::Table project(HSQUIRRELVM vm, const eve::Result<T>& result, Value value) {
    if (!result.ok()) return script::projectStatusResult(vm, result.status());
    return script::projectStatusResult(vm, result.status(), std::move(value));
}
 
[[nodiscard]] inline ssq::Table bindingFailure(HSQUIRRELVM vm, const char* source, DiagnosticCode code,
                                               std::string message, std::string path = {}) {
    return script::projectStatusResult(
        vm, Status::failure(Diagnostic::error(code, std::move(message), std::move(path), {}, source ? source : "")));
}
 
template <class T>
[[nodiscard]] inline ssq::Table projectHistoryRevision(HSQUIRRELVM vm, const eve::Result<T>& result) {
    return project(vm, result, Value(result.ok() ? static_cast<std::int64_t>(result.value().afterRevision) : 0));
}
 
template <class T>
[[nodiscard]] inline ssq::Table projectOwnedInstance(HSQUIRRELVM vm, std::unique_ptr<T> instance) {
    auto object = script::makeOwnedSquirrelInstance<T>(vm, std::move(instance));
    if (!object) return script::projectStatusResult(vm, object.status());
    ssq::Object owned  = std::move(object).takeValue();
    auto        result = script::projectStatusResult(vm, Status::success(StatusCode::Applied));
    result.set("value", owned);
    result.set("ownership", std::string("owned"));
    return result;
}
 
template <class T>
[[nodiscard]] inline ssq::Table projectOwnedCreate(HSQUIRRELVM vm, const char* source, std::string emptyIdMessage,
                                                   const std::string& targetId) {
    if (targetId.empty())
        return bindingFailure(vm, source, DiagnosticCode::InvalidArgument, std::move(emptyIdMessage), "targetId");
    return projectOwnedInstance<T>(vm, std::make_unique<T>(targetId));
}
 
template <class T>
[[nodiscard]] inline auto addScriptClass(ssq::Table& table, const char* name) {
    return table.addClass<T>(name, std::function<T*()>([]() -> T* { return nullptr; }), true);
}
 
class ScriptBind {
public:
    constexpr ScriptBind(HSQUIRRELVM vm, const char* source) noexcept : ctx_(vm, source) {}
 
    [[nodiscard]] constexpr const script::BindContext& context() const noexcept { return ctx_; }
 
    [[nodiscard]] constexpr HSQUIRRELVM vm() const noexcept { return ctx_.vm(); }
 
    [[nodiscard]] constexpr const char* source() const noexcept { return ctx_.source(); }
 
    [[nodiscard]] ssq::Table fail(DiagnosticCode code, std::string message, std::string path = {}) const {
        return ctx_.fail(code, std::move(message), std::move(path));
    }
 
    template <class Fn>
    [[nodiscard]] ssq::Table checked(bool ready, std::string nullMessage, Fn&& fn, std::string path = {}) const {
        if (!ready) return fail(DiagnosticCode::InvalidArgument, std::move(nullMessage), std::move(path));
        return project(vm(), std::forward<Fn>(fn)());
    }
 
    template <class T, class Fn>
    [[nodiscard]] ssq::Table checked(T* self, std::string nullMessage, Fn&& fn, std::string path = {}) const {
        return checked(self != nullptr, std::move(nullMessage), std::forward<Fn>(fn), std::move(path));
    }
 
    template <class T, class Fn>
    [[nodiscard]] ssq::Table history(T* self, std::string nullMessage, Fn&& fn) const {
        if (!self) return fail(DiagnosticCode::InvalidArgument, std::move(nullMessage));
        return projectHistoryRevision(vm(), std::forward<Fn>(fn)());
    }
 
    template <class T>
    [[nodiscard]] ssq::Table ownedCreate(std::string emptyIdMessage, const std::string& targetId) const {
        return projectOwnedCreate<T>(vm(), source(), std::move(emptyIdMessage), targetId);
    }
 
    template <class T>
    [[nodiscard]] ssq::Table ownedInstance(std::unique_ptr<T> instance) const {
        return projectOwnedInstance<T>(vm(), std::move(instance));
    }
 
private:
    script::BindContext ctx_;
};
 
template <class ScriptT>
inline void registerEditorWorkspace(ssq::Class& cls, const ScriptBind& bind, const char* nullMessage) {
    cls.addFunc("configureWorkspace", [bind, nullMessage](ScriptT* self, EditorWorkspace* workspace) {
        return bind.checked(
            self && workspace, nullMessage, [&] { return self->editor().configureWorkspace(*workspace); }, "workspace");
    });
}
 
template <class EditorT>
inline void registerDirectEditorWorkspace(ssq::Class& cls, const ScriptBind& bind, const char* nullMessage) {
    cls.addFunc("configureWorkspace", [bind, nullMessage](EditorT* self, EditorWorkspace* workspace) {
        return bind.checked(self && workspace, nullMessage, [&] { return self->configureWorkspace(*workspace); });
    });
}
 
template <class ScriptT>
inline void registerEditorHistory(ssq::Class& cls, const ScriptBind& bind, const char* nullMessage) {
    cls.addFunc("undo", [bind, nullMessage](ScriptT* self) {
        return bind.history(self, nullMessage, [&] { return self->editor().undo(); });
    });
    cls.addFunc("redo", [bind, nullMessage](ScriptT* self) {
        return bind.history(self, nullMessage, [&] { return self->editor().redo(); });
    });
    cls.addFunc("canUndo", [](ScriptT* self) { return self && self->editor().canUndo(); });
    cls.addFunc("canRedo", [](ScriptT* self) { return self && self->editor().canRedo(); });
    cls.addFunc("getRevision", [](ScriptT* self) { return self ? static_cast<int>(self->editor().revision()) : 0; });
}
 
template <class ScriptT, class ModuleT>
inline void registerEditorOwnedCreate(ssq::Class& moduleClass, const ScriptBind& bind, const char* emptyIdMessage) {
    moduleClass.addFunc("create", [bind, emptyIdMessage](ModuleT*, const std::string& targetId) {
        return bind.ownedCreate<ScriptT>(emptyIdMessage, targetId);
    });
}
 
}  // namespace eve::editor