nanobind a vector of a NonCopyable class

[JeanDidierGaraud]

Hello,
I'm trying to bind a class that contains a std::vector<NonCopyable>. It fails to compile.
Is it something that is not (yet?) supported?

I've pasted below the compilation message and a small reproducible example.
From what I understand, the problem arises when nanobind tries to create the method nanobind::detail::wrap_copy.

If relevant, I'm using nanobind 2.1.0, and tried with gcc-11 or 12, python 3.10 or 3.12.
I've also tried to replace the vector with other containers (map, unordered_map, list, set), the error is similar.

jdgaraud@laptop:mre-non-copiable$ cmake --build build --verbose
[ 92%] Building CXX object CMakeFiles/mre1.dir/src/my_binding.cpp.o
/usr/bin/c++ -Dmre1_EXPORTS -I/usr/include/python3.10 -I/home/jdgaraud/.local/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -fPIC -fvisibility=hidden -fno-stack-protector -Os -ffunction-sections -fdata-sections -MD -MT CMakeFiles/mre1.dir/src/my_binding.cpp.o -MF CMakeFiles/mre1.dir/src/my_binding.cpp.o.d -o CMakeFiles/mre1.dir/src/my_binding.cpp.o -c /home/jdgaraud/mre-non-copiable/src/my_binding.cpp
In file included from /usr/include/c++/11/vector:66,
                 from /home/jdgaraud/mre-non-copiable/src/my_binding.cpp:2:
/usr/include/c++/11/bits/stl_uninitialized.h: In instantiation of ‘_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const Part*, std::vector<Part> >; _ForwardIterator = Part*]’:
/usr/include/c++/11/bits/stl_uninitialized.h:333:37:   required from ‘_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = __gnu_cxx::__normal_iterator<const Part*, std::vector<Part> >; _ForwardIterator = Part*; _Tp = Part]’
/usr/include/c++/11/bits/stl_vector.h:558:31:   required from ‘std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = Part; _Alloc = std::allocator<Part>]’
/home/jdgaraud/mre-non-copiable/src/my_binding.cpp:33:7:   required from ‘void nanobind::detail::wrap_copy(void*, const void*) [with T = MyContainer]’
/home/jdgaraud/.local/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h:504:24:   required from ‘nanobind::class_<T, Ts>::class_(nanobind::handle, const char*, const Extra& ...) [with Extra = {}; T = MyContainer; Ts = {}]’
/home/jdgaraud/mre-non-copiable/src/my_binding.cpp:43:43:   required from here
/usr/include/c++/11/bits/stl_uninitialized.h:138:72: error: static assertion failed: result type must be constructible from value type of input range
  138 |       static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
      |                                                                        ^~~~~
/usr/include/c++/11/bits/stl_uninitialized.h:138:72: note: ‘std::integral_constant<bool, false>::value’ evaluates to false
gmake[2]: *** [CMakeFiles/mre1.dir/build.make:76: CMakeFiles/mre1.dir/src/my_binding.cpp.o] Error 1

file my_binding.cpp

#include <string>
#include <vector>

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

namespace nb = nanobind;
using namespace nb::literals;


/// A very big object
class Part {
public:
  // no copy (it is a heavy object)
  Part(const Part&) = delete;
  Part& operator=(const Part&) = delete;

  // move is ok
  Part(Part&&) = default;
  Part& operator=(Part&&) = default;  // =delete

  Part() = default;
  ~Part() = default;

  Part(int /*very_big_size*/) { /*... create huge arrays here ...*/ }

protected:
  // ... huge arrays ...
};


class MyContainer {
public:
  // Part a_single_part;   // this works fine
  std::vector<Part> parts_;
};


NB_MODULE(mre1, m) {
  m.doc() = "mre1 - a small binding.";

  nb::class_<MyContainer>(m, "MyContainer")
    .def(nb::init<>())
    ;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.20)
project(mre1)

set(DEV_MODULE Development.Module)


find_package(Python 3.8 COMPONENTS Interpreter ${DEV_MODULE} REQUIRED)


if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()


# Detect the installed nanobind package and import it into CMake
execute_process(
  COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
  OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE NB_DIR)
list(APPEND CMAKE_PREFIX_PATH "${NB_DIR}")
find_package(nanobind CONFIG REQUIRED)

nanobind_add_module(mre1 src/my_binding.cpp)

# Usage:
#  cmake -S . -B build
#  cmake --build build
#  ( cd build ; python3 -c "import mre1; print(mre1.__doc__)" )

Thanks for any advices,
JD

[wojdyr]

Perhaps bind_vector (you include the header, but you don't use it) with the reference_internal policy would work without copying. I didn't test it, though. The documentation of bind_vector explains why this policy is unsafe, so needs to be used with care.

[JeanDidierGaraud]

thanks for your answer. I have not tested the bind_vector method yet (and won't need for the moment since my problem is now fixed).

[JeanDidierGaraud]

I had missed something in my design: the class MyContainer is naturally not copyable, but I forgot to explicitly delete the constructor.
In pure C++, the copy-constructor is never called so the program compiles. Nanobind must be trying to instanciate a copy.

Adding MyContainer(const MyContainer&) = delete; fixes everything.

The case for a_single_part works because the compiler implicitly deletes it for us.