pocketpy/include/pybind11/internal/accessor.h

#pragma once

#include "builtins.h"

namespace pkbind {

template <typename policy>
class accessor : public interface<accessor<policy>> {
    using key_type = typename policy::key_type;

    friend interface<handle>;
    friend interface<accessor<policy>>;
    friend tuple;
    friend list;
    friend dict;

    accessor(handle obj, key_type key) : m_obj(obj), m_value(), m_key(key) {}

public:
    auto ptr() const {
        if(!m_value) { m_value = policy::get(m_obj, m_key); }
        return m_value.ptr();
    }

    template <typename Value>
    accessor& operator= (Value&& value) && {
        policy::set(m_obj, m_key, pkbind::cast(std::forward<Value>(value)));
        return *this;
    }

    template <typename Value>
    accessor& operator= (Value&& value) & {
        m_value = std::forward<Value>(value);
        return *this;
    }

    operator handle () const { return ptr(); }

private:
    handle m_obj;
    mutable handle m_value;
    key_type m_key;
};

namespace policy {
struct attr {
    using key_type = name;

    static handle get(handle obj, name key) {
        raise_call<py_getattr>(obj.ptr(), key.index());
        return py_retval();
    }

    static void set(handle obj, name key, handle value) { raise_call<py_setattr>(obj.ptr(), key.index(), value.ptr()); }
};

template <typename Key>
struct item {
    using key_type = Key;

    static handle get(handle obj, int key) { return get(obj, int_(key)); }

    static handle get(handle obj, name key) { return get(obj, str(key)); }

    static handle get(handle obj, handle key) {
        raise_call<py_getitem>(obj.ptr(), key.ptr());
        return py_retval();
    }

    static void set(handle obj, int key, handle value) { set(obj, int_(key), value); }

    static void set(handle obj, name key, handle value) { set(obj, str(key), value); }

    static void set(handle obj, handle key, handle value) { raise_call<py_setitem>(obj.ptr(), key.ptr(), value.ptr()); }
};

struct tuple {
    using key_type = int;

    static handle get(handle obj, int key) { return py_tuple_getitem(obj.ptr(), key); }

    static void set(handle obj, int key, handle value) { py_tuple_setitem(obj.ptr(), key, value.ptr()); }
};

struct list {
    using key_type = int;

    static handle get(handle obj, int key) { return py_list_getitem(obj.ptr(), key); }

    static void set(handle obj, int key, handle value) { py_list_setitem(obj.ptr(), key, value.ptr()); }
};

template <typename Key>
struct dict {
    using key_type = Key;

    static handle get(handle obj, int key) { return get(obj, int_(key)); }

    static handle get(handle obj, name key) { return get(obj, str(key)); }

    static handle get(handle obj, handle key) {
        raise_call<py_dict_getitem>(obj.ptr(), key.ptr());
        return py_retval();
    }

    static void set(handle obj, int key, handle value) { set(obj, int_(key), value); }

    static void set(handle obj, name key, handle value) { set(obj, str(key), value); }

    static void set(handle obj, handle key, handle value) {
        raise_call<py_dict_setitem>(obj.ptr(), key.ptr(), value.ptr());
    }
};

}  // namespace policy

// implement other methods of interface

template <typename Derived>
inline attr_accessor interface<Derived>::attr(name key) const {
    return {ptr(), key};
}

template <typename Derived>
inline item_accessor<int> interface<Derived>::operator[] (int key) const {
    return {ptr(), key};
}

template <typename Derived>
inline item_accessor<name> interface<Derived>::operator[] (name key) const {
    return {ptr(), key};
}

template <typename Derived>
inline item_accessor<handle> interface<Derived>::operator[] (handle key) const {
    return {ptr(), key};
}

inline tuple_accessor tuple::operator[] (int index) const { return {m_ptr, index}; }

inline list_accessor list::operator[] (int index) const { return {m_ptr, index}; };

inline dict_accessor<int> dict::operator[] (int key) const { return {m_ptr, key}; }

inline dict_accessor<name> dict::operator[] (name key) const { return {m_ptr, key}; }

inline dict_accessor<handle> dict::operator[] (handle key) const { return {m_ptr, key}; }

inline dict::iterator::iterator(handle h) : items(h.attr("items")()), iter(items.begin()) {}

inline std::pair<handle, handle> dict::iterator::operator* () const {
    tuple pair = tuple(*iter, object::ref_t{});
    return {pair[0], pair[1]};
}

}  // namespace pkbind