Interface cleanup

Author: franzpoeschel

include/openPMD/LoadStoreChunk.hpp

@@ -45,7 +45,7 @@ namespace auxiliary::detail
 #undef OPENPMD_ENUMERATE_TYPES
 } // namespace auxiliary::detail
 
-enum class EnqueuePolicy
+enum class EnqueuePolicy : std::uint8_t
 {
     Defer,
     Immediate
@@ -73,12 +73,16 @@ class ConfigureLoadStore
 
     auto deferFlush(Attributable &);
 
+    auto getOffset() -> Offset const &;
+    auto getExtent() -> Extent const &;
+
     // The below methods return void.
     // For chaining calls, they should return *this, but this class right
     // here is going to be somewhere in the inheritance chain, and the final
     // class should be returned. Could be solved more elegantly with CRT,
     // but that blows up compile-time, so we make internal void functions
     // and then repeat them in the final classes.
+    // (e.g. ConfigureLoadStoreFromBuffer::offset())
 
     void offset_impl(Offset);
     void extent_impl(Extent);
@@ -100,9 +104,7 @@ class ConfigureLoadStore
 public:
     using this_t = ConfigureLoadStore;
 
-    auto getOffset() -> Offset const &;
-    auto getExtent() -> Extent const &;
-
+    // Configuration methods (always available)
     auto offset(Offset offset) -> this_t &
     {
         offset_impl(std::move(offset));
@@ -113,46 +115,37 @@ class ConfigureLoadStore
         extent_impl(std::move(extent));
         return *this;
     }
+
     /*
      * If the type is non-const, then the return type should be
-     * ConfigureLoadStoreFromBuffer<>, ...
+     * ConfigureLoadStoreFromBuffer, but if it is a const type, Load operations
+     * make no sense, so the return type should be
+     * ConfigureStoreChunkFromBuffer<>.
      */
     template <typename T>
-    struct shared_ptr_return_type_impl
-    {
-        using return_type = openPMD::ConfigureLoadStoreFromBuffer;
-        using normalize_pointer_type = std::shared_ptr<std::remove_extent_t<T>>;
-    };
-    /*
-     * ..., but if it is a const type, Load operations make no sense, so the
-     * return type should be ConfigureStoreChunkFromBuffer<>.
-     */
-    template <typename T>
-    struct shared_ptr_return_type_impl<T const>
-    {
-        using return_type = openPMD::ConfigureStoreChunkFromBuffer;
-        using normalize_pointer_type =
-            std::shared_ptr<std::remove_extent_t<T> const>;
-    };
-
-    template <typename T>
-    using shared_ptr_return_type = typename shared_ptr_return_type_impl<
-        std::remove_extent_t<T>>::return_type;
+    using shared_ptr_return_type = std::conditional_t<
+        std::is_const_v<T>,
+        ConfigureStoreChunkFromBuffer,
+        ConfigureLoadStoreFromBuffer>;
     template <typename T>
-    using shared_ptr_normalized_type = typename shared_ptr_return_type_impl<
-        std::remove_extent_t<T>>::normalized_pointer_type;
+    using shared_ptr_normalized_type = std::conditional_t<
+        std::is_const_v<T>,
+        std::shared_ptr<std::remove_extent_t<T> const>,
+        std::shared_ptr<std::remove_extent_t<T>>>;
 
     /*
      * As loading into unique pointer types makes no sense, the case is
      * simpler for unique pointers. Just remove the array extents here.
+     * (Our interface wrappers still support const-type unique pointers,
+     * but the internal logic does not handle them separately.)
      */
     template <typename T>
     using unique_ptr_return_type = openPMD::ConfigureStoreChunkFromBuffer;
     template <typename T>
     using unique_ptr_normalized_type =
         UniquePtrWithLambda<std::remove_extent_t<T>>;
 
-    // @todo rvalue references..?
+    // Buffer specification methods (return specialized configurations)
     template <typename T>
     auto withSharedPtr(std::shared_ptr<T>) -> shared_ptr_return_type<T>;
     template <typename T>
@@ -167,6 +160,7 @@ class ConfigureLoadStore
             auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
             shared_ptr_return_type<typename T_ContiguousContainer::value_type>>;
 
+    // Enqueue methods (deferred execution)
     template <typename T>
     [[nodiscard]] auto enqueueStore() -> DynamicMemoryView<T>;
     // definition for this one is in RecordComponent.tpp since it needs the
@@ -178,12 +172,13 @@ class ConfigureLoadStore
     [[nodiscard]] auto enqueueLoad()
         -> auxiliary::DeferredComputation<std::shared_ptr<T>>;
 
-    template <typename T>
-    [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr<T>;
-
     [[nodiscard]] auto enqueueLoadVariant() -> auxiliary::DeferredComputation<
         auxiliary::detail::shared_ptr_dataset_types>;
 
+    // Direct execution methods (with EnqueuePolicy)
+    template <typename T>
+    [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr<T>;
+
     [[nodiscard]] auto loadVariant(EnqueuePolicy)
         -> auxiliary::detail::shared_ptr_dataset_types;
 };
@@ -208,9 +203,12 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore
     // and then repeat them in the final classes.
     void memorySelection_impl(MemorySelection);
 
+    auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer;
+
 public:
     using this_t = ConfigureStoreChunkFromBuffer;
 
+    // Configuration methods (always available)
     auto offset(Offset offset) -> this_t &
     {
         offset_impl(std::move(offset));
@@ -227,10 +225,10 @@ class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore
         return *this;
     }
 
-    auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer;
-
+    // Enqueue method (deferred execution)
     auto enqueueStore() -> auxiliary::DeferredComputation<void>;
 
+    // Direct execution method (with EnqueuePolicy)
     auto store(EnqueuePolicy) -> void;
 
     /** This intentionally shadows the parent class's enqueueLoad methods in
@@ -266,6 +264,7 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer
 public:
     using this_t = ConfigureLoadStoreFromBuffer;
 
+    // Configuration methods (always available)
     auto offset(Offset offset) -> this_t &
     {
         offset_impl(std::move(offset));
@@ -282,8 +281,10 @@ class ConfigureLoadStoreFromBuffer : public ConfigureStoreChunkFromBuffer
         return *this;
     }
 
+    // Enqueue method (deferred execution)
     auto enqueueLoad() -> auxiliary::DeferredComputation<void>;
 
+    // Direct execution method (with EnqueuePolicy)
     auto load(EnqueuePolicy) -> void;
 };
 

src/LoadStoreChunk.cpp

@@ -7,14 +7,12 @@
 #include "openPMD/auxiliary/Memory.hpp"
 #include "openPMD/auxiliary/Memory_internal.hpp"
 #include "openPMD/auxiliary/ShareRawInternal.hpp"
-#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/auxiliary/UniquePtr.hpp"
 
 // comment to keep clang-format from reordering
 #include "openPMD/DatatypeMacros.hpp"
 #include "openPMD/backend/Attributable.hpp"
 
-#include <future>
 #include <memory>
 #include <optional>
 #include <stdexcept>