Rename in preparation for storeChunk adaptations

Author: franzpoeschel

include/openPMD/LoadStoreChunk.hpp

@@ -41,15 +41,15 @@ namespace internal
 } // namespace internal
 
 template <typename ChildClass = void>
-class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
+class ConfigureLoadStore : protected internal::ConfigureStoreChunkData
 {
     friend class RecordComponent;
     template <typename>
-    friend class ConfigureStoreChunk;
+    friend class ConfigureLoadStore;
 
 protected:
-    ConfigureStoreChunk(RecordComponent &rc);
-    ConfigureStoreChunk(ConfigureStoreChunkData &&);
+    ConfigureLoadStore(RecordComponent &rc);
+    ConfigureLoadStore(ConfigureStoreChunkData &&);
 
     auto dim() const -> uint8_t;
     auto getOffset() const -> Offset;
@@ -59,7 +59,7 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
 public:
     using return_type = std::conditional_t<
         std::is_void_v<ChildClass>,
-        /*then*/ ConfigureStoreChunk<void>,
+        /*then*/ ConfigureLoadStore<void>,
         /*else*/ ChildClass>;
     template <typename T>
     using normalize_dataset_type = std::remove_cv_t<std::remove_extent_t<T>>;
@@ -93,24 +93,24 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
                     typename T_ContiguousContainer::value_type> const>>>;
 
     template <typename T>
-    auto enqueue() -> DynamicMemoryView<T>;
+    [[nodiscard]] auto enqueueStore() -> DynamicMemoryView<T>;
     // definition for this one is in RecordComponent.tpp since it needs the
     // definition of class RecordComponent.
     template <typename T, typename F>
-    auto enqueue(F &&createBuffer) -> DynamicMemoryView<T>;
+    [[nodiscard]] auto enqueueStore(F &&createBuffer) -> DynamicMemoryView<T>;
 };
 
 template <typename Ptr_Type>
 class ConfigureStoreChunkFromBuffer
-    : public ConfigureStoreChunk<ConfigureStoreChunkFromBuffer<Ptr_Type>>
+    : public ConfigureLoadStore<ConfigureStoreChunkFromBuffer<Ptr_Type>>
 {
 public:
     using parent_t =
-        ConfigureStoreChunk<ConfigureStoreChunkFromBuffer<Ptr_Type>>;
+        ConfigureLoadStore<ConfigureStoreChunkFromBuffer<Ptr_Type>>;
 
 private:
     template <typename T>
-    friend class ConfigureStoreChunk;
+    friend class ConfigureLoadStore;
 
     Ptr_Type m_buffer;
     std::optional<MemorySelection> m_mem_select;
@@ -126,80 +126,8 @@ class ConfigureStoreChunkFromBuffer
     auto as_parent() & -> parent_t &;
     auto as_parent() const & -> parent_t const &;
 
-    auto enqueue() -> void;
+    auto enqueueStore() -> void;
 };
-
-template <typename ChildClass>
-template <typename T>
-auto ConfigureStoreChunk<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
-    -> ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>
-{
-    if (!data)
-    {
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    }
-    return ConfigureStoreChunkFromBuffer<
-        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>
-template <typename T>
-auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
-    -> ConfigureStoreChunkFromBuffer<
-        UniquePtrWithLambda<normalize_dataset_type<T>>>
-{
-    if (!data)
-    {
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    }
-    return ConfigureStoreChunkFromBuffer<
-        UniquePtrWithLambda<normalize_dataset_type<T>>>(
-        std::move(data).template static_cast_<normalize_dataset_type<T>>(),
-        {std::move(*this)});
-}
-template <typename ChildClass>
-template <typename T>
-auto ConfigureStoreChunk<ChildClass>::fromRawPtr(T *data)
-    -> ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>
-{
-    if (!data)
-    {
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    }
-    return ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>(
-        auxiliary::shareRaw(data), {std::move(*this)});
-}
-
-template <typename ChildClass>
-template <typename T, typename Del>
-auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(
-    std::unique_ptr<T, Del> data)
-    -> ConfigureStoreChunkFromBuffer<
-        UniquePtrWithLambda<normalize_dataset_type<T>>>
-{
-    return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
-}
-template <typename ChildClass>
-template <typename T_ContiguousContainer>
-auto ConfigureStoreChunk<ChildClass>::fromContiguousContainer(
-    T_ContiguousContainer &data) ->
-    typename std::enable_if_t<
-        auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
-        ConfigureStoreChunkFromBuffer<std::shared_ptr<normalize_dataset_type<
-            typename T_ContiguousContainer::value_type> const>>>
-{
-    if (!m_extent.has_value() && dim() == 1)
-    {
-        m_extent = Extent{data.size()};
-    }
-    return fromRawPtr(data.data());
-}
 } // namespace openPMD
+
+#include "openPMD/LoadStoreChunk.tpp"

include/openPMD/LoadStoreChunk.tpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "openPMD/LoadStoreChunk.hpp"
+
+namespace openPMD
+{
+
+template <typename ChildClass>
+template <typename T>
+auto ConfigureLoadStore<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
+    -> ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return ConfigureStoreChunkFromBuffer<
+        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>
+template <typename T>
+auto ConfigureLoadStore<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
+    -> ConfigureStoreChunkFromBuffer<
+        UniquePtrWithLambda<normalize_dataset_type<T>>>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return ConfigureStoreChunkFromBuffer<
+        UniquePtrWithLambda<normalize_dataset_type<T>>>(
+        std::move(data).template static_cast_<normalize_dataset_type<T>>(),
+        {std::move(*this)});
+}
+template <typename ChildClass>
+template <typename T>
+auto ConfigureLoadStore<ChildClass>::fromRawPtr(T *data)
+    -> ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>(
+        auxiliary::shareRaw(data), {std::move(*this)});
+}
+
+template <typename ChildClass>
+template <typename T, typename Del>
+auto ConfigureLoadStore<ChildClass>::fromUniquePtr(std::unique_ptr<T, Del> data)
+    -> ConfigureStoreChunkFromBuffer<
+        UniquePtrWithLambda<normalize_dataset_type<T>>>
+{
+    return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
+}
+template <typename ChildClass>
+template <typename T_ContiguousContainer>
+auto ConfigureLoadStore<ChildClass>::fromContiguousContainer(
+    T_ContiguousContainer &data) ->
+    typename std::enable_if_t<
+        auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
+        ConfigureStoreChunkFromBuffer<std::shared_ptr<normalize_dataset_type<
+            typename T_ContiguousContainer::value_type> const>>>
+{
+    if (!m_extent.has_value() && dim() == 1)
+    {
+        m_extent = Extent{data.size()};
+    }
+    return fromRawPtr(data.data());
+}
+} // namespace openPMD

include/openPMD/RecordComponent.hpp

@@ -134,7 +134,7 @@ class RecordComponent : public BaseRecordComponent
     friend class internal::RecordComponentData;
     friend class MeshRecordComponent;
     template <typename ChildClass>
-    friend class ConfigureStoreChunk;
+    friend class ConfigureLoadStore;
     template <typename Ptr_Type>
     friend class ConfigureStoreChunkFromBuffer;
 
@@ -288,7 +288,7 @@ class RecordComponent : public BaseRecordComponent
     template <typename T>
     void loadChunkRaw(T *data, Offset offset, Extent extent);
 
-    ConfigureStoreChunk<void> prepareStoreChunk();
+    ConfigureLoadStore<void> prepareStoreChunk();
 
     /** Store a chunk of data from a chunk of memory.
      *

include/openPMD/RecordComponent.tpp

@@ -192,7 +192,7 @@ RecordComponent::storeChunk(std::shared_ptr<T> data, Offset o, Extent e)
         .offset(std::move(o))
         .extent(std::move(e))
         .fromSharedPtr(std::move(data))
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T>
@@ -203,7 +203,7 @@ RecordComponent::storeChunk(UniquePtrWithLambda<T> data, Offset o, Extent e)
         .offset(std::move(o))
         .extent(std::move(e))
         .fromUniquePtr(std::move(data))
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T, typename Del>
@@ -214,7 +214,7 @@ RecordComponent::storeChunk(std::unique_ptr<T, Del> data, Offset o, Extent e)
         .offset(std::move(o))
         .extent(std::move(e))
         .fromUniquePtr(std::move(data))
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T>
@@ -224,7 +224,7 @@ void RecordComponent::storeChunkRaw(T *ptr, Offset offset, Extent extent)
         .offset(std::move(offset))
         .extent(std::move(extent))
         .fromRawPtr(ptr)
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T_ContiguousContainer>
@@ -244,7 +244,7 @@ RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e)
         storeChunkConfig.extent(std::move(e));
     }
 
-    std::move(storeChunkConfig).fromContiguousContainer(data).enqueue();
+    std::move(storeChunkConfig).fromContiguousContainer(data).enqueueStore();
 }
 
 template <typename T, typename F>
@@ -254,7 +254,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
     return prepareStoreChunk()
         .offset(std::move(o))
         .extent(std::move(e))
-        .enqueue<T>(std::forward<F>(createBuffer));
+        .enqueueStore<T>(std::forward<F>(createBuffer));
 }
 
 template <typename T>
@@ -264,7 +264,7 @@ RecordComponent::storeChunk(Offset offset, Extent extent)
     return prepareStoreChunk()
         .offset(std::move(offset))
         .extent(std::move(extent))
-        .enqueue<T>();
+        .enqueueStore<T>();
 }
 
 template <typename T, typename F>
@@ -367,7 +367,7 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const
 // definitions for LoadStoreChunk.hpp
 template <typename ChildClass>
 template <typename T, typename F>
-auto ConfigureStoreChunk<ChildClass>::enqueue(F &&createBuffer)
+auto ConfigureLoadStore<ChildClass>::enqueueStore(F &&createBuffer)
     -> DynamicMemoryView<T>
 {
     return m_rc.storeChunkSpanCreateBuffer_impl<T>(