replace inline constexpr by constrexpr

Author: Julian LALU

interface/core/atomics/atomics_gcc.h

@@ -210,13 +210,13 @@ namespace hud::gcc
     private:
 
     private:
-        static inline constexpr i32 to_gcc_order(memory_order_e order)
+        static constexpr i32 to_gcc_order(memory_order_e order)
         {
             // Avoid switch statement to make this a constexpr.
             return order == memory_order_e::relaxed ? __ATOMIC_RELAXED : (order == memory_order_e::acquire ? __ATOMIC_ACQUIRE : (order == memory_order_e::release ? __ATOMIC_RELEASE : (order == memory_order_e::seq_cst ? __ATOMIC_SEQ_CST : (order == memory_order_e::acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_CONSUME))));
         }
 
-        static inline constexpr i32 to_gcc_failure_order(memory_order_e order)
+        static constexpr i32 to_gcc_failure_order(memory_order_e order)
         {
             // Avoid switch statement to make this a constexpr.
             // This memory order cannot be __ATOMIC_RELEASE nor __ATOMIC_ACQ_REL. It also cannot be a stronger order than that specified by success_memorder.

interface/core/containers/hashset.h

@@ -1448,6 +1448,18 @@ namespace hud
                 {
                     // Move elements to new buffer if any
                     // Relocate slots to newly allocated buffer
+                    // iterate_over_full_slots(old_control_ptr, old_slot_ptr, [this](control_type *control_ptr, slot_type *slot_ptr)
+                    //                         {
+                    //       // Compute the hash
+                    //     u64 hash {hasher_type {}(slot_ptr->key())};
+                    //     // Find H1 slot index
+                    //     u64 h1 {H1(hash)};
+                    //     usize slot_index {find_first_empty_or_deleted(control_ptr_, max_slot_count_, h1)};
+                    //     // Save h2 in control h1 index
+                    //     control::set_h2(control_ptr_, slot_index, H2(hash), max_slot_count_);
+                    //     // Move old slot to new slot
+                    //     hud::memory::move_or_copy_construct_object_then_destroy(slot_ptr_ + slot_index, hud::move(*slot_ptr)); });
+
                     auto [control_full_or_sentinel, slot_full_or_sentinel] = skip_empty_or_deleted(old_control_ptr, old_slot_ptr);
                     while (control_full_or_sentinel != old_control_ptr + old_max_slot_count)
                     {
@@ -1681,6 +1693,54 @@ namespace hud
                 }
             }
 
+            constexpr void iterate_over_full_slots(control_type *control_ptr, auto *slot_ptr, auto callback) noexcept
+            {
+                // When max slot count is less than the probing group
+                // We have cloned control in the group
+                // In this case, we start probing at the sentinel instead of 0
+                if (max_slot_count_ < group_type::SLOT_PER_GROUP - 1)
+                {
+                    group_type group {control_ptr_sentinel()};
+
+                    // In the case of constant expression
+                    // If the hashmap is empty, slot_ptr is nullptr, we don't want to decrement the pointer in the case
+                    // In a non constant expression slot_ptr is located after control in the same memory layout,
+                    // we can safely decrement as soon as we don't read the value
+                    if (hud::is_constant_evaluated())
+                    {
+                        // Iterate over cloned control bytes
+                        for (u32 full_index : group.mask_of_full_slot())
+                        {
+                            callback(control_ptr + full_index, slot_ptr + full_index);
+                        }
+                    }
+                    else
+                    {
+                        --slot_ptr;
+                        // Iterate over cloned control bytes
+                        for (u32 full_index : group.mask_of_full_slot())
+                        {
+                            callback(control_ptr + full_index, slot_ptr + full_index);
+                        }
+                    }
+                }
+                else
+                {
+                    size_t remaining_slots {count()};
+                    while (remaining_slots != 0)
+                    {
+                        group_type group {control_ptr};
+                        for (u32 full_index : group.mask_of_full_slot())
+                        {
+                            callback(control_ptr + full_index, slot_ptr + full_index);
+                            --remaining_slots;
+                        }
+                        control_ptr += group_type::SLOT_PER_GROUP;
+                        slot_ptr += group_type::SLOT_PER_GROUP;
+                    }
+                }
+            }
+
             template<typename slot_t>
             [[nodiscard]] constexpr hud::pair<control_type *, slot_t *> skip_empty_or_deleted(control_type *control_ptr, slot_t *slot_ptr) const noexcept
             {

interface/core/containers/optional.h

@@ -431,7 +431,7 @@ namespace hud
     };
 
     /** Constant used to indicate optional type with uninitialized state. */
-    inline constexpr nullopt_t nullopt {nullopt_t::tag {}};
+    constexpr nullopt_t nullopt {nullopt_t::tag {}};
 
     /**
      * Manages an optional contained value, i.e. a value that may or may not be present.

interface/core/containers/tuple.h

@@ -192,7 +192,7 @@ namespace hud
         };
 
         template<typename pair_t, typename tuple_t>
-        inline constexpr bool is_pair_copy_constructible_to_tuple_v = is_pair_copy_constructible_to_tuple<pair_t, tuple_t>::value;
+        constexpr bool is_pair_copy_constructible_to_tuple_v = is_pair_copy_constructible_to_tuple<pair_t, tuple_t>::value;
 
         /**
          * Check if a tuple<T0,T1> is explicitly copy constructible from pair<first_type,second_type>.
@@ -211,7 +211,7 @@ namespace hud
         };
 
         template<typename pair_t, typename tuple_t>
-        inline constexpr bool is_pair_explicitly_copy_constructible_to_tuple_v = is_pair_explicitly_copy_constructible_to_tuple<pair_t, tuple_t>::value;
+        constexpr bool is_pair_explicitly_copy_constructible_to_tuple_v = is_pair_explicitly_copy_constructible_to_tuple<pair_t, tuple_t>::value;
 
         /**
          * @brief Check if a tuple<T0,T1> is move constructible from pair<first_type,second_type>.
@@ -233,7 +233,7 @@ namespace hud
         };
 
         template<typename pair_t, typename tuple_t>
-        inline constexpr bool is_pair_move_constructible_to_tuple_v = is_pair_move_constructible_to_tuple<pair_t, tuple_t>::value;
+        constexpr bool is_pair_move_constructible_to_tuple_v = is_pair_move_constructible_to_tuple<pair_t, tuple_t>::value;
 
         /**
          * Check if a tuple<T0,T1> is explicitly move constructible from pair<first_type,second_type>.
@@ -252,7 +252,7 @@ namespace hud
         };
 
         template<typename pair_t, typename tuple_t>
-        inline constexpr bool is_pair_explicitly_move_constructible_to_tuple_v = is_pair_explicitly_move_constructible_to_tuple<pair_t, tuple_t>::value;
+        constexpr bool is_pair_explicitly_move_constructible_to_tuple_v = is_pair_explicitly_move_constructible_to_tuple<pair_t, tuple_t>::value;
 
         /**
          * Recursively assign a tuple to another.

interface/core/containers/tuple_size.h

@@ -72,7 +72,7 @@ namespace hud
 
     /** Equalivent of tuple_size<tuple_like>::value. */
     template<typename tuple_like>
-    inline constexpr usize tuple_size_v = tuple_size<tuple_like>::value;
+    constexpr usize tuple_size_v = tuple_size<tuple_like>::value;
 
 } // namespace hud
 

interface/core/hash.h

@@ -509,7 +509,7 @@ namespace hud
 
     /** Equivalent of is_hashable<type_t>::value. */
     template<typename type_t>
-    inline constexpr bool is_hashable_64_v = is_hashable_64<type_t>::value;
+    constexpr bool is_hashable_64_v = is_hashable_64<type_t>::value;
 
     // Traits used to check if a type is hashable
     template<typename type_t, typename = void>
@@ -526,7 +526,7 @@ namespace hud
 
     /** Equivalent of is_hashable<type_t>::value. */
     template<typename type_t>
-    inline constexpr bool is_hashable_32_v = is_hashable_32<type_t>::value;
+    constexpr bool is_hashable_32_v = is_hashable_32<type_t>::value;
 } // namespace hud
 
 #endif // HD_INC_CORE_HASH_H

interface/core/i128.h

@@ -149,11 +149,11 @@ namespace hud
     {
     }
 
-    static inline constexpr i128 i128_max = i128 {i64_max, u64_max};
-    static inline constexpr i128 i128_min = i128 {i64_min, 0u};
+    static constexpr i128 i128_max = i128 {i64_max, u64_max};
+    static constexpr i128 i128_min = i128 {i64_min, 0u};
 
-    static inline constexpr u128 u128_max = u128 {u64_max, u64_max};
-    static inline constexpr u128 u128_min = u128 {u64_min, 0u};
+    static constexpr u128 u128_max = u128 {u64_max, u64_max};
+    static constexpr u128 u128_min = u128 {u64_min, 0u};
 
     template<> struct limits<i128>
     {

interface/core/i128/i128_portable.h

@@ -1223,11 +1223,11 @@ namespace hud
 
     } // namespace details::i128
 
-    // static inline constexpr details::i128::i128_impl i128_max = details::i128::i128_impl {i64_max, u64_max};
-    // static inline constexpr details::i128::i128_impl i128_min = details::i128::i128_impl {i64_min, 0u};
+    // static constexpr details::i128::i128_impl i128_max = details::i128::i128_impl {i64_max, u64_max};
+    // static constexpr details::i128::i128_impl i128_min = details::i128::i128_impl {i64_min, 0u};
 
-    // static inline constexpr details::i128::u128_impl u128_max = details::i128::u128_impl {u64_max, u64_max};
-    // static inline constexpr details::i128::u128_impl u128_min = details::i128::u128_impl {u64_min, 0u};
+    // static constexpr details::i128::u128_impl u128_max = details::i128::u128_impl {u64_max, u64_max};
+    // static constexpr details::i128::u128_impl u128_min = details::i128::u128_impl {u64_min, 0u};
 
     // template<> struct limits<details::i128::i128_impl>
     // {

interface/core/tag_in_place.h

@@ -11,7 +11,7 @@ namespace hud
     };
 
     /** Constant used to indicate to construct an object in-place. */
-    inline constexpr tag_in_place in_place {};
+    constexpr tag_in_place in_place {};
 } // namespace hud
 
 #endif // HD_INC_CORE_INPLACE_H

interface/core/tag_init.h

@@ -17,7 +17,7 @@ namespace hud
     };
 
     /** Constant used to indicate to initialize an object. */
-    inline constexpr tag_init taginit {tag_init::tag {}};
+    constexpr tag_init taginit {tag_init::tag {}};
 
 } // namespace hud