Add Pair trivial and non trivial destructors and destructor test

Author: Julian LALU

interface/core/containers/pair.h

@@ -32,7 +32,6 @@
 
 namespace hud
 {
-
     /**
      * This class couples together a pair of components, which may be of different types (first_type and second_type). The individual components can be accessed through its public members first and second.
      * pair is a particular case of Tuple.
@@ -58,8 +57,7 @@ namespace hud
          * If one of the component is explicitly default constructible, the pair is explicitly default constructible.
          * pair do not accept throwable default constructible components.
          */
-        constexpr explicit(!(hud::is_implicitly_default_constructible_v<first_type> && hud::is_implicitly_default_constructible_v<second_type>))
-            pair() noexcept
+        constexpr explicit(!(hud::is_implicitly_default_constructible_v<first_type> && hud::is_implicitly_default_constructible_v<second_type>)) pair() noexcept
             : first()
             , second()
         {
@@ -76,8 +74,7 @@ namespace hud
          * @param f An object of the same type as 'first' or some other type implicitly convertible to it.
          * @param s An object of the same type as 'second' or some other type implicitly convertible to it.
          */
-        constexpr explicit(!(hud::is_convertible_v<const first_type &, first_type> && hud::is_convertible_v<const second_type &, second_type>))
-            pair(const first_type &f, const second_type &s) noexcept
+        constexpr explicit(!(hud::is_convertible_v<const first_type &, first_type> && hud::is_convertible_v<const second_type &, second_type>)) pair(const first_type &f, const second_type &s) noexcept
         requires(hud::is_copy_constructible_v<first_type> && hud::is_copy_constructible_v<second_type>)
             : first(f)
             , second(s)
@@ -99,8 +96,7 @@ namespace hud
          */
         template<typename u_type_t = first_type, typename v_type_t = second_type>
         requires(hud::is_move_constructible_v<first_type, u_type_t> && hud::is_move_constructible_v<second_type, v_type_t>)
-        constexpr explicit(!(hud::is_convertible_v<u_type_t &&, first_type> && hud::is_convertible_v<v_type_t &&, second_type>))
-            pair(u_type_t &&f, v_type_t &&s) noexcept
+        constexpr explicit(!(hud::is_convertible_v<u_type_t &&, first_type> && hud::is_convertible_v<v_type_t &&, second_type>)) pair(u_type_t &&f, v_type_t &&s) noexcept
             : first(hud::forward<u_type_t>(f))
             , second(hud::forward<v_type_t>(s))
         {
@@ -116,8 +112,7 @@ namespace hud
          * pair does not accept throwable copy constructible components.
          * @param other Another pair object.
          */
-        constexpr explicit(!(hud::is_convertible_v<const first_type &, first_type> && hud::is_convertible_v<const second_type &, second_type>))
-            pair(const pair &other) noexcept
+        constexpr explicit(!(hud::is_convertible_v<const first_type &, first_type> && hud::is_convertible_v<const second_type &, second_type>)) pair(const pair &other) noexcept
         requires(hud::is_nothrow_copy_constructible_v<first_type> && hud::is_nothrow_copy_constructible_v<second_type>)
         = default;
 
@@ -132,8 +127,7 @@ namespace hud
          */
         template<typename u_type_t, typename v_type_t>
         requires(hud::is_copy_constructible_v<first_type, u_type_t> && hud::is_copy_constructible_v<second_type, v_type_t>)
-        constexpr explicit(!(hud::is_convertible_v<const u_type_t &, first_type> && hud::is_convertible_v<const v_type_t &, second_type>))
-            pair(const pair<u_type_t, v_type_t> &other) noexcept
+        constexpr explicit(!(hud::is_convertible_v<const u_type_t &, first_type> && hud::is_convertible_v<const v_type_t &, second_type>)) pair(const pair<u_type_t, v_type_t> &other) noexcept
             : first(other.first)
             , second(other.second)
         {
@@ -165,8 +159,7 @@ namespace hud
          */
         template<typename u_type_t, typename v_type_t>
         requires(hud::is_move_constructible_v<first_type, u_type_t> && hud::is_move_constructible_v<second_type, v_type_t>)
-        constexpr explicit(!(hud::is_convertible_v<u_type_t, first_type> && hud::is_convertible_v<v_type_t, second_type>))
-            pair(pair<u_type_t, v_type_t> &&other) noexcept
+        constexpr explicit(!(hud::is_convertible_v<u_type_t, first_type> && hud::is_convertible_v<v_type_t, second_type>)) pair(pair<u_type_t, v_type_t> &&other) noexcept
             : first(hud::forward<u_type_t>(other.first))
             , second(hud::forward<v_type_t>(other.second))
         {
@@ -191,6 +184,22 @@ namespace hud
             return *this;
         }
 
+        /**
+         * Destructor; Trivial if first_type and second_type are trivially destructible
+         * This call first_type and second_type destructors.
+         */
+        constexpr ~pair()
+        requires(std::is_trivially_destructible_v<first_type> && std::is_trivially_destructible_v<second_type>)
+        = default;
+
+        /**
+         * Destructor; Trivial if first_type and second_type are trivially destructible
+         * This call first_type and second_type destructors.
+         */
+        constexpr ~pair()
+        requires(!(std::is_trivially_destructible_v<first_type> && std::is_trivially_destructible_v<second_type>))
+        = default;
+
         /**
          * Assigns other as the new content for the pair object.
          * Perform copy assignments, with the elements of its argument preserving their values after the call.

test/CMakeLists.txt

@@ -112,6 +112,7 @@ set( src
 	pair/pair_assignments.cpp
 	pair/pair_comparison.cpp
 	pair/pair_constructors.cpp
+	pair/pair_destructor.cpp
 	pair/pair_misc.cpp
 	pair/pair_swap.cpp
 	shared_pointer/multi_thread/shared_pointer_multi_thread_assignments.cpp

test/pair/pair_destructor.cpp

@@ -0,0 +1,51 @@
+#include <core/containers/pair.h>
+
+GTEST_TEST(pair, destructor_call_inner_components_destructors)
+{
+    using first_type = hud_test::SetBoolToTrueWhenDestroyed;
+    using second_type = hud_test::SetBoolToTrueWhenDestroyed;
+
+    const auto test = []()
+    {
+        i32 destructor_counts[2] = {0};
+        bool destructor_first_ok = true;
+        bool destructor_second_ok = true;
+        {
+            hud::pair<first_type, second_type> pair {&destructor_counts[0], &destructor_counts[1]};
+            destructor_first_ok &= (destructor_counts[0] == 0);
+            destructor_second_ok &= (destructor_counts[1] == 0);
+        }
+        destructor_first_ok &= (destructor_counts[0] == 1);
+        destructor_second_ok &= (destructor_counts[1] == 1);
+        return std::tuple {destructor_first_ok, destructor_second_ok};
+    };
+
+    // Non constant
+    {
+        const auto result = test();
+        hud_assert_true(std::get<0>(result));
+        hud_assert_true(std::get<1>(result));
+    }
+
+    // Constant
+    {
+        constexpr auto result = test();
+        hud_assert_true(std::get<0>(result));
+        hud_assert_true(std::get<1>(result));
+    }
+}
+
+GTEST_TEST(pair, pair_is_trivially_destructible_if_inner_types_are_trivially_destructible)
+{
+    static_assert(hud::is_trivially_destructible_v<hud::pair<i32, i64>>);
+    hud_assert_true((hud::is_trivially_destructible_v<hud::pair<i32, i64>>));
+
+    static_assert(!hud::is_trivially_destructible_v<hud::pair<hud_test::non_bitwise_type, i64>>);
+    hud_assert_true((!hud::is_trivially_destructible_v<hud::pair<hud_test::non_bitwise_type, i64>>));
+
+    static_assert(!hud::is_trivially_destructible_v<hud::pair<i32, hud_test::non_bitwise_type>>);
+    hud_assert_true((!hud::is_trivially_destructible_v<hud::pair<i32, hud_test::non_bitwise_type>>));
+
+    static_assert(!hud::is_trivially_destructible_v<hud::pair<hud_test::non_bitwise_type, hud_test::non_bitwise_type>>);
+    hud_assert_true((!hud::is_trivially_destructible_v<hud::pair<hud_test::non_bitwise_type, hud_test::non_bitwise_type>>));
+}