find_best_packing: store orders side-by-side in a single vector

.gitignore

@@ -1,6 +1,7 @@
 /cmake-build-debug/
 .DS_Store
 .idea
+.cache/
 *.iml
 example/clang_commands.sh
 example/main

src/CMakeLists.txt

@@ -4,4 +4,4 @@ target_include_directories(
     rectpack2D
     INTERFACE
         ${CMAKE_CURRENT_SOURCE_DIR}/
-)
+)

src/rectpack2D/best_bin_finder.h

@@ -44,10 +44,11 @@ namespace rectpack2D {
 		HEIGHT
 	};
 
-	template <class empty_spaces_type, class O>
+	template <class empty_spaces_type, class OrderingIterator>
 	std::variant<total_area_type, rect_wh> best_packing_for_ordering_impl(
 		empty_spaces_type& root,
-		O ordering,
+		OrderingIterator ordering_begin,
+		OrderingIterator ordering_end,
 		const rect_wh starting_bin,
 		int discard_step,
 		const bin_dimension tried_dimension
@@ -88,8 +89,8 @@ namespace rectpack2D {
 			int total_inserted_area = 0;
 
 			const bool all_inserted = [&]() {
-				for (const auto& r : ordering) {
-					const auto& rect = dereference(r).get_rect();
+				for (OrderingIterator it = ordering_begin; it != ordering_end; ++it) {
+					const auto& rect = dereference(*it).get_rect();
 
 					if (root.insert(rect.get_wh())) {
 						total_inserted_area += rect.area();
@@ -158,10 +159,11 @@ namespace rectpack2D {
 		}
 	}
 
-	template <class empty_spaces_type, class O>
+	template <class empty_spaces_type, class OrderingIterator>
 	std::variant<total_area_type, rect_wh> best_packing_for_ordering(
 		empty_spaces_type& root,
-		O&& ordering,
+		OrderingIterator ordering_begin,
+		OrderingIterator ordering_end,
 		const rect_wh starting_bin,
 		const int discard_step
 	) {
@@ -171,7 +173,8 @@ namespace rectpack2D {
 		) {
 			return best_packing_for_ordering_impl(
 				root,
-				std::forward<O>(ordering),
+				ordering_begin,
+				ordering_end,
 				starting_bin,
 				discard_step,
 				tried_dimension
@@ -209,14 +212,14 @@ namespace rectpack2D {
 
 	template <
 		class empty_spaces_type, 
-		class OrderType,
+		class OrderingIterator,
 		class F,
 		class I
 	>
 	rect_wh find_best_packing_impl(F for_each_order, const I input) {
 		const auto max_bin = rect_wh(input.max_bin_side, input.max_bin_side);
 
-		OrderType* best_order = nullptr;
+		OrderingIterator best_order_begin = OrderingIterator{}, best_order_end;
 
 		int best_total_inserted = -1;
 		auto best_bin = max_bin;
@@ -229,10 +232,11 @@ namespace rectpack2D {
 		thread_local empty_spaces_type root = rect_wh();
 		root.flipping_mode = input.flipping_mode;
 
-		for_each_order ([&](OrderType& current_order) {
+		for_each_order ([&](OrderingIterator ordering_begin, OrderingIterator ordering_end) {
 			const auto packing = best_packing_for_ordering(
 				root,
-				current_order,
+				ordering_begin,
+				ordering_end,
 				max_bin,
 				input.discard_step
 			);
@@ -242,29 +246,31 @@ namespace rectpack2D {
 					Track which function inserts the most area in total,
 					just in case that all orders will fail to fit into the largest allowed bin.
 				*/
-				if (best_order == nullptr) {
+				if (best_order_begin == OrderingIterator{}) {
 					if (*total_inserted > best_total_inserted) {
-						best_order = std::addressof(current_order);
+						best_order_begin = ordering_begin;
+						best_order_end = ordering_end;
 						best_total_inserted = *total_inserted;
 					}
 				}
 			}
 			else if (const auto result_bin = std::get_if<rect_wh>(&packing)) {
 				/* Save the function if it performed the best. */
 				if (result_bin->area() <= best_bin.area()) {
-					best_order = std::addressof(current_order);
+					best_order_begin = ordering_begin;
+					best_order_end = ordering_end;
 					best_bin = *result_bin;
 				}
 			}
 		});
 
 		{
-			assert(best_order != nullptr);
+			assert(best_order_begin != OrderingIterator{});
 
 			root.reset(best_bin);
 
-			for (auto& rr : *best_order) {
-				auto& rect = dereference(rr).get_rect();
+			for (OrderingIterator it = best_order_begin; it != best_order_end; ++it) {
+				auto& rect = dereference(*it).get_rect();
 
 				if (const auto ret = root.insert(rect.get_wh())) {
 					rect = *ret;

src/rectpack2D/finders_interface.h

@@ -51,10 +51,10 @@ namespace rectpack2D {
 		Subjects& subjects,
 		const finder_input<F, G>& input
 	) {
-		using order_type = std::remove_reference_t<decltype(subjects)>;
+		using iterator_type = decltype(std::begin(subjects));
 
-		return find_best_packing_impl<empty_spaces_type, order_type>(
-			[&subjects](auto callback) { callback(subjects); },
+		return find_best_packing_impl<empty_spaces_type, iterator_type>(
+			[&subjects](auto callback) { callback(std::begin(subjects), std::end(subjects)); },
 			input
 		);
 	}
@@ -63,7 +63,7 @@ namespace rectpack2D {
 	/*
 		Finds the best packing for the rectangles.
 		Accepts a list of predicates able to compare two input rectangles.
-	   
+
 		The function will try to pack the rectangles in all orders generated by the predicates,
 		and will only write the x, y coordinates of the best packing found among the orders.
 	*/
@@ -77,43 +77,61 @@ namespace rectpack2D {
 		Comparators... comparators
 	) {
 		using rect_type = output_rect_t<empty_spaces_type>;
-		using order_type = std::vector<rect_type*>;
 
 		constexpr auto count_orders = 1 + sizeof...(Comparators);
-		thread_local std::array<order_type, count_orders> orders;
+		const std::size_t count_subjects = std::count_if(
+			std::begin(subjects),
+			std::end(subjects),
+			[](const auto& sub) {
+				return sub.get_rect().area() != 0;
+			}
+		);
 
-		{
-			/* order[0] will always exist since this overload requires at least one comparator */
-			auto& initial_pointers = orders[0];
-			initial_pointers.clear();
+		std::vector<rect_type*> orders(count_orders * count_subjects);
 
-			for (auto& s : subjects) {
-				auto& r = s.get_rect();
+		for (std::size_t i = 0; i < count_subjects; ++i) {
+			auto& r = subjects[i].get_rect();
 
-				if (r.area() > 0) {
-					initial_pointers.emplace_back(std::addressof(r));
-				}
+			if (r.area() == 0) {
+				continue;
 			}
 
-			for (std::size_t i = 1; i < count_orders; ++i) {
-				orders[i] = initial_pointers;
-			}
+			orders[i] = std::addressof(r);
 		}
 
-		std::size_t f = 0;
+		std::transform(
+			std::begin(subjects),
+			std::end(subjects),
+			orders.begin(),
+			[](auto& sub) { return &sub.get_rect(); }
+		);
 
+		for (auto it = orders.begin() + count_subjects; it != orders.end(); it += count_subjects) {
+			std::copy(orders.begin(), orders.begin() + count_subjects, it);
+		}
+
+		std::size_t f = 0;
 		auto& orders_ref = orders;
 
-		auto make_order = [&f, &orders_ref](auto& predicate) {
-			std::sort(orders_ref[f].begin(), orders_ref[f].end(), predicate);
+		auto make_order = [&f, &orders_ref, &count_subjects](auto& predicate) {
+			std::sort(
+				orders_ref.begin() + (f * count_subjects),
+				orders_ref.begin() + ((f + 1) * count_subjects),
+				predicate
+			);
 			++f;
 		};
 
 		make_order(comparator);
 		(make_order(comparators), ...);
 
-		return find_best_packing_impl<empty_spaces_type, order_type>(
-			[&orders_ref](auto callback){ for (auto& o : orders_ref) { callback(o); } },
+
+		return find_best_packing_impl<empty_spaces_type, decltype(std::begin(orders))>(
+			[count_subjects, &orders_ref](auto callback) {
+				for (auto it = orders_ref.begin(); it != orders_ref.end(); it += count_subjects) {
+					callback(it, it + count_subjects);
+				}
+			},
 			input
 		);
 	}