pocketpy/include/pybind11/internal/instance.h

#pragma once

#include "kernel.h"

namespace pybind11 {
struct type_info {
    const char* name;
    std::size_t size;
    std::size_t alignment;
    void (*destructor)(void*);
    void (*copy)(void*, const void*);
    void (*move)(void*, void*);
    const std::type_info* type;

    template <typename T>
    static type_info& of() {
        static_assert(!std::is_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>,
                      "T must not be a reference type or const type.");
        static type_info info = {
            typeid(T).name(),
            sizeof(T),
            alignof(T),
            [](void* ptr) {
                ((T*)ptr)->~T();
                operator delete (ptr);
            },
            [](void* dst, const void* src) {
                new (dst) T(*(const T*)src);
            },
            [](void* dst, void* src) {
                new (dst) T(std::move(*(T*)src));
            },
            &typeid(T),
        };
        return info;
    }
};

// all registered C++ class will be ensured as instance type.
class instance {
public:
    // use to record the type information of C++ class.

private:
    enum Flag {
        None = 0,
        Own = 1 << 0,  // if the instance is owned by C++ side.
        Ref = 1 << 1,  // need to mark the parent object.
    };

    Flag flag;
    void* data;
    const type_info* type;
    pkpy::PyVar parent;
    // pkpy::PyVar

public:
    instance() noexcept : flag(Flag::None), data(nullptr), type(nullptr), parent(nullptr) {}

    instance(const instance&) = delete;

    instance(instance&& other) noexcept : flag(other.flag), data(other.data), type(other.type), parent(other.parent) {
        other.flag = Flag::None;
        other.data = nullptr;
        other.type = nullptr;
        other.parent = nullptr;
    }

    template <typename T>
    static pkpy::PyVar create(pkpy::Type type) {
        instance instance;
        instance.type = &type_info::of<T>();
        instance.data = operator new (sizeof(T));
        instance.flag = Flag::Own;
        return vm->new_object<pybind11::instance>(type, std::move(instance));
    }

    template <typename T>
    static pkpy::PyVar create(T&& value,
                              pkpy::Type type,
                              return_value_policy policy = return_value_policy::automatic_reference,
                              pkpy::PyVar parent = nullptr) noexcept {
        using underlying_type = std::remove_cv_t<std::remove_reference_t<T>>;

        // resolve for automatic policy.
        if(policy == return_value_policy::automatic) {
            policy = std::is_pointer_v<underlying_type> ? return_value_policy::take_ownership
                     : std::is_lvalue_reference_v<T&&>  ? return_value_policy::copy
                                                        : return_value_policy::move;
        } else if(policy == return_value_policy::automatic_reference) {
            policy = std::is_pointer_v<underlying_type> ? return_value_policy::reference
                     : std::is_lvalue_reference_v<T&&>  ? return_value_policy::copy
                                                        : return_value_policy::move;
        }

        auto& _value = [&]() -> auto& {
            /**
             * note that, pybind11 will ignore the const qualifier.
             * in fact, try to modify a const value will result in undefined behavior.
             */
            if constexpr(std::is_pointer_v<underlying_type>) {
                return *reinterpret_cast<underlying_type*>(value);
            } else {
                return const_cast<underlying_type&>(value);
            }
        }();

        instance instance;
        instance.type = &type_info::of<underlying_type>();

        if(policy == return_value_policy::take_ownership) {
            instance.data = &_value;
            instance.flag = Flag::Own;
        } else if(policy == return_value_policy::copy) {
            instance.data = ::new auto(_value);
            instance.flag = Flag::Own;
        } else if(policy == return_value_policy::move) {
            instance.data = ::new auto(std::move(_value));
            instance.flag = Flag::Own;
        } else if(policy == return_value_policy::reference) {
            instance.data = &_value;
            instance.flag = Flag::None;
        } else if(policy == return_value_policy::reference_internal) {
            instance.data = &_value;
            instance.flag = Flag::Ref;
            instance.parent = parent;
        }

        return vm->new_object<pybind11::instance>(type, std::move(instance));
    }

    ~instance() {
        if(flag & Flag::Own) { type->destructor(data); }
    }

    void _gc_mark(pkpy::VM* vm) const noexcept {
        if(parent && (flag & Flag::Ref)) { PK_OBJ_MARK(parent); }
    }

    template <typename T>
    T& cast() noexcept {
        return *static_cast<T*>(data);
    }
};
}  // namespace pybind11