pocketpy/include/pybind11/internal/class.h

#pragma once

#include "cpp_function.h"

namespace pybind11 {

    class module : public object {

    public:
        using object::object;

        static module import(const char* name) {
            if(name == std::string_view{"__main__"}) {
                return module{vm->_main, true};
            } else {
                return module{vm->py_import(name, false), true};
            }
        }
    };

    // TODO:
    // 1. inheritance
    // 2. virtual function
    // 3. factory function

    template <typename T, typename... Others>
    class class_ : public type {
    public:
        using type::type;

        template <typename... Args>
        class_(const handle& scope, const char* name, Args&&... args) :
            type(vm->new_type_object(scope.ptr(),
                                     name,
                                     vm->tp_object,
                                     false,
                                     pkpy::PyTypeInfo::Vt::get<instance>()),
                 true) {
            pkpy::PyVar mod = scope.ptr();
            mod->attr().set(name, m_ptr);
            vm->_cxx_typeid_map[typeid(T)] = _builtin_cast<pkpy::Type>(m_ptr);
            vm->bind_func(m_ptr, "__new__", -1, [](pkpy::VM* vm, pkpy::ArgsView args) {
                auto cls = _builtin_cast<pkpy::Type>(args[0]);
                return instance::create<T>(cls);
            });
        }

        /// bind constructor
        template <typename... Args, typename... Extra>
        class_& def(init<Args...>, const Extra&... extra) {
            if constexpr(!std::is_constructible_v<T, Args...>) {
                static_assert(std::is_constructible_v<T, Args...>, "Invalid constructor arguments");
            } else {
                bind_function(
                    *this,
                    "__init__",
                    [](T* self, Args... args) { new (self) T(args...); },
                    pkpy::BindType::DEFAULT,
                    extra...);
                return *this;
            }
        }

        /// bind member function
        template <typename Fn, typename... Extra>
        class_& def(const char* name, Fn&& f, const Extra&... extra) {
            using first = std::tuple_element_t<0, callable_args_t<remove_cvref_t<Fn>>>;
            constexpr bool is_first_base_of_v =
                std::is_reference_v<first> && std::is_base_of_v<T, remove_cvref_t<first>>;

            if constexpr(!is_first_base_of_v) {
                static_assert(
                    is_first_base_of_v,
                    "If you want to bind member function, the first argument must be the base class");
            } else {
                bind_function(*this, name, std::forward<Fn>(f), pkpy::BindType::DEFAULT, extra...);
            }

            return *this;
        }

        /// bind operators
        template <typename Operator, typename... Extras>
        class_& def(Operator op, const Extras&... extras) {
            op.execute(*this, extras...);
            return *this;
        }

        // TODO: factory function

        /// bind static function
        template <typename Fn, typename... Extra>
        class_& def_static(const char* name, Fn&& f, const Extra&... extra) {
            bind_function(*this, name, std::forward<Fn>(f), pkpy::BindType::STATICMETHOD, extra...);
            return *this;
        }

        template <typename MP, typename... Extras>
        class_& def_readwrite(const char* name, MP mp, const Extras&... extras) {
            if constexpr(!std::is_member_object_pointer_v<MP>) {
                static_assert(std::is_member_object_pointer_v<MP>,
                              "def_readwrite only supports pointer to data member");
            } else {
                bind_property(*this, name, mp, mp, extras...);
            }
            return *this;
        }

        template <typename MP, typename... Extras>
        class_& def_readonly(const char* name, MP mp, const Extras&... extras) {
            if constexpr(!std::is_member_object_pointer_v<MP>) {
                static_assert(std::is_member_object_pointer_v<MP>,
                              "def_readonly only supports pointer to data member");
            } else {
                bind_property(*this, name, mp, nullptr, extras...);
            }
            return *this;
        }

        template <typename Getter, typename Setter, typename... Extras>
        class_& def_property(const char* name, Getter&& g, Setter&& s, const Extras&... extras) {
            bind_property(*this, name, std::forward<Getter>(g), std::forward<Setter>(s), extras...);
            return *this;
        }

        template <typename Getter, typename... Extras>
        class_& def_property_readonly(const char* name, Getter&& mp, const Extras&... extras) {
            bind_property(*this, name, std::forward<Getter>(mp), nullptr, extras...);
            return *this;
        }

        template <typename Var, typename... Extras>
        class_& def_readwrite_static(const char* name, Var& mp, const Extras&... extras) {
            static_assert(
                dependent_false<Var>,
                "define static properties requires metaclass. This is a complex feature with few use cases, so it may never be implemented.");
            return *this;
        }

        template <typename Var, typename... Extras>
        class_& def_readonly_static(const char* name, Var& mp, const Extras&... extras) {
            static_assert(
                dependent_false<Var>,
                "define static properties requires metaclass. This is a complex feature with few use cases, so it may never be implemented.");
            return *this;
        }

        template <typename Getter, typename Setter, typename... Extras>
        class_&
            def_property_static(const char* name, Getter&& g, Setter&& s, const Extras&... extras) {
            static_assert(
                dependent_false<Getter>,
                "define static properties requires metaclass. This is a complex feature with few use cases, so it may never be implemented.");
            return *this;
        }
    };

    template <typename T, typename... Others>
    class enum_ : public class_<T, Others...> {
        std::map<const char*, pkpy::PyVar> m_values;

    public:
        using class_<T, Others...>::class_;

        template <typename... Args>
        enum_(const handle& scope, const char* name, Args&&... args) :
            class_<T, Others...>(scope, name, std::forward<Args>(args)...) {}

        enum_& value(const char* name, T value) {
            handle var = type_caster<T>::cast(value, return_value_policy::copy);
            this->m_ptr->attr().set(name, var.ptr());
            m_values[name] = var.ptr();
            return *this;
        }

        enum_& export_values() {
            pkpy::PyVar mod = this->m_ptr->attr("__module__");
            for(auto& [name, value]: m_values) {
                mod->attr().set(name, value);
            }
            return *this;
        }
    };
}  // namespace pybind11