Fix assigning to a vector that has been move-assigned from.

Support minimum sizes greater than 0 in `dynamic_array`.

Make move construction of `uninitialized_dynamic_array` faster at the expense of some copy assignment operators for types that use it.

Support non-default-constructible types in `test_sequence_container`.

Author: davidstone

source/containers/bounded_vector.cpp

@@ -122,13 +122,11 @@ struct [[clang::trivial_abi]] bounded_vector : private lexicographical_compariso
 		if (this == std::addressof(other)) {
 			return *this;
 		}
-		if constexpr (min_capacity > 0_bi) {
-			if (!m_storage.data()) {
-				replace_empty_allocation(other.size());
-				::containers::uninitialized_copy_no_overlap(other, data());
-				m_size = other.m_size;
-				return *this;
-			}
+		if (!m_storage.data()) {
+			replace_empty_allocation(other.size());
+			::containers::uninitialized_copy_no_overlap(other, data());
+			m_size = other.m_size;
+			return *this;
 		}
 		containers::assign(*this, other);
 		return *this;

source/containers/dynamic_array.cpp

@@ -33,9 +33,12 @@ import numeric_traits;
 import std_module;
 
 namespace containers {
+	
+using namespace bounded::literal;
 
 export template<typename T, typename Size = array_size_type<T>>
 struct [[clang::trivial_abi]] dynamic_array : private lexicographical_comparison::base {
+	static_assert(numeric_traits::min_value<Size> >= 0_bi);
 	using size_type = Size;
 
 	constexpr dynamic_array() = default;
@@ -62,12 +65,14 @@ struct [[clang::trivial_abi]] dynamic_array : private lexicographical_comparison
 	}
 
 	constexpr dynamic_array(dynamic_array && other) noexcept:
-		m_data(std::exchange(other.m_data, {}))
+		m_data(std::move(other.m_data))
 	{
 	}
 
 	constexpr ~dynamic_array() {
-		::containers::destroy_range(*this);
+		if (data()) {
+			::containers::destroy_range(*this);
+		}
 	}
 
 	constexpr auto operator=(dynamic_array const & other) & -> dynamic_array & {
@@ -77,9 +82,10 @@ struct [[clang::trivial_abi]] dynamic_array : private lexicographical_comparison
 		return *this;
 	}
 	constexpr auto operator=(dynamic_array && other) & noexcept -> dynamic_array & {
-		::containers::destroy_range(*this);
+		if (data()) {
+			::containers::destroy_range(*this);
+		}
 		m_data = std::move(other.m_data);
-		other.m_data = {};
 		return *this;
 	}
 
@@ -100,13 +106,20 @@ struct [[clang::trivial_abi]] dynamic_array : private lexicographical_comparison
 		*this = {};
 	}
 
+	// Requires that `range` does not alias any elements of `*this`
 	template<size_then_use_range Range> requires(!std::is_array_v<Range> or !std::is_reference_v<Range>)
 	constexpr auto assign(Range && range) & -> void {
-		auto const difference = ::containers::linear_size(range);
-		if (difference == size()) {
+		auto const new_size = ::containers::linear_size(range);
+		if (!data()) {
+			*this = dynamic_array<T, Size>(OPERATORS_FORWARD(range));
+			return;
+		}
+		if (new_size == size()) {
 			::containers::copy(OPERATORS_FORWARD(range), ::containers::begin(*this));
 		} else {
-			clear();
+			if constexpr (numeric_traits::min_value<Size> == 0_bi) {
+				clear();
+			}
 			*this = dynamic_array<T, Size>(OPERATORS_FORWARD(range));
 		}
 	}

source/containers/test/bidirectional_linked_list.cpp

@@ -29,6 +29,8 @@ using namespace bounded::literal;
 
 static_assert(bounded::convertible_to<containers::bidirectional_linked_list<int>::iterator, containers::bidirectional_linked_list<int>::const_iterator>);
 
+static_assert(bounded::default_constructible<containers::bidirectional_linked_list<int>>);
+static_assert(bounded::default_constructible<containers::bidirectional_linked_list<bounded_test::integer>>);
 static_assert(containers_test::test_sequence_container<containers::bidirectional_linked_list<int>>());
 static_assert(containers_test::test_sequence_container<containers::bidirectional_linked_list<bounded_test::integer>>());
 

source/containers/test/dynamic_array.cpp

@@ -13,9 +13,15 @@ import bounded;
 import bounded.test_int;
 import std_module;
 
+static_assert(bounded::default_constructible<containers::dynamic_array<int>>);
+static_assert(bounded::default_constructible<containers::dynamic_array<bounded_test::integer>>);
+
 static_assert(containers_test::test_sequence_container<containers::dynamic_array<int>>());
 static_assert(containers_test::test_sequence_container<containers::dynamic_array<bounded_test::integer>>());
 
+static_assert(containers_test::test_sequence_container<containers::dynamic_array<int, bounded::integer<1, 40>>>());
+static_assert(containers_test::test_sequence_container<containers::dynamic_array<bounded_test::integer, bounded::integer<1, 40>>>());
+
 static_assert(bounded::convertible_to<containers::dynamic_array<bounded_test::integer> const &, std::span<bounded_test::integer const>>);
 static_assert(bounded::convertible_to<containers::dynamic_array<bounded_test::integer> &, std::span<bounded_test::integer>>);
 

source/containers/test/forward_linked_list.cpp

@@ -29,6 +29,8 @@ using namespace bounded::literal;
 
 static_assert(bounded::convertible_to<containers::forward_linked_list<int>::iterator, containers::forward_linked_list<int>::const_iterator>);
 
+static_assert(bounded::default_constructible<containers::forward_linked_list<int>>);
+static_assert(bounded::default_constructible<containers::forward_linked_list<bounded_test::integer>>);
 static_assert(containers_test::test_sequence_container<containers::forward_linked_list<int>>());
 static_assert(containers_test::test_sequence_container<containers::forward_linked_list<bounded_test::non_copyable_integer>>());
 

source/containers/test/small_buffer_optimized_vector.cpp

@@ -20,12 +20,14 @@ namespace {
 
 using namespace bounded::literal;
 
+static_assert(bounded::default_constructible<containers::small_buffer_optimized_vector<int, 40>>);
 static_assert(containers_test::test_sequence_container<containers::small_buffer_optimized_vector<int, 40>>());
 static_assert(containers_test::test_set_size<containers::small_buffer_optimized_vector<int, 1>>());
 
 template<typename T>
 constexpr auto test_sbo_vector_impl(auto const capacity, auto const size) -> void {
 	using container = containers::small_buffer_optimized_vector<T, capacity.value()>;
+	static_assert(bounded::default_constructible<container>);
 	static_assert(containers_test::test_sequence_container<container>());
 	static_assert(containers_test::test_reserve_and_capacity<container>());
 	constexpr auto generator = containers::repeat_default_n<T>(size);
@@ -49,6 +51,7 @@ TEST_CASE("small_buffer_optimized_vector", "[small_buffer_optimized_vector]") {
 	test_sbo_vector<char>(254_bi);
 	test_sbo_vector<char>(255_bi);
 	test_sbo_vector<char>(256_bi);
+	static_assert(bounded::default_constructible<containers::small_buffer_optimized_vector<bounded_test::integer, 3>>);
 	containers_test::test_sequence_container<containers::small_buffer_optimized_vector<bounded_test::integer, 3>>();
 	containers_test::test_reserve_and_capacity<containers::small_buffer_optimized_vector<bounded_test::integer, 3>>();
 	containers_test::test_set_size<containers::small_buffer_optimized_vector<bounded_test::integer, 1>>();

source/containers/test/stable_vector.cpp

@@ -22,6 +22,8 @@ using test_stable_vector = containers::stable_vector<T, 1000_bi>;
 
 static_assert(test_stable_vector<int>::capacity() == 1000_bi);
 
+static_assert(bounded::default_constructible<test_stable_vector<int>>);
+static_assert(bounded::default_constructible<test_stable_vector<bounded_test::integer>>);
 static_assert(containers_test::test_sequence_container<test_stable_vector<int>>());
 static_assert(containers_test::test_sequence_container<test_stable_vector<bounded_test::integer>>());
 

source/containers/test/static_vector.cpp

@@ -57,6 +57,7 @@ using test_static_vector = containers::static_vector<T, 40_bi>;
 
 static_assert(test_static_vector<int>::capacity() == 40_bi);
 
+static_assert(bounded::default_constructible<test_static_vector<int>>);
 static_assert(containers_test::test_sequence_container<test_static_vector<int>>());
 static_assert(containers_test::test_set_size<test_static_vector<int>>());
 
@@ -73,6 +74,7 @@ static_assert(homogeneous_equals(
 static_assert(!bounded::constructible_from<containers::static_vector<int, 1_bi>, containers::c_array<int, 2> &&>);
 
 TEST_CASE("static_vector", "[static_vector]") {
+	static_assert(bounded::default_constructible<test_static_vector<bounded_test::integer>>);
 	containers_test::test_sequence_container<test_static_vector<bounded_test::integer>>();
 	containers_test::test_set_size<test_static_vector<bounded_test::integer>>();
 }

source/containers/test/string.cpp

@@ -23,6 +23,7 @@ auto check_equal(std::string_view const input) {
 }
 
 TEST_CASE("string", "[string]") {
+	static_assert(bounded::default_constructible<containers::string>);
 	containers_test::test_sequence_container<containers::string>();
 	containers_test::test_reserve_and_capacity<containers::string>();
 	containers_test::test_set_size<containers::string>();

source/containers/test/test_sequence_container.cpp

@@ -129,14 +129,23 @@ constexpr auto test_default_copy_assignment_from_non_empty(auto const make) -> v
 	BOUNDED_ASSERT(containers::equal(target, Container()));
 }
 template<typename Container>
-constexpr auto test_copy_assignment_from_moved_from(auto const make) -> void {
+constexpr auto test_copy_assignment_from_move_constructed_from(auto const make) -> void {
 	auto target = Container(make());
 	auto const source = std::move(target);
 	target = source;
 	BOUNDED_ASSERT(containers::equal(target, make()));
 	BOUNDED_ASSERT(containers::equal(target, source));
 }
 template<typename Container>
+constexpr auto test_copy_assignment_from_move_assigned_from(auto const make) -> void {
+	auto target = Container(make());
+	auto source = Container(make());
+	source = std::move(target);
+	target = source;
+	BOUNDED_ASSERT(containers::equal(target, make()));
+	BOUNDED_ASSERT(containers::equal(target, source));
+}
+template<typename Container>
 constexpr auto test_self_copy_assignment(auto const make) -> void {
 	auto copy = Container(make());
 	// Turn off compiler warning for self assignment
@@ -146,11 +155,14 @@ constexpr auto test_self_copy_assignment(auto const make) -> void {
 }
 template<typename Container>
 constexpr auto test_copy_assignment(auto const make) -> void {
-	test_copy_assignment_from_empty<Container>(make);
+	if constexpr (bounded::default_constructible<Container>) {
+		test_copy_assignment_from_empty<Container>(make);
+		test_default_copy_assignment_from_empty<Container>();
+		test_default_copy_assignment_from_non_empty<Container>(make);
+	}
 	test_copy_assignment_from_non_empty<Container>(make);
-	test_default_copy_assignment_from_empty<Container>();
-	test_default_copy_assignment_from_non_empty<Container>(make);
-	test_copy_assignment_from_moved_from<Container>(make);
+	test_copy_assignment_from_move_constructed_from<Container>(make);
+	test_copy_assignment_from_move_assigned_from<Container>(make);
 	test_self_copy_assignment<Container>(make);
 }
 
@@ -169,13 +181,21 @@ constexpr auto test_move_assignment_from_non_empty(auto const make) -> void {
 	BOUNDED_ASSERT(containers::equal(target, make()));
 }
 template<typename Container>
-constexpr auto test_move_assignment_from_moved_from(auto const make) -> void {
+constexpr auto test_move_assignment_from_move_constructed_from(auto const make) -> void {
 	auto target = Container(make());
 	auto temp = std::move(target);
 	target = std::move(temp);
 	BOUNDED_ASSERT(containers::equal(target, make()));
 }
 template<typename Container>
+constexpr auto test_move_assignment_from_move_assigned_from(auto const make) -> void {
+	auto target = Container(make());
+	auto temp = Container(make());
+	temp = std::move(target);
+	target = std::move(temp);
+	BOUNDED_ASSERT(containers::equal(target, make()));
+}
+template<typename Container>
 constexpr auto test_recover_from_self_move(auto const make, auto const & validate) -> void {
 	auto container = Container(make());
 	container = std::move(container);
@@ -194,9 +214,12 @@ constexpr auto test_self_move_assignment(auto const make, auto const & validate)
 }
 template<typename Container>
 constexpr auto test_move_assignment(auto const make) -> void {
-	test_move_assignment_from_empty<Container>(make);
+	if constexpr (bounded::default_constructible<Container>) {
+		test_move_assignment_from_empty<Container>(make);
+	}
 	test_move_assignment_from_non_empty<Container>(make);
-	test_move_assignment_from_moved_from<Container>(make);
+	test_move_assignment_from_move_constructed_from<Container>(make);
+	test_move_assignment_from_move_assigned_from<Container>(make);
 	test_self_move_assignment<Container>(make, [&](Container const & container) { return containers::equal(container, make()); });
 }
 
@@ -240,7 +263,9 @@ constexpr auto test_special_members(auto const make) -> bool {
 			test_copy_assignment<Container>(make);
 		}
 	}
-	test_assignment_from_empty_braces<Container>(make);
+	if constexpr (bounded::default_constructible<Container>) {
+		test_assignment_from_empty_braces<Container>(make);
+	}
 	test_swap(make);
 	return true;
 }
@@ -256,14 +281,16 @@ constexpr auto test_sequence_container() -> bool {
 	static_assert(containers::is_container<Container>);
 	test_forward_range_concepts<Container>();
 
-	test_range_based_for_loop<Container>();
+	if constexpr (bounded::default_constructible<Container>) {
+		test_range_based_for_loop<Container>();
 
-	test_sequence_container_default_constructed_empty<Container>();
-	test_sequence_container_implicit_from_two_empty_braces<Container>();
+		test_sequence_container_default_constructed_empty<Container>();
+		test_sequence_container_implicit_from_two_empty_braces<Container>();
 
-	test_sequence_container_from<Container>([] {
-		return containers::to_array<containers::range_value_t<Container>>({});
-	});
+		test_sequence_container_from<Container>([] {
+			return containers::to_array<containers::range_value_t<Container>>({});
+		});
+	}
 	test_sequence_container_from<Container>([] {
 		return containers::to_array<containers::range_value_t<Container>>({5});
 	});