diff --git a/ref_app/src/math/wide_integer/uintwide_t.h b/ref_app/src/math/wide_integer/uintwide_t.h index 0713b91d1..0469fd22a 100644 --- a/ref_app/src/math/wide_integer/uintwide_t.h +++ b/ref_app/src/math/wide_integer/uintwide_t.h @@ -690,32 +690,28 @@ explicit constexpr dynamic_array(size_type count_in, const_reference value_in = value_type(), const allocator_type& alloc_in = allocator_type()) - : elem_count(count_in) + : elem_count(count_in), + my_alloc(alloc_in) { if(elem_count > static_cast(UINT8_C(0))) { - allocator_type my_alloc(alloc_in); - elems = std::allocator_traits::allocate(my_alloc, elem_count); iterator it = begin(); while(it != end()) { - std::allocator_traits::construct(my_alloc, it, value_in); - - ++it; + *it++ = value_in; } } } constexpr dynamic_array(const dynamic_array& other) - : elem_count(other.size()) + : elem_count(other.elem_count), + my_alloc(other.my_alloc) { if(elem_count > static_cast(UINT8_C(0))) { - allocator_type my_alloc; - elems = std::allocator_traits::allocate(my_alloc, elem_count); #if defined(WIDE_INTEGER_NAMESPACE) @@ -730,12 +726,11 @@ constexpr dynamic_array(input_iterator first, input_iterator last, const allocator_type& alloc_in = allocator_type()) - : elem_count(static_cast(last - first)) + : elem_count(static_cast(last - first)), + my_alloc(alloc_in) { if(elem_count > static_cast(UINT8_C(0))) { - allocator_type my_alloc(alloc_in); - elems = std::allocator_traits::allocate(my_alloc, elem_count); #if defined(WIDE_INTEGER_NAMESPACE) @@ -748,12 +743,11 @@ constexpr dynamic_array(std::initializer_list lst, const allocator_type& alloc_in = allocator_type()) - : elem_count(lst.size()) + : elem_count(lst.size()), + my_alloc(alloc_in) { if(elem_count > static_cast(UINT8_C(0))) { - allocator_type my_alloc(alloc_in); - elems = std::allocator_traits::allocate(my_alloc, elem_count); #if defined(WIDE_INTEGER_NAMESPACE) @@ -766,22 +760,20 @@ // Move constructor. constexpr dynamic_array(dynamic_array&& other) noexcept : elem_count(other.elem_count), - elems (other.elems) + elems (other.elems), + my_alloc (std::move(other.my_alloc)) { other.elem_count = static_cast(UINT8_C(0)); other.elems = nullptr; } // Destructor. - //constexpr virtual ~dynamic_array() { if(!empty()) { using local_allocator_traits_type = std::allocator_traits; - allocator_type my_alloc { }; - // Deallocate the range of *this. local_allocator_traits_type::deallocate(my_alloc, elems, elem_count); @@ -820,60 +812,61 @@ // Move assignment operator. constexpr auto operator=(dynamic_array&& other) noexcept -> dynamic_array& { - if(!empty()) + if(this != &other) { - using local_allocator_traits_type = std::allocator_traits; - - allocator_type my_alloc { }; + if(!empty()) + { + using local_allocator_traits_type = std::allocator_traits; - // Deallocate the range of *this. - local_allocator_traits_type::deallocate(my_alloc, elems, elem_count); - } + // Deallocate the range of *this. + local_allocator_traits_type::deallocate(my_alloc, elems, elem_count); + } - elem_count = other.elem_count; - elems = other.elems; + elem_count = other.elem_count; + elems = other.elems; - other.elem_count = static_cast(UINT8_C(0)); - other.elems = nullptr; + other.elem_count = static_cast(UINT8_C(0)); + other.elems = nullptr; + } return *this; } // Iterator members: - constexpr auto begin () -> iterator { return elems; } - constexpr auto end () -> iterator { return elems + elem_count; } - constexpr auto begin () const -> const_iterator { return elems; } - constexpr auto end () const -> const_iterator { return elems + elem_count; } - constexpr auto cbegin () const -> const_iterator { return elems; } - constexpr auto cend () const -> const_iterator { return elems + elem_count; } - constexpr auto rbegin () -> reverse_iterator { return reverse_iterator(elems + elem_count); } - constexpr auto rend () -> reverse_iterator { return reverse_iterator(elems); } - constexpr auto rbegin () const -> const_reverse_iterator { return const_reverse_iterator(elems + elem_count); } - constexpr auto rend () const -> const_reverse_iterator { return const_reverse_iterator(elems); } - constexpr auto crbegin() const -> const_reverse_iterator { return const_reverse_iterator(elems + elem_count); } - constexpr auto crend () const -> const_reverse_iterator { return const_reverse_iterator(elems); } + WIDE_INTEGER_NODISCARD constexpr auto begin () -> iterator { return elems; } + WIDE_INTEGER_NODISCARD constexpr auto end () -> iterator { return elems + elem_count; } + WIDE_INTEGER_NODISCARD constexpr auto begin () const -> const_iterator { return elems; } + WIDE_INTEGER_NODISCARD constexpr auto end () const -> const_iterator { return elems + elem_count; } + WIDE_INTEGER_NODISCARD constexpr auto cbegin () const -> const_iterator { return elems; } + WIDE_INTEGER_NODISCARD constexpr auto cend () const -> const_iterator { return elems + elem_count; } + WIDE_INTEGER_NODISCARD constexpr auto rbegin () -> reverse_iterator { return reverse_iterator(elems + elem_count); } + WIDE_INTEGER_NODISCARD constexpr auto rend () -> reverse_iterator { return reverse_iterator(elems); } + WIDE_INTEGER_NODISCARD constexpr auto rbegin () const -> const_reverse_iterator { return const_reverse_iterator(elems + elem_count); } + WIDE_INTEGER_NODISCARD constexpr auto rend () const -> const_reverse_iterator { return const_reverse_iterator(elems); } + WIDE_INTEGER_NODISCARD constexpr auto crbegin() const -> const_reverse_iterator { return const_reverse_iterator(elems + elem_count); } + WIDE_INTEGER_NODISCARD constexpr auto crend () const -> const_reverse_iterator { return const_reverse_iterator(elems); } // Raw pointer access. - constexpr auto data() -> pointer { return elems; } - constexpr auto data() const -> const_pointer { return elems; } + WIDE_INTEGER_NODISCARD constexpr auto data() -> pointer { return elems; } + WIDE_INTEGER_NODISCARD constexpr auto data() const -> const_pointer { return elems; } // Size and capacity. - constexpr auto size () const noexcept -> size_type { return elem_count; } - constexpr auto max_size() const noexcept -> size_type { return elem_count; } - constexpr auto empty () const noexcept -> bool { return (elem_count == static_cast(UINT8_C(0))); } + WIDE_INTEGER_NODISCARD constexpr auto size () const noexcept -> size_type { return elem_count; } + WIDE_INTEGER_NODISCARD constexpr auto max_size() const noexcept -> size_type { return elem_count; } + WIDE_INTEGER_NODISCARD constexpr auto empty () const noexcept -> bool { return (elem_count == static_cast(UINT8_C(0))); } // Element access members. - constexpr auto operator[](const size_type i) -> reference { return elems[i]; } - constexpr auto operator[](const size_type i) const -> const_reference { return elems[i]; } + WIDE_INTEGER_NODISCARD constexpr auto operator[](const size_type i) -> reference { return elems[i]; } + WIDE_INTEGER_NODISCARD constexpr auto operator[](const size_type i) const -> const_reference { return elems[i]; } - constexpr auto front() -> reference { return elems[static_cast(UINT8_C(0))]; } - constexpr auto front() const -> const_reference { return elems[static_cast(UINT8_C(0))]; } + WIDE_INTEGER_NODISCARD constexpr auto front() -> reference { return elems[static_cast(UINT8_C(0))]; } + WIDE_INTEGER_NODISCARD constexpr auto front() const -> const_reference { return elems[static_cast(UINT8_C(0))]; } - constexpr auto back() -> reference { return ((elem_count > static_cast(UINT8_C(0))) ? elems[static_cast(elem_count - static_cast(UINT8_C(1)))] : elems[static_cast(UINT8_C(0))]); } - constexpr auto back() const -> const_reference { return ((elem_count > static_cast(UINT8_C(0))) ? elems[static_cast(elem_count - static_cast(UINT8_C(1)))] : elems[static_cast(UINT8_C(0))]); } + WIDE_INTEGER_NODISCARD constexpr auto back() -> reference { return ((elem_count > static_cast(UINT8_C(0))) ? elems[static_cast(elem_count - static_cast(UINT8_C(1)))] : elems[static_cast(UINT8_C(0))]); } + WIDE_INTEGER_NODISCARD constexpr auto back() const -> const_reference { return ((elem_count > static_cast(UINT8_C(0))) ? elems[static_cast(elem_count - static_cast(UINT8_C(1)))] : elems[static_cast(UINT8_C(0))]); } - constexpr auto at(const size_type i) -> reference { return ((i < elem_count) ? elems[i] : elems[static_cast(UINT8_C(0))]); } - constexpr auto at(const size_type i) const -> const_reference { return ((i < elem_count) ? elems[i] : elems[static_cast(UINT8_C(0))]); } + WIDE_INTEGER_NODISCARD constexpr auto at(const size_type i) -> reference { return ((i < elem_count) ? elems[i] : elems[static_cast(UINT8_C(0))]); } + WIDE_INTEGER_NODISCARD constexpr auto at(const size_type i) const -> const_reference { return ((i < elem_count) ? elems[i] : elems[static_cast(UINT8_C(0))]); } // Element manipulation members. constexpr auto fill(const value_type& value_in) -> void @@ -892,24 +885,19 @@ #if defined(WIDE_INTEGER_NAMESPACE) WIDE_INTEGER_NAMESPACE::math::wide_integer::detail::swap_unsafe(elems, other.elems); WIDE_INTEGER_NAMESPACE::math::wide_integer::detail::swap_unsafe(elem_count, other.elem_count); + WIDE_INTEGER_NAMESPACE::math::wide_integer::detail::swap_unsafe(my_alloc, other.my_alloc); #else ::math::wide_integer::detail::swap_unsafe(elems, other.elems); ::math::wide_integer::detail::swap_unsafe(elem_count, other.elem_count); + ::math::wide_integer::detail::swap_unsafe(my_alloc, other.my_alloc); #endif } } - constexpr auto swap(dynamic_array&& other) noexcept -> void - { - dynamic_array tmp { std::move(*this) }; - - *this = std::move(static_cast(other)); - other = std::move(static_cast(tmp)); - } - private: - mutable size_type elem_count; // NOLINT(readability-identifier-naming) - pointer elems { nullptr }; // NOLINT(readability-identifier-naming,altera-id-dependent-backward-branch) + size_type elem_count { static_cast(UINT8_C(0)) }; // NOLINT(readability-identifier-naming) + pointer elems { nullptr }; // NOLINT(readability-identifier-naming,altera-id-dependent-backward-branch) + allocator_type my_alloc; // NOLINT(readability-identifier-naming) friend constexpr auto operator==(const dynamic_array& lhs, const dynamic_array& rhs) -> bool { diff --git a/ref_app/src/util/utility/util_dynamic_array.h b/ref_app/src/util/utility/util_dynamic_array.h index 7a16768d4..624461ebd 100644 --- a/ref_app/src/util/utility/util_dynamic_array.h +++ b/ref_app/src/util/utility/util_dynamic_array.h @@ -1,5 +1,5 @@ /////////////////////////////////////////////////////////////////////////////// -// Copyright Christopher Kormanyos 2012 - 2025. +// Copyright Christopher Kormanyos 2012 - 2026. // 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) @@ -46,74 +46,71 @@ using const_reverse_iterator = std::reverse_iterator; // Constructors. - explicit constexpr dynamic_array( size_type count = static_cast(UINT8_C(0)), - const_reference v = value_type(), - const allocator_type& a = allocator_type()) - : elem_count(count) + constexpr dynamic_array() = delete; + + explicit constexpr dynamic_array(size_type count_in, + const_reference value_in = value_type(), + const allocator_type& alloc_in = allocator_type()) + : elem_count(count_in), + my_alloc(alloc_in) { if(elem_count > static_cast(UINT8_C(0))) { - allocator_type my_a(a); - - elems = std::allocator_traits::allocate(my_a, elem_count); + elems = std::allocator_traits::allocate(my_alloc, elem_count); iterator it = begin(); while(it != end()) { - std::allocator_traits::construct(my_a, it, v); - - ++it; + *it++ = value_in; } } } constexpr dynamic_array(const dynamic_array& other) - : elem_count(other.size()) + : elem_count(other.elem_count), + my_alloc(other.my_alloc) { - allocator_type my_a; - if(elem_count > static_cast(UINT8_C(0))) { - elems = std::allocator_traits::allocate(my_a, elem_count); - } + elems = std::allocator_traits::allocate(my_alloc, elem_count); - std::copy(other.elems, other.elems + elem_count, elems); + std::copy(other.elems, other.elems + elem_count, elems); + } } template constexpr dynamic_array(input_iterator first, input_iterator last, - const allocator_type& a = allocator_type()) - : elem_count(static_cast(std::distance(first, last))) + const allocator_type& alloc_in = allocator_type()) + : elem_count(static_cast(std::distance(first, last))), + my_alloc(alloc_in) { - allocator_type my_a(a); - if(elem_count > static_cast(UINT8_C(0))) { - elems = std::allocator_traits::allocate(my_a, elem_count); - } + elems = std::allocator_traits::allocate(my_alloc, elem_count); - std::copy(first, last, elems); + std::copy(first, last, elems); + } } constexpr dynamic_array(std::initializer_list lst, - const allocator_type& a = allocator_type()) - : elem_count(lst.size()) + const allocator_type& alloc_in = allocator_type()) + : elem_count(lst.size()), + my_alloc(alloc_in) { - allocator_type my_a(a); - if(elem_count > static_cast(UINT8_C(0))) { - elems = std::allocator_traits::allocate(my_a, elem_count); - } + elems = std::allocator_traits::allocate(my_alloc, elem_count); - std::copy(lst.begin(), lst.end(), elems); + std::copy(lst.begin(), lst.end(), elems); + } } // Move constructor. constexpr dynamic_array(dynamic_array&& other) noexcept : elem_count(other.elem_count), - elems (other.elems) + elems (other.elems), + my_alloc (std::move(other.my_alloc)) { other.elem_count = static_cast(UINT8_C(0)); other.elems = nullptr; @@ -122,12 +119,16 @@ // Destructor. virtual ~dynamic_array() // LCOV_EXCL_LINE { - using local_allocator_traits_type = std::allocator_traits; + if(!empty()) + { + using local_allocator_traits_type = std::allocator_traits; - allocator_type my_a; + // Deallocate the range of *this. + local_allocator_traits_type::deallocate(my_alloc, elems, elem_count); - // Destroy the elements and deallocate the range. - local_allocator_traits_type::deallocate(my_a, elems, elem_count); + elem_count = static_cast(UINT8_C(0)); + elems = nullptr; + } } // Assignment operator. @@ -203,54 +204,36 @@ } } - constexpr auto swap(dynamic_array&& other) noexcept -> void - { - elems = std::move(other.elems); - elem_count = std::move(other.elem_count); - } - private: - size_type elem_count; // NOLINT(readability-identifier-naming) - pointer elems { nullptr }; // NOLINT(readability-identifier-naming,altera-id-dependent-backward-branch) - }; - - template - auto operator==(const dynamic_array& lhs, - const dynamic_array& rhs) -> bool - { - bool left_and_right_are_equal = false; + size_type elem_count { static_cast(UINT8_C(0)) }; // NOLINT(readability-identifier-naming) + pointer elems { nullptr }; // NOLINT(readability-identifier-naming,altera-id-dependent-backward-branch) + allocator_type my_alloc; // NOLINT(readability-identifier-naming) - if(lhs.size() == rhs.size()) + friend constexpr auto operator==(const dynamic_array& lhs, const dynamic_array& rhs) -> bool { - using size_type = typename dynamic_array::size_type; + bool left_and_right_are_equal = false; - const auto size_of_left_is_zero = (lhs.size() == static_cast(UINT8_C(0))); + if(lhs.size() == rhs.size()) + { + using size_type = typename dynamic_array::size_type; - left_and_right_are_equal = - (size_of_left_is_zero || std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin())); - } + const auto size_of_left_is_zero = (lhs.size() == static_cast(UINT8_C(0))); - return left_and_right_are_equal; - } + left_and_right_are_equal = + (size_of_left_is_zero || std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin())); - template - auto operator<(const dynamic_array& lhs, - const dynamic_array& rhs) -> bool - { - using size_type = typename dynamic_array::size_type; + return left_and_right_are_equal; + } + } - const auto size_of_left_is_zero = (lhs.size() == static_cast(UINT8_C(0))); + friend constexpr auto operator<(const dynamic_array& lhs, const dynamic_array& rhs) -> bool + { + using size_type = typename dynamic_array::size_type; - bool b_result { }; + const auto size_of_left_is_zero = (lhs.size() == static_cast(UINT8_C(0))); - if(size_of_left_is_zero) - { - const auto size_of_right_is_zero = (rhs.size() == static_cast(UINT8_C(0))); + bool b_result { }; - b_result = (!size_of_right_is_zero); - } - else - { if(size_of_left_is_zero) { const auto size_of_right_is_zero = (rhs.size() == static_cast(UINT8_C(0))); @@ -259,49 +242,35 @@ } else { - const size_type count = (std::min)(lhs.size(), rhs.size()); - - b_result= std::lexicographical_compare(lhs.cbegin(), - lhs.cbegin() + count, - rhs.cbegin(), - rhs.cbegin() + count); - } - } - - return b_result; - } + if(size_of_left_is_zero) + { + const auto size_of_right_is_zero = (rhs.size() == static_cast(UINT8_C(0))); - template - auto operator!=(const dynamic_array& lhs, - const dynamic_array& rhs) -> bool - { - return (!(lhs == rhs)); - } + b_result = (!size_of_right_is_zero); + } + else + { + const size_type count = (std::min)(lhs.size(), rhs.size()); - template - auto operator>(const dynamic_array& lhs, - const dynamic_array& rhs) -> bool - { - return (rhs < lhs); - } + b_result= std::lexicographical_compare(lhs.cbegin(), + lhs.cbegin() + count, + rhs.cbegin(), + rhs.cbegin() + count); + } + } - template - auto operator>=(const dynamic_array& lhs, - const dynamic_array& rhs) -> bool - { - return (!(lhs < rhs)); - } + return b_result; + } - template - auto operator<=(const dynamic_array& lhs, - const dynamic_array& rhs) -> bool - { - return (!(rhs < lhs)); - } + friend constexpr auto operator!=(const dynamic_array& lhs, const dynamic_array& rhs) -> bool { return (!(lhs == rhs)); } + friend constexpr auto operator> (const dynamic_array& lhs, const dynamic_array& rhs) -> bool { return (rhs < lhs); } + friend constexpr auto operator>=(const dynamic_array& lhs, const dynamic_array& rhs) -> bool { return (!(lhs < rhs)); } + friend constexpr auto operator<=(const dynamic_array& lhs, const dynamic_array& rhs) -> bool { return (!(rhs < lhs)); } + }; template - auto swap(dynamic_array& x, - dynamic_array& y) noexcept -> void + constexpr auto swap(dynamic_array& x, + dynamic_array& y) noexcept -> void { x.swap(y); }