How to enforce const -ness on Python side

[StudioWEngineers]

Dear all,
I have defined a Point class and a PointTable one, which is nothing more than a vector of Points.
There are situations in which I do not want to give the possibility of modifying objects retrieved from the table, so I implemented a const getter.

Example:

#include <vector>
#include <nanobind/nanobind.h>

namespace nb = nanobind;

struct Point {
    double x;
    double y;
    double z;
};

struct PointTable {
    std::vector<Point> table;

    void add(const Point& point) {table.push_back(point);};

    Point* get(std::size_t index) {
        return &table[index];
    }
    const Point* get_const(std::size_t index) const {
        return &table[index];
    }
};

NB_MODULE(nanobind_example_ext, m) {
    nb::class_<Point>(m, "Point")
        .def(nb::init<>())
        .def(nb::init<double, double, double>())

        .def_rw("x", &Point::x)
        .def_rw("y", &Point::y)
        .def_rw("z", &Point::z)
    ;

    nb::class_<PointTable>(m, "PointTable")
        .def(nb::init<>())
        .def("add", &PointTable::add)
        .def("get", &PointTable::get, nb::rv_policy::reference_internal)
        .def("get_const", &PointTable::get_const, nb::rv_policy::reference_internal)
    ;
}

The const-ness is lost in the sense that I can still modify a retrieved object in Python (by calling get_const) because of the way Point is exposed.

Alternatives:

1. I could return a copy, which still can be modified in Python but this will not propagate back to the PointTable
2. I could implement a small wrapper around Point like:

struct PointView {
    const Point* p;

    double x() const { return p->x; }
    double y() const { return p->y; }
    double z() const { return p->z; }
};

but in this case I would lose all other methods Point implements (not shown here).

I am not an experienced C++ developer, so this question might be trivial or silly, but I will appreciate any hint from the community.

Regards, W

[wjakob]

nanobind (like Python) has no concept of const-ness, and will not have such a feature in the future. So this ultimately isn't a nanobind question. You could have a read-only base class. Or you could export implementations to separate regular and view classes without inheritance relationship via the curiously recurring template pattern (CRTP).

[StudioWEngineers]

Thank you for taking time to provide a feedback.