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

example/main.cpp

@@ -118,13 +118,16 @@ int main() {
 	/*
 		The example will compile just fine if you use any of these instead:
 
+		my_rect rectangles[];
+
 		std::vector<rect_type> rectangles;
 		std::list<rect_type> rectangles;
 
 		std::list<my_rect> rectangles;
 
-		1. The container just needs to be forward-iterable with .begin() and .end().
-		2. The element type just needs to have get_rect() member functions defined (const and non-const).
+		1.	The container needs to be forward-iterable with std::begin() and std::end(),
+			and have its size queryable via std::size().
+		2.	The element type just needs to have get_rect() member functions defined (const and non-const).
 	*/
 
 	rectangles.emplace_back(rect_xywh(0, 0, 20, 40));

src/rectpack2D/best_bin_finder.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <variant>
 #include <cassert>
+#include <algorithm>
 #include "rect_structs.h"
 
 namespace rectpack2D {
@@ -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 (auto it = ordering.first; it != ordering.second; ++it) {
+					const auto& rect = dereference(*it).get_rect();
 
 					if (root.insert(rect.get_wh())) {
 						total_inserted_area += rect.area();
@@ -216,7 +217,7 @@ namespace rectpack2D {
 	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;
+		std::optional<OrderType> best_order;
 
 		int best_total_inserted = -1;
 		auto best_bin = max_bin;
@@ -229,7 +230,7 @@ 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 ([&](const OrderType& current_order) {
 			const auto packing = best_packing_for_ordering(
 				root,
 				current_order,
@@ -242,29 +243,29 @@ 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.has_value()) {
 					if (*total_inserted > best_total_inserted) {
-						best_order = std::addressof(current_order);
+						best_order = current_order;
 						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 = current_order;
 					best_bin = *result_bin;
 				}
 			}
 		});
 
 		{
-			assert(best_order != nullptr);
+			assert(best_order.has_value());
 
 			root.reset(best_bin);
 
-			for (auto& rr : *best_order) {
-				auto& rect = dereference(rr).get_rect();
+			for (auto span = best_order.value(); span.first != span.second; ++span.first) {
+				auto& rect = dereference(*span.first).get_rect();
 
 				if (const auto ret = root.insert(rect.get_wh())) {
 					rect = *ret;

src/rectpack2D/finders_interface.h

@@ -3,6 +3,7 @@
 #include <vector>
 #include <array>
 #include <variant>
+#include <memory>
 #include <algorithm>
 
 #include "insert_and_split.h"
@@ -51,10 +52,12 @@ namespace rectpack2D {
 		Subjects& subjects,
 		const finder_input<F, G>& input
 	) {
-		using order_type = std::remove_reference_t<decltype(subjects)>;
+		// A slightly hacky way of getting the iterator type of any container (including C arrays).
+		using iterator_type = decltype(std::begin(subjects));
+		using order_type = std::pair<iterator_type, iterator_type>;
 
 		return find_best_packing_impl<empty_spaces_type, order_type>(
-			[&subjects](auto callback) { callback(subjects); },
+			[&subjects](auto callback) { callback(order_type(std::begin(subjects), std::end(subjects))); },
 			input
 		);
 	}
@@ -77,43 +80,53 @@ namespace rectpack2D {
 		Comparators... comparators
 	) {
 		using rect_type = output_rect_t<empty_spaces_type>;
-		using order_type = std::vector<rect_type*>;
+		using order_type = std::pair<rect_type**, rect_type**>;
 
 		constexpr auto count_orders = 1 + sizeof...(Comparators);
-		thread_local std::array<order_type, count_orders> orders;
+		std::size_t count_valid_subjects = 0;
 
-		{
-			/* order[0] will always exist since this overload requires at least one comparator */
-			auto& initial_pointers = orders[0];
-			initial_pointers.clear();
+		// Allocate space assuming no rectangle has an area of zero.
+		// The actual size is adjusted later.
+		auto orders = std::make_unique<rect_type*[]>(count_orders * std::size(subjects));
 
-			for (auto& s : subjects) {
-				auto& r = s.get_rect();
+		for (auto& s : subjects) {
+			auto& r = s.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[count_valid_subjects++] = std::addressof(r);
 		}
 
-		std::size_t f = 0;
+		// Cut off any potentially unused rectangle pointers at the end.
+		const auto orders_end = orders.get() + (count_orders * count_valid_subjects);
 
-		auto& orders_ref = orders;
+		for (auto it = orders.get() + count_valid_subjects; it != orders_end; it += count_valid_subjects) {
+			std::copy(orders.get(), orders.get() + count_valid_subjects, it);
+		}
 
-		auto make_order = [&f, &orders_ref](auto& predicate) {
-			std::sort(orders_ref[f].begin(), orders_ref[f].end(), predicate);
+		std::size_t f = 0;
+
+		auto make_order = [&f, &orders, &count_valid_subjects](auto& predicate) {
+			std::sort(
+				orders.get() + (f * count_valid_subjects),
+				orders.get() + ((f + 1) * count_valid_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); } },
+			[count_valid_subjects, &orders, orders_end](auto callback) {
+				for (auto it = orders.get(); it != orders_end; it += count_valid_subjects) {
+					callback(std::make_pair(it, it + count_valid_subjects));
+				}
+			},
 			input
 		);
 	}