pocketpy/include/pybind11/internal/types.h

#pragma once

#include "object.h"

namespace pybind11 {
class type : public object {
public:
    using object::object;
    template <typename T>
    static handle handle_of();
};

class iterable : public object {
public:
    using object::object;
    iterable() = delete;
};

class iterator : public object {
public:
    using object::object;
    iterator() = delete;
};

class list : public object {
public:
    using object::object;

    list() : object(vm->new_object<pkpy::List>(pkpy::VM::tp_list), true) {}
};

class tuple : public object {
public:
    using object::object;

    tuple(int n) : object(vm->new_object<pkpy::Tuple>(pkpy::VM::tp_tuple, n), true) {}

    //& operator[](int i){ return _args[i]; }
    // PyVar operator[](int i) const { return _args[i]; }
};

class set : public object {
public:
    using object::object;
    // set() : object(vm->new_object<pkpy::Se>(pkpy::VM::tp_set), true) {}
};

class dict : public object {
public:
    using object::object;

    dict() : object(vm->new_object<pkpy::Dict>(pkpy::VM::tp_dict), true) {}
};

class str : public object {

public:
    using object::object;
    str(const char* c, int len) :
        object(vm->new_object<pkpy::Str>(pkpy::VM::tp_str, c, len), true) {

        };

    str(const char* c = "") : str(c, strlen(c)) {}

    str(const std::string& s) : str(s.data(), s.size()) {}

    str(std::string_view sv) : str(sv.data(), sv.size()) {}

    explicit str(const bytes& b);
    explicit str(handle h);
    operator std::string () const;

    template <typename... Args>
    str format(Args&&... args) const;
};

class int_ : public object {
public:
    using object::object;

    int_(int64_t value) : object(pkpy::py_var(vm, value), true) {}
};

class float_ : public object {
public:
    using object::object;

    float_(double value) : object(pkpy::py_var(vm, value), true) {}
};

class bool_ : public object {
public:
    using object::object;

    bool_(bool value) : object(pkpy::py_var(vm, value), true) {}
};

class function : public object {
public:
    using object::object;
};

class attr_accessor : public object {
private:
    object key;

public:
    template <typename T>
    attr_accessor(const object& obj, T&& key) : object(obj), key(std::forward<T>(key)){};

    template <typename T>
    attr_accessor& operator= (T&& value) & {
        static_assert(std::is_base_of_v<object, std::decay_t<T>>, "T must be derived from object");
        m_ptr = std::forward<T>(value);
        return *this;
    }

    template <typename T>
    attr_accessor& operator= (T&& value) && {
        static_assert(std::is_base_of_v<object, std::decay_t<T>>, "T must be derived from object");
        setattr(*this, key, std::forward<T>(value));
        return *this;
    }
};

inline attr_accessor handle::attr(const char* name) const {
    return attr_accessor(reinterpret_borrow<object>(*this), str(name));
}

inline attr_accessor handle::attr(const handle& name) const {
    return attr_accessor(reinterpret_borrow<object>(*this), reinterpret_borrow<object>(name));
}

inline attr_accessor handle::attr(object&& name) const {
    return attr_accessor(reinterpret_borrow<object>(*this), std::move(name));
}

class item_accessor : public object {
public:
    object key;

public:
    template <typename T>
    item_accessor(const object& obj, T&& key) : object(obj), key(std::forward<T>(key)){};

    template <typename T>
    item_accessor& operator= (T&& value) & {
        static_assert(std::is_base_of_v<object, std::decay_t<T>>, "T must be derived from object");
        m_ptr = std::forward<T>(value);
    }

    template <typename T>
    item_accessor& operator= (object&& value) && {
        static_assert(std::is_base_of_v<object, std::decay_t<T>>, "T must be derived from object");
        setitem(*this, key, std::forward<T>(value));
    }
};

inline item_accessor handle::operator[] (int64_t key) const {
    return item_accessor(reinterpret_borrow<object>(*this), int_(key));
}

inline item_accessor handle::operator[] (const char* key) const {
    return item_accessor(reinterpret_borrow<object>(*this), str(key));
}

inline item_accessor handle::operator[] (const handle& key) const {
    return item_accessor(reinterpret_borrow<object>(*this), reinterpret_borrow<object>(key));
}

inline item_accessor handle::operator[] (object&& key) const {
    return item_accessor(reinterpret_borrow<object>(*this), std::move(key));
}

class args : public tuple {
    using tuple::tuple;
};

class kwargs : public dict {
    using dict::dict;
};

template <typename T>
handle type::handle_of() {
    if constexpr(std::is_same_v<T, object>) { return vm->_t(vm->tp_object); }
#define PYBIND11_TYPE_MAPPER(type, tp)                                                                                 \
    else if constexpr(std::is_same_v<T, type>) { return vm->_t(vm->tp); }
    PYBIND11_TYPE_MAPPER(type, tp_type)
    PYBIND11_TYPE_MAPPER(str, tp_str)
    PYBIND11_TYPE_MAPPER(int_, tp_int)
    PYBIND11_TYPE_MAPPER(float_, tp_float)
    PYBIND11_TYPE_MAPPER(bool_, tp_bool)
    PYBIND11_TYPE_MAPPER(list, tp_list)
    PYBIND11_TYPE_MAPPER(tuple, tp_tuple)
    PYBIND11_TYPE_MAPPER(args, tp_tuple)
    PYBIND11_TYPE_MAPPER(dict, tp_dict)
    PYBIND11_TYPE_MAPPER(kwargs, tp_dict)
#undef PYBIND11_TYPE_MAPPER
    else {
        auto result = vm->_cxx_typeid_map.find(typeid(T));
        if(result != vm->_cxx_typeid_map.end()) { return vm->_t(result->second); }

        vm->TypeError("Type not registered");
    }
}

}  // namespace pybind11