SquirrelOwnership.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Result.h"
#include "common/RuntimeHandle.h"
#include "common/RuntimeRegistry.h"
#include "common/Value.h"
 
#include <squirrel.h>
#include <simplesquirrel/simplesquirrel.hpp>
 
#include <atomic>
#include <cstdint>
#include <exception>
#include <functional>
#include <limits>
#include <memory>
#include <optional>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <vector>
 
namespace eve::script {
 
enum class ObjectSemantic { Value, Owned, Borrowed };
 
[[nodiscard]] inline const char* objectSemanticName(ObjectSemantic semantic) noexcept {
    switch (semantic) {
        case ObjectSemantic::Value: return "value";
        case ObjectSemantic::Owned: return "owned";
        case ObjectSemantic::Borrowed: return "borrowed";
    }
    return "unknown";
}
 
 
using ScriptValue = eve::Value;
 
class EVENGINE_API_FOUNDATION_INLINE BorrowedSquirrelObject {
public:
    constexpr BorrowedSquirrelObject() noexcept = default;
    explicit constexpr BorrowedSquirrelObject(const ssq::Object* object) noexcept : object_(object) {}
 
    [[nodiscard]] constexpr const ssq::Object* get() const noexcept { return object_; }
    [[nodiscard]] bool isBound() const noexcept { return object_ != nullptr && !object_->isEmpty(); }
 
private:
    const ssq::Object* object_ = nullptr;
};
 
[[nodiscard]] inline BorrowedSquirrelObject borrowSquirrelObject(const ssq::Object& object) noexcept {
    return BorrowedSquirrelObject(&object);
}
 
class EVENGINE_API ISquirrelRootReleaser {
public:
    static constexpr const char* capabilityName = "eve.script.ISquirrelRootReleaser";
    virtual ~ISquirrelRootReleaser()            = default;
    virtual void releaseSquirrelRoots() noexcept = 0;
};
 
class EVENGINE_API_FOUNDATION_INLINE OwnedSquirrelObject {
public:
    OwnedSquirrelObject() = default;
    explicit OwnedSquirrelObject(ssq::Object object) noexcept : object_(std::move(object)) {}
 
    OwnedSquirrelObject(const OwnedSquirrelObject&)                = delete;
    OwnedSquirrelObject& operator=(const OwnedSquirrelObject&)     = delete;
    OwnedSquirrelObject(OwnedSquirrelObject&&) noexcept            = default;
    OwnedSquirrelObject& operator=(OwnedSquirrelObject&&) noexcept = default;
    ~OwnedSquirrelObject()                                         = default;
 
    [[nodiscard]] const ssq::Object& get() const noexcept { return object_; }
    [[nodiscard]] bool isBound() const noexcept { return !object_.isEmpty(); }
    [[nodiscard]] ssq::Object release() && noexcept { return std::move(object_); }
 
private:
    ssq::Object object_;
};
 
[[nodiscard]] inline eve::Result<OwnedSquirrelObject> ownSquirrelObject(BorrowedSquirrelObject borrowed) {
    if (!borrowed.isBound()) {
        return eve::Result<OwnedSquirrelObject>::failure(
            eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,
                                   "cannot own an empty or unbound Squirrel object", {}, {}, "squirrel.ownership"));
    }
    return eve::Result<OwnedSquirrelObject>::success(OwnedSquirrelObject(*borrowed.get()));
}
 
namespace detail {
 
 
template <class T>
[[nodiscard]] inline std::size_t squirrelTypeHash() {
    static const std::size_t value = std::hash<std::string>{}(typeid(T).name());
    return value;
}
 
template <class T>
SQInteger ownedInstanceReleaseHook(SQUserPointer pointer, SQInteger) noexcept {
    delete static_cast<T*>(pointer);
    return 0;
}
 
}  // namespace detail
 
 
namespace detail {
 
// squirrelTypeHash, ownedInstanceReleaseHook and ownedInstanceDestroy are
// declared earlier in this header, before RuntimeObjectRegistry, because the
// registry's constructor needs ownedInstanceDestroy<T>.
 
using SquirrelReleaseHook = SQInteger (*)(SQUserPointer, SQInteger);
 
[[nodiscard]] EVENGINE_API Diagnostic ownedInstanceArgumentDiagnostic();
 
[[nodiscard]] EVENGINE_API eve::Result<ssq::Object> makeOwnedSquirrelInstanceRaw(HSQUIRRELVM vm, void* object,
                                                                                 SquirrelReleaseHook  releaseHook,
                                                                                 OwnedInstanceDestroy destroy,
                                                                                 std::size_t          typeHash);
 
}  // namespace detail
 
template <class T>
[[nodiscard]] eve::Result<ssq::Object> makeOwnedSquirrelInstance(HSQUIRRELVM vm, Owned<T> object) {
    if (!vm || !object) {
        return eve::Result<ssq::Object>::failure(detail::ownedInstanceArgumentDiagnostic());
    }
    return detail::makeOwnedSquirrelInstanceRaw(vm, static_cast<void*>(object.release()),
                                                &detail::ownedInstanceReleaseHook<T>, &detail::ownedInstanceDestroy<T>,
                                                detail::squirrelTypeHash<T*>());
}
 
}  // namespace eve::script