Frontend support for unique pointers with const value types

Author: franzpoeschel

include/openPMD/LoadStoreChunk.tpp

@@ -24,10 +24,6 @@ auto ConfigureLoadStore<ChildClass>::withUniquePtr(UniquePtrWithLambda<T> data)
     -> unique_ptr_return_type<T>
 
 {
-    // should we support them?
-    static_assert(
-        !std::is_const_v<T>,
-        "Unique pointers to const types not supported as storeChunk buffers.");
     if (!data)
     {
         throw std::runtime_error(

src/LoadStoreChunk.cpp

@@ -41,6 +41,22 @@ namespace
         return auxiliary::WriteBuffer(
             std::move(ptr).template static_cast_<void>());
     }
+
+    /*
+     * There is no backend support currently for const unique pointers.
+     * We support these mostly for providing a clean API to users that have such
+     * pointers and want to store from them, but there will be no
+     * backend-specific optimizations for such buffers as there are for
+     * non-const unique pointers.
+     */
+    template <typename T>
+    auto
+    asWriteBuffer(UniquePtrWithLambda<T const> &&ptr) -> auxiliary::WriteBuffer
+    {
+        auto raw_ptr = ptr.get();
+        return asWriteBuffer(std::shared_ptr<T const>{
+            raw_ptr, [ptr_lambda = std::move(ptr)](auto const *) {}});
+    }
 } // namespace
 
 template <typename ChildClass>
@@ -272,6 +288,14 @@ OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_METHOD_TEMPLATES_FOR_BASE)
     INSTANTIATE_METHOD_TEMPLATES(                                              \
         ConfigureLoadStore<                                                    \
             ConfigureStoreChunkFromBuffer<std::shared_ptr<dtype const>>>,      \
+        dtype)                                                                 \
+    template class ConfigureStoreChunkFromBuffer<                              \
+        UniquePtrWithLambda<dtype const>>;                                     \
+    template class ConfigureLoadStore<                                         \
+        ConfigureStoreChunkFromBuffer<UniquePtrWithLambda<dtype const>>>;      \
+    INSTANTIATE_METHOD_TEMPLATES(                                              \
+        ConfigureLoadStore<                                                    \
+            ConfigureStoreChunkFromBuffer<UniquePtrWithLambda<dtype const>>>,  \
         dtype)
 // clang-format on
 

test/SerialIOTest.cpp

@@ -928,7 +928,11 @@ inline void constant_scalar(std::string const &file_ending)
             new unsigned int[6], [](unsigned int const *p) { delete[] p; });
         unsigned int e{0};
         std::generate(E.get(), E.get() + 6, [&e] { return e++; });
-        E_y.storeChunk(std::move(E), {0, 0, 0}, {1, 2, 3});
+        // check that const-type unique pointers work in the builder pattern
+        E_y.prepareLoadStore()
+            .extent({1, 2, 3})
+            .withUniquePtr(std::move(E).static_cast_<unsigned int const>())
+            .enqueueStore();
 
         // store a number of predefined attributes in E
         Mesh &E_mesh = s.iterations[1].meshes["E"];