Dealing with classes that have private or deleted constructors.

[rvijayc]

I have a problem where I am trying to wrap a legacy class in Python using pybind11. The special aspect of this legacy class (whose code I cannot change) is that it doesn't allow copy construction. See below for an minimal extracted example of what I am dealing with:

// [start] LEGACY CLASS - CANNOT CHANGE 

struct A {

    A(): obj(py::int_(65537)) {}

    // move constructor required for std::vector resize to work.
    A(A&& cpy): obj(std::move(cpy.obj)) { }

    py::object get_obj() { return obj; }

  private:

    // disable copy construction.
    A(const A&)=delete;
    A& operator=(const A&)=delete;

    // some object (that is encapsulated by A).
    py::object obj;
};

struct B {
  std::vector<A> a_list;
};

// [end] LEGACY CLASS - CANNOT CHANGE

First, I tried to use Custom Type Casters directly to wrap A as described in the docs, but that also requires that the underlying class be copy constructible.

As an alternative, I tried wrapping B by defining a class module that extracts obj like below:

PYBIND11_EMBEDDED_MODULE(B, m) {
  py::class_<B>(m, "B")
    .def_property_readonly("a_list", [](B &self) {
        // converts std::vector<A> a_list into a Python list containing A::obj.
        py::list out;
        for(auto &i: self.a_list) {
          out.append(i.get_obj());
        }
        return out;
      });
};

Using the above example, the wrapping code works when B is used as a pointer, but doesn't work when B is used as a stack object. See below:

int main() {
  py::scoped_interpreter interpreter;
  py::module::import("B");

  // Case-A: this works.
  {
    B *b_ptr = new B();
    b_ptr->a_list.resize(5); 
    auto b_py = py::cast(std::unique_ptr<B>(b_ptr));
    // prints ...
    // [65537, 65537, 65537, 65537, 65537]
    py::print(b_py.attr("a_list"));
  }

  // Case-B: this doesn't compile.
  // reason being A not support copy construction.
  {
    B b;
    b.a_list.resize(5);
    auto b_py = py::cast(b);
    py::print(b_py.attr("a_list"));
  }
  return 0;
}

I believe Case-B doesn't work because A doesn't allow copy construction. Is there a way I can make Case-B work (i.e., make wrapping work with B objects defined on the stack)?

I am using pybind11 version 2.6.2.

Please let me know if I missing something basic. Appreciate your help.

[rvijayc]

After reading the fine manual one more time, I found one workaround that will probably work for me using shared pointers:
https://pybind11.readthedocs.io/en/stable/advanced/smart_ptrs.html

I changed the holder to a shared pointer:

PYBIND11_EMBEDDED_MODULE(B, m) {
  py::class_<B, std::shared_ptr<B>>(m, "B")

And, changed the usage to defining a shared_ptr for B that is tossed over to Python (and is shared with Python).

    auto b_ptr = std::make_shared<B>();
    b_ptr->a_list.resize(5); 
    auto b_py = py::cast(b_ptr);
    // prints ...
    // [65537, 65537, 65537, 65537, 65537]
    py::print(b_py.attr("a_list"));