StoreChunk completely moved over to new syntax

Author: franzpoeschel

include/openPMD/LoadStoreChunk.hpp

@@ -68,16 +68,16 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
         /*then*/ ConfigureStoreChunk<void>,
         /*else*/ ChildClass>;
     template <typename T>
-    using normalize_dataset_type =
-        std::remove_cv_t<std::remove_extent_t<T>> const;
+    using normalize_dataset_type = std::remove_cv_t<std::remove_extent_t<T>>;
 
     auto offset(Offset) -> return_type &;
     auto extent(Extent) -> return_type &;
 
     // @todo rvalue references..?
     template <typename T>
     auto fromSharedPtr(std::shared_ptr<T>)
-        -> TypedConfigureStoreChunk<std::shared_ptr<normalize_dataset_type<T>>>;
+        -> TypedConfigureStoreChunk<
+            std::shared_ptr<normalize_dataset_type<T> const>>;
     template <typename T>
     auto fromUniquePtr(UniquePtrWithLambda<T>)
         -> TypedConfigureStoreChunk<
@@ -87,13 +87,15 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
         -> TypedConfigureStoreChunk<
             UniquePtrWithLambda<normalize_dataset_type<T>>>;
     template <typename T>
-    auto fromRawPtr(T *data) -> TypedConfigureStoreChunk<std::shared_ptr<T>>;
+    auto
+    fromRawPtr(T *data) -> TypedConfigureStoreChunk<
+                            std::shared_ptr<normalize_dataset_type<T> const>>;
     template <typename T_ContiguousContainer>
     auto fromContiguousContainer(T_ContiguousContainer &data) ->
         typename std::enable_if_t<
             auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
-            TypedConfigureStoreChunk<
-                std::shared_ptr<typename T_ContiguousContainer::value_type>>>;
+            TypedConfigureStoreChunk<std::shared_ptr<normalize_dataset_type<
+                typename T_ContiguousContainer::value_type> const>>>;
 
     template <typename T>
     auto enqueue() -> DynamicMemoryView<T>;
@@ -135,15 +137,18 @@ class TypedConfigureStoreChunk
 template <typename ChildClass>
 template <typename T>
 auto ConfigureStoreChunk<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
-    -> TypedConfigureStoreChunk<std::shared_ptr<normalize_dataset_type<T>>>
+    -> TypedConfigureStoreChunk<
+        std::shared_ptr<normalize_dataset_type<T> const>>
 {
     if (!data)
     {
         throw std::runtime_error(
             "Unallocated pointer passed during chunk store.");
     }
-    return TypedConfigureStoreChunk<std::shared_ptr<normalize_dataset_type<T>>>(
-        std::static_pointer_cast<normalize_dataset_type<T>>(std::move(data)),
+    return TypedConfigureStoreChunk<
+        std::shared_ptr<normalize_dataset_type<T> const>>(
+        std::static_pointer_cast<normalize_dataset_type<T> const>(
+            std::move(data)),
         {std::move(*this)});
 }
 template <typename ChildClass>
@@ -164,14 +169,16 @@ auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
 template <typename ChildClass>
 template <typename T>
 auto ConfigureStoreChunk<ChildClass>::fromRawPtr(T *data)
-    -> TypedConfigureStoreChunk<std::shared_ptr<T>>
+    -> TypedConfigureStoreChunk<
+        std::shared_ptr<normalize_dataset_type<T> const>>
 {
     if (!data)
     {
         throw std::runtime_error(
             "Unallocated pointer passed during chunk store.");
     }
-    return TypedConfigureStoreChunk<std::shared_ptr<T>>(
+    return TypedConfigureStoreChunk<
+        std::shared_ptr<normalize_dataset_type<T> const>>(
         auxiliary::shareRaw(data), {std::move(*this)});
 }
 
@@ -189,8 +196,8 @@ auto ConfigureStoreChunk<ChildClass>::fromContiguousContainer(
     T_ContiguousContainer &data) ->
     typename std::enable_if_t<
         auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
-        TypedConfigureStoreChunk<
-            std::shared_ptr<typename T_ContiguousContainer::value_type>>>
+        TypedConfigureStoreChunk<std::shared_ptr<normalize_dataset_type<
+            typename T_ContiguousContainer::value_type> const>>>
 {
     if (!m_extent.has_value() && dim() == 1)
     {

include/openPMD/RecordComponent.tpp

@@ -199,63 +199,52 @@ template <typename T>
 inline void
 RecordComponent::storeChunk(UniquePtrWithLambda<T> data, Offset o, Extent e)
 {
-    if (!data)
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    Datatype dtype = determineDatatype<>(data);
-
-    storeChunk_impl(
-        auxiliary::WriteBuffer{std::move(data).template static_cast_<void>()},
-        dtype,
-        {std::move(o), std::move(e), std::nullopt});
+    prepareStoreChunk()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .fromUniquePtr(std::move(data))
+        .enqueue();
 }
 
 template <typename T, typename Del>
 inline void
 RecordComponent::storeChunk(std::unique_ptr<T, Del> data, Offset o, Extent e)
 {
-    storeChunk(
-        UniquePtrWithLambda<T>(std::move(data)), std::move(o), std::move(e));
+    prepareStoreChunk()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .fromUniquePtr(std::move(data))
+        .enqueue();
 }
 
 template <typename T>
 void RecordComponent::storeChunkRaw(T *ptr, Offset offset, Extent extent)
 {
-    storeChunk(auxiliary::shareRaw(ptr), std::move(offset), std::move(extent));
+    prepareStoreChunk()
+        .offset(std::move(offset))
+        .extent(std::move(extent))
+        .fromRawPtr(ptr)
+        .enqueue();
 }
 
 template <typename T_ContiguousContainer>
 inline typename std::enable_if_t<
     auxiliary::IsContiguousContainer_v<T_ContiguousContainer>>
 RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e)
 {
-    uint8_t dim = getDimensionality();
+    auto storeChunkConfig = prepareStoreChunk();
 
-    // default arguments
-    //   offset = {0u}: expand to right dim {0u, 0u, ...}
-    Offset offset = o;
-    if (o.size() == 1u && o.at(0) == 0u)
+    auto joined_dim = joinedDimension();
+    if (!joined_dim.has_value() && (o.size() != 1 || o.at(0) != 0u))
     {
-        if (joinedDimension().has_value())
-        {
-            offset.clear();
-        }
-        else if (dim > 1u)
-        {
-            offset = Offset(dim, 0u);
-        }
+        storeChunkConfig.offset(std::move(o));
+    }
+    if (e.size() != 1 || e.at(0) != -1u)
+    {
+        storeChunkConfig.extent(std::move(e));
     }
 
-    //   extent = {-1u}: take full size
-    Extent extent(dim, 1u);
-    //   avoid outsmarting the user:
-    //   - stdlib data container implement 1D -> 1D chunk to write
-    if (e.size() == 1u && e.at(0) == -1u && dim == 1u)
-        extent.at(0) = data.size();
-    else
-        extent = e;
-
-    storeChunk(auxiliary::shareRaw(data.data()), offset, extent);
+    std::move(storeChunkConfig).fromContiguousContainer(data).enqueue();
 }
 
 template <typename T, typename F>

include/openPMD/auxiliary/Memory.hpp

@@ -180,9 +180,10 @@ namespace auxiliary
         WriteBuffer() : m_buffer(UniquePtrWithLambda<void>())
         {}
 
-        template <typename... Args>
-        explicit WriteBuffer(Args &&...args)
-            : m_buffer(std::forward<Args>(args)...)
+        WriteBuffer(std::shared_ptr<void const> ptr) : m_buffer(std::move(ptr))
+        {}
+
+        WriteBuffer(UniquePtrWithLambda<void> ptr) : m_buffer(std::move(ptr))
         {}
 
         WriteBuffer(WriteBuffer &&) = default;
@@ -196,7 +197,7 @@ namespace auxiliary
             return *this;
         }
 
-        WriteBuffer const &operator=(UniquePtrWithLambda<void const> ptr)
+        WriteBuffer const &operator=(UniquePtrWithLambda<void> ptr)
         {
             m_buffer = std::move(ptr);
             return *this;

include/openPMD/auxiliary/UniquePtr.hpp

@@ -170,10 +170,11 @@ template <typename U>
 UniquePtrWithLambda<U> UniquePtrWithLambda<T>::static_cast_() &&
 {
     using other_type = std::remove_extent_t<U>;
+    auto original_ptr = this->release();
     return UniquePtrWithLambda<U>{
-        static_cast<other_type *>(this->release()),
-        [deleter = std::move(this->get_deleter())](other_type *ptr) {
-            deleter(static_cast<T_decayed *>(ptr));
+        static_cast<other_type *>(original_ptr),
+        [deleter = std::move(this->get_deleter()), original_ptr](other_type *) {
+            deleter(original_ptr);
         }};
 }
 } // namespace openPMD

src/LoadStoreChunk.cpp

@@ -37,8 +37,8 @@ namespace
     template <typename T>
     auto asWriteBuffer(UniquePtrWithLambda<T> &&ptr) -> auxiliary::WriteBuffer
     {
-        return auxiliary::WriteBuffer{
-            std::move(ptr).template static_cast_<void const>()};
+        return auxiliary::WriteBuffer(
+            std::move(ptr).template static_cast_<void>());
     }
 } // namespace
 
@@ -178,12 +178,12 @@ OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_METHOD_TEMPLATES_FOR_BASE)
         ConfigureStoreChunk<                                                   \
             TypedConfigureStoreChunk<std::shared_ptr<dtype const>>>,           \
         dtype)                                                                 \
-    template class TypedConfigureStoreChunk<UniquePtrWithLambda<dtype const>>; \
+    template class TypedConfigureStoreChunk<UniquePtrWithLambda<dtype>>;       \
     template class ConfigureStoreChunk<                                        \
-        TypedConfigureStoreChunk<UniquePtrWithLambda<dtype const>>>;           \
+        TypedConfigureStoreChunk<UniquePtrWithLambda<dtype>>>;                 \
     INSTANTIATE_METHOD_TEMPLATES(                                              \
         ConfigureStoreChunk<                                                   \
-            TypedConfigureStoreChunk<UniquePtrWithLambda<dtype const>>>,       \
+            TypedConfigureStoreChunk<UniquePtrWithLambda<dtype>>>,             \
         dtype)
 
 OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_TYPED_STORE_CHUNK)

test/SerialIOTest.cpp

@@ -40,6 +40,8 @@
 #include <unistd.h>
 #endif
 
+#include <execinfo.h>
+
 using namespace openPMD;
 
 struct BackendSelection