cleanup: noexcept code

The idea is to have make moving noexcept. The twist is that move
assignment requires decrementing a reference count. Which in turn might
require freeing the object, which could fail. Hence move assignment is
not no-except for any objects that own a HID. It's still worth
implementing since we can steal the reference of `other`.

All other object should behave normally, i.e. both move construction and
assignment are noexcept.

This commit changes two addition occurences of `noexcept`:

  * Add `noexcept` to `Object(hid_t)`, because it semantically
  steals the HID and it can't check anything. Moreover, it's useful
  for move ctors/assignment.

  * Remove `noexcept` from `Chunking::getDimensions` for consistency
  and freedom to change the implementation later.

Outdated occurences of `throw()` have been modernized.

There's several occurences of `noexcept` in accessors of `ObjectInfo`.
They're not changed, because we probably want to have different objects
for different versions of `H5O_info_t` (since that struct dictates
what's available).

Author: 1uc

include/highfive/H5DataType.hpp

@@ -212,6 +212,9 @@ class CompoundType: public DataType {
     };
 
     CompoundType(const CompoundType& other) = default;
+    CompoundType(CompoundType&& other) noexcept = default;
+    CompoundType& operator=(const CompoundType& other) = default;
+    CompoundType& operator=(CompoundType&& other) = default;
 
     ///
     /// \brief Initializes a compound type from a vector of member definitions

include/highfive/H5Exception.hpp

@@ -25,13 +25,19 @@ class Exception: public std::exception {
     Exception(const std::string& err_msg)
         : _errmsg(err_msg) {}
 
-    ~Exception() throw() override = default;
+    Exception(const Exception& other) = default;
+    Exception(Exception&& other) noexcept = default;
+
+    Exception& operator=(const Exception& other) = default;
+    Exception& operator=(Exception&& other) noexcept = default;
+
+    ~Exception() noexcept override {}
 
     ///
     /// \brief get the current exception error message
     /// \return
     ///
-    inline const char* what() const throw() override {
+    inline const char* what() const noexcept override {
         return _errmsg.c_str();
     }
 

include/highfive/H5File.hpp

@@ -79,12 +79,23 @@ class File: public Object, public NodeTraits<File>, public AnnotateTraits<File>
          const FileCreateProps& fileCreateProps,
          const FileAccessProps& fileAccessProps = FileAccessProps::Default());
 
+    /// \brief Keeps reference count constant, and invalidates other.
+    File(File&& other) noexcept = default;
+
+    /// \brief Keeps reference count constant, and invalidates other.
+    File& operator=(File&& other) = default;
+
+    /// \brief Increments reference count, keeps other valid.
+    File(const File& other) = default;
+
+    /// \brief Increments reference count, keeps other valid.
+    File& operator=(const File& other) = default;
+
     ///
     /// \brief Return the name of the file
     ///
     const std::string& getName() const;
 
-
     /// \brief Object path of a File is always "/"
     std::string getPath() const noexcept {
         return "/";

include/highfive/H5Object.hpp

@@ -75,13 +75,14 @@ class Object {
     Object(const Object& other);
 
     // Init with an low-level object id
-    explicit Object(hid_t);
+    explicit Object(hid_t) noexcept;
 
     // decrease reference counter
     ~Object();
 
     // Copy-Assignment operator
     Object& operator=(const Object& other);
+    Object& operator=(Object&& other);
 
     hid_t _hid;
 

include/highfive/H5PropertyList.hpp

@@ -506,7 +506,7 @@ class Chunking {
 
     explicit Chunking(DataSetCreateProps& plist, size_t max_dims = 32);
 
-    const std::vector<hsize_t>& getDimensions() const noexcept;
+    const std::vector<hsize_t>& getDimensions() const;
 
   private:
     friend DataSetCreateProps;

include/highfive/bits/H5Object_misc.hpp

@@ -19,7 +19,7 @@ namespace HighFive {
 inline Object::Object()
     : _hid(H5I_INVALID_HID) {}
 
-inline Object::Object(hid_t hid)
+inline Object::Object(hid_t hid) noexcept
     : _hid(hid) {}
 
 inline Object::Object(const Object& other)
@@ -34,6 +34,17 @@ inline Object::Object(Object&& other) noexcept
     other._hid = H5I_INVALID_HID;
 }
 
+inline Object& Object::operator=(Object&& other) {
+    if (this != &other) {
+        if ((*this).isValid()) {
+            detail::h5i_dec_ref(_hid);
+        }
+        _hid = other._hid;
+        other._hid = H5I_INVALID_HID;
+    }
+    return *this;
+}
+
 inline Object& Object::operator=(const Object& other) {
     if (this != &other) {
         if ((*this).isValid()) {

include/highfive/bits/H5PropertyList_misc.hpp

@@ -296,7 +296,7 @@ inline Chunking::Chunking(DataSetCreateProps& plist, size_t max_dims)
     }
 }
 
-inline const std::vector<hsize_t>& Chunking::getDimensions() const noexcept {
+inline const std::vector<hsize_t>& Chunking::getDimensions() const {
     return _dims;
 }
 

tests/unit/CMakeLists.txt

@@ -6,7 +6,7 @@ if(MSVC)
 endif()
 
 ## Base tests
-foreach(test_name tests_high_five_base tests_high_five_easy test_all_types test_high_five_selection tests_high_five_data_type test_boost test_empty_arrays test_legacy test_opencv test_string test_stl test_xtensor)
+foreach(test_name tests_high_five_base tests_high_five_easy test_all_types test_high_five_selection tests_high_five_data_type test_boost test_empty_arrays test_legacy test_nothrow_movable test_opencv test_string test_stl test_xtensor)
   add_executable(${test_name} "${test_name}.cpp")
   target_link_libraries(${test_name} HighFive HighFiveWarnings HighFiveFlags Catch2::Catch2WithMain)
   target_link_libraries(${test_name} HighFiveOptionalDependencies)

tests/unit/test_nothrow_movable.cpp

@@ -0,0 +1,87 @@
+/*
+ *  Copyright (c), 2025, HighFive Developers
+ *
+ *  Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+#include <catch2/catch_template_test_macros.hpp>
+
+#include <highfive/highfive.hpp>
+
+using namespace HighFive;
+
+template<typename T, bool T1, bool T2, bool T3, bool T4>
+constexpr void check_constructible_assignable() {
+  static_assert(std::is_copy_constructible_v<T> == T1);
+  static_assert(std::is_copy_assignable_v<T> == T2);
+  static_assert(std::is_move_constructible_v<T> == T3);
+  static_assert(std::is_move_assignable_v<T> == T4);
+}
+
+TEST_CASE("Enshrine constructible/assignable status", "[core]") {
+  // Object isn't constructible at all, because its dtor has
+  // been deleted.
+  check_constructible_assignable<Object, false, false, false, false>();
+  check_constructible_assignable<File, true, true, true, true>();
+  check_constructible_assignable<CompoundType, true, true, true, true>();
+}
+
+template<class T>
+constexpr void
+check_nothrow_movable() {
+  // Check that if it's moveable, it's nothrow movable.
+  static_assert(std::is_move_constructible_v<T> == std::is_nothrow_move_constructible_v<T>);
+  static_assert(std::is_move_assignable_v<T> == std::is_nothrow_move_assignable_v<T>);
+}
+
+TEST_CASE("Nothrow movable exceptions", "[core]") {
+  check_nothrow_movable<Exception>();
+  check_nothrow_movable<FileException>();
+  check_nothrow_movable<ObjectException>();
+  check_nothrow_movable<AttributeException>();
+  check_nothrow_movable<DataSpaceException>();
+  check_nothrow_movable<DataSetException>();
+  check_nothrow_movable<GroupException>();
+  check_nothrow_movable<PropertyException>();
+  check_nothrow_movable<ReferenceException>();
+  check_nothrow_movable<DataTypeException>();
+}
+
+template<class T>
+constexpr void
+check_nothrow_object() {
+  // HighFive objects are reference counted. During move assignment, the
+  // reference count can drop to zero, triggering freeing of the object, which
+  // can fail. Hence, move assignment can file, but move construction shouldn't.
+  static_assert(std::is_move_constructible_v<T> == std::is_nothrow_move_constructible_v<T>);
+  static_assert(!std::is_nothrow_move_assignable_v<T>);
+  static_assert(!std::is_nothrow_copy_constructible_v<T>);
+  static_assert(!std::is_nothrow_copy_assignable_v<T>);
+}
+
+TEST_CASE("HighFive::Objects are nothrow move constructible", "[core]") {
+  check_nothrow_object<Object>();
+  check_nothrow_object<File>();
+  check_nothrow_object<Attribute>();
+  check_nothrow_object<DataSpace>();
+  check_nothrow_object<DataSet>();
+  check_nothrow_object<Group>();
+  check_nothrow_object<DataType>();
+  check_nothrow_object<Selection>();
+}
+
+TEST_CASE("Regular HighFive objects are nothrow movable", "[core]") {
+  check_nothrow_movable<RegularHyperSlab>();
+  check_nothrow_movable<HyperSlab>();
+  check_nothrow_movable<ElementSet>();
+  check_nothrow_movable<ProductSet>();
+}
+
+TEST_CASE("Nothrow movable data types", "[core]") {
+  check_nothrow_object<AtomicType<double>>();
+  check_nothrow_object<CompoundType>();
+  check_nothrow_object<StringType>();
+}