AI code review

Author: franzpoeschel

include/openPMD/IO/InvalidatableFile.hpp

@@ -93,7 +93,9 @@ struct less<openPMD::InvalidatableFile>
 {
     using first_argument_type = openPMD::InvalidatableFile;
     using second_argument_type = first_argument_type;
-    using result_type = typename std::less<std::string>::result_type;
+    using result_type = decltype(std::less<>()(
+        *std::declval<first_argument_type const &>(),
+        *std::declval<second_argument_type const &>()));
     result_type
     operator()(first_argument_type const &, second_argument_type const &) const;
 };

include/openPMD/auxiliary/Future.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <functional>
+#include <type_traits>
 #include <variant>
 
 namespace openPMD::auxiliary::detail
@@ -69,6 +70,15 @@ class DeferredComputation
      */
     DeferredComputation(cached_type val);
 
+    explicit DeferredComputation();
+
+    DeferredComputation(DeferredComputation &&) noexcept;
+    DeferredComputation(DeferredComputation const &) = delete;
+
+    auto operator=(DeferredComputation &&) noexcept -> DeferredComputation &;
+    auto operator=(DeferredComputation const &)
+        -> DeferredComputation & = delete;
+
     ~DeferredComputation();
 
     /** Get the result of the computation

src/IO/AbstractIOHandler.cpp

@@ -131,7 +131,11 @@ std::future<void> AbstractIOHandler::flush(internal::ParsedFlushParams &params)
     // been flushed already.
     bool increase_flush_counter = !m_work.empty();
     auto res = this->flush_impl(params);
-    if (increase_flush_counter && m_work.empty())
+    if (!m_work.empty())
+    {
+        throw error::Internal("flush() did not clear all work!");
+    }
+    if (increase_flush_counter)
     {
         ++*m_flushCounter;
     }

src/auxiliary/Future.cpp

@@ -53,6 +53,17 @@ DeferredComputation<T>::DeferredComputation(cached_type cached_val)
     : m_task(detail::CachedValue<T>{std::move(cached_val)})
 {}
 
+template <typename T>
+DeferredComputation<T>::DeferredComputation() = default;
+
+template <typename T>
+DeferredComputation<T>::DeferredComputation(DeferredComputation &&) noexcept =
+    default;
+
+template <typename T>
+auto DeferredComputation<T>::operator=(DeferredComputation &&) noexcept
+    -> DeferredComputation & = default;
+
 template <typename T>
 DeferredComputation<T>::~DeferredComputation()
 {