Market use country index instead of instance

Author: wvpm

src/openvic-simulation/country/CountryInstance.cpp

@@ -2051,7 +2051,7 @@ void CountryInstance::manage_national_stockpile(
 			market_instance.place_market_sell_order(
 				{
 					good_instance.get_good_definition(),
-					this,
+					get_index(),
 					quantity_to_sell,
 					this,
 					after_sell,
@@ -2131,7 +2131,7 @@ void CountryInstance::manage_national_stockpile(
 			market_instance.place_buy_up_to_order(
 				{
 					good_definition,
-					this,
+					get_index(),
 					max_quantity_to_buy,
 					money_to_spend,
 					this,

src/openvic-simulation/economy/production/ResourceGatheringOperation.cpp

@@ -147,7 +147,9 @@ void ResourceGatheringOperation::rgo_tick(memory::vector<fixed_point_t>& reusabl
 		market_instance.place_market_sell_order(
 			{
 				production_type.get_output_good(),
-				country_to_report_economy_nullable,
+				country_to_report_economy_nullable == nullptr
+					? std::nullopt
+					: std::optional<size_t>{country_to_report_economy_nullable->get_index()},
 				output_quantity_yesterday,
 				this,
 				after_sell,

src/openvic-simulation/economy/trading/BuyUpToOrder.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <cstddef>
+#include <optional>
+
 #include "openvic-simulation/economy/trading/BuyResult.hpp"
 
 namespace OpenVic {
@@ -14,17 +17,17 @@ namespace OpenVic {
 		const callback_t after_trade;
 
 	public:
-		CountryInstance const* const country_nullable;
+		const std::optional<size_t> country_index_optional;
 		const fixed_point_t max_quantity;
 		const fixed_point_t money_to_spend;
 
 		constexpr GoodBuyUpToOrder(
-			CountryInstance const* const new_country_nullable,
+			const std::optional<size_t> new_country_index_optional,
 			const fixed_point_t new_max_quantity,
 			const fixed_point_t new_money_to_spend,
 			const actor_t new_actor,
 			const callback_t new_after_trade
-		) : country_nullable { new_country_nullable },
+		) : country_index_optional { new_country_index_optional },
 			max_quantity { new_max_quantity },
 			money_to_spend { new_money_to_spend },
 			actor { new_actor },
@@ -47,13 +50,13 @@ namespace OpenVic {
 
 		constexpr BuyUpToOrder(
 			GoodDefinition const& new_good,
-			CountryInstance const* const new_country_nullable,
+			const std::optional<size_t> new_country_index_optional,
 			const fixed_point_t new_max_quantity,
 			const fixed_point_t new_money_to_spend,
 			const actor_t new_actor,
 			const callback_t new_after_trade
 		) : GoodBuyUpToOrder {
-				new_country_nullable,
+				new_country_index_optional,
 				new_max_quantity,
 				new_money_to_spend,
 				new_actor,

src/openvic-simulation/economy/trading/GoodMarket.cpp

@@ -68,7 +68,7 @@ void GoodMarket::add_market_sell_order(GoodMarketSellOrder&& market_sell_order)
 void GoodMarket::execute_orders(
 	IndexedFlatMap<CountryInstance, fixed_point_t>& reusable_country_map_0,
 	IndexedFlatMap<CountryInstance, fixed_point_t>& reusable_country_map_1,
-	utility::forwardable_span<
+	std::span<
 		memory::vector<fixed_point_t>,
 		VECTORS_FOR_EXECUTE_ORDERS
 	> reusable_vectors
@@ -123,9 +123,9 @@ void GoodMarket::execute_orders(
 		IndexedFlatMap<CountryInstance, fixed_point_t>& supply_per_country = reusable_country_map_0;
 		IndexedFlatMap<CountryInstance, fixed_point_t>& actual_bought_per_country = reusable_country_map_1;
 		for (GoodMarketSellOrder const& market_sell_order : market_sell_orders) {
-			CountryInstance const* const country_nullable = market_sell_order.country_nullable;
-			if (country_nullable != nullptr) {
-				supply_per_country.at(*country_nullable) += market_sell_order.quantity;
+			const std::optional<size_t> country_index_optional = market_sell_order.country_index_optional;
+			if (country_index_optional.has_value()) {
+				supply_per_country.at_index(country_index_optional.value()) += market_sell_order.quantity;
 			}
 			supply_sum += market_sell_order.quantity;
 		}
@@ -191,10 +191,10 @@ void GoodMarket::execute_orders(
 						continue;
 					}
 
-					CountryInstance const* const country_nullable = buy_up_to_order.country_nullable;
-					if (country_nullable != nullptr) {
+					const std::optional<size_t> country_index_optional = buy_up_to_order.country_index_optional;
+					if (country_index_optional.has_value()) {
 						//subtract as it might be updated below
-						actual_bought_per_country.at(*country_nullable) -= distributed_supply;
+						actual_bought_per_country.at_index(country_index_optional.value()) -= distributed_supply;
 					}
 
 					distributed_supply = fixed_point_t::mul_div(
@@ -210,8 +210,8 @@ void GoodMarket::execute_orders(
 						purchasing_power_sum -= purchasing_power_per_order[i];
 					}
 
-					if (country_nullable != nullptr) {
-						actual_bought_per_country.at(*country_nullable) += distributed_supply;
+					if (country_index_optional.has_value()) {
+						actual_bought_per_country.at_index(country_index_optional.value()) += distributed_supply;
 					}
 
 					if (someone_bought_max_quantity) {
@@ -278,9 +278,9 @@ void GoodMarket::execute_orders(
 					buy_up_to_order.money_to_spend / new_price
 				);
 
-				CountryInstance const* const country_nullable = buy_up_to_order.country_nullable;
-				if (country_nullable != nullptr) {
-					actual_bought_per_country.at(*country_nullable) += quantity_bought_per_order[i];
+				const std::optional<size_t> country_index_optional = buy_up_to_order.country_index_optional;
+				if (country_index_optional.has_value()) {
+					actual_bought_per_country.at_index(country_index_optional.value()) += quantity_bought_per_order[i];
 				}
 			}
 
@@ -335,13 +335,14 @@ void GoodMarket::execute_orders(
 
 				fixed_point_t quantity_sold_domestically;
 				fixed_point_t quantity_offered_as_export;
-				CountryInstance const* const country_nullable = market_sell_order.country_nullable;
-				if (country_nullable == nullptr) {
+				const std::optional<size_t> country_index_optional = market_sell_order.country_index_optional;
+				if (!country_index_optional.has_value()) {
 					quantity_sold_domestically = 0;
 					quantity_offered_as_export = quantity_offered;
 				} else {
-					const fixed_point_t total_bought_domestically = actual_bought_per_country.at(*country_nullable);
-					const fixed_point_t total_domestic_supply = supply_per_country.at(*country_nullable);
+					const size_t country_index = country_index_optional.value();
+					const fixed_point_t total_bought_domestically = actual_bought_per_country.at_index(country_index);
+					const fixed_point_t total_domestic_supply = supply_per_country.at_index(country_index);
 					quantity_sold_domestically = total_bought_domestically >= total_domestic_supply
 						? quantity_offered
 						: fixed_point_t::mul_div(
@@ -416,15 +417,16 @@ void GoodMarket::execute_buy_orders(
 				fixed_point_t::epsilon //we know from purchasing power that you can afford it.
 			);
 
-			fixed_point_t money_spent_on_imports;			
-			CountryInstance const* const country_nullable = buy_up_to_order.country_nullable;
-			if (country_nullable == nullptr) {
+			fixed_point_t money_spent_on_imports;
+			const std::optional<size_t> country_index_optional = buy_up_to_order.country_index_optional;
+			if (!country_index_optional.has_value()) {
 				//could be trade between native Americans and tribal Africa, so it's all imported
 				money_spent_on_imports = money_spent_total;
 			} else {
+				const size_t country_index = country_index_optional.value();
 				//must be > 0, since quantity_bought > 0
-				const fixed_point_t actual_bought_in_my_country = actual_bought_per_country.at(*country_nullable);
-				const fixed_point_t supply_in_my_country = supply_per_country.at(*country_nullable);
+				const fixed_point_t actual_bought_in_my_country = actual_bought_per_country.at_index(country_index);
+				const fixed_point_t supply_in_my_country = supply_per_country.at_index(country_index);
 
 				if (supply_in_my_country >= actual_bought_in_my_country) {
 					//no imports

src/openvic-simulation/economy/trading/GoodMarket.hpp

@@ -1,14 +1,14 @@
 #pragma once
 
 #include <mutex>
+#include <span>
 
 #include "openvic-simulation/economy/trading/BuyUpToOrder.hpp"
 #include "openvic-simulation/economy/trading/MarketSellOrder.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/ValueHistory.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
-#include "openvic-simulation/utility/ForwardableSpan.hpp"
 
 namespace OpenVic {
 	struct CountryInstance;
@@ -68,7 +68,7 @@ namespace OpenVic {
 		void execute_orders(
 			IndexedFlatMap<CountryInstance, fixed_point_t>& reusable_country_map_0,
 			IndexedFlatMap<CountryInstance, fixed_point_t>& reusable_country_map_1,
-			utility::forwardable_span<
+			std::span<
 				memory::vector<fixed_point_t>,
 				VECTORS_FOR_EXECUTE_ORDERS
 			> reusable_vectors

src/openvic-simulation/economy/trading/MarketSellOrder.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <cstddef>
+#include <optional>
+
 #include "openvic-simulation/economy/trading/SellResult.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 
@@ -16,15 +19,15 @@ namespace OpenVic {
 		const callback_t after_trade;
 
 	public:
-		CountryInstance const* const country_nullable;
+		const std::optional<size_t> country_index_optional;
 		const fixed_point_t quantity;
 
 		constexpr GoodMarketSellOrder(
-			CountryInstance const* const new_country_nullable,
+			const std::optional<size_t> new_country_index_optional,
 			const fixed_point_t new_quantity,
 			const actor_t new_actor,
 			const callback_t new_after_trade
-		) : country_nullable { new_country_nullable },
+		) : country_index_optional { new_country_index_optional },
 			quantity { new_quantity },
 			actor { new_actor },
 			after_trade { new_after_trade }
@@ -41,12 +44,12 @@ namespace OpenVic {
 
 		constexpr MarketSellOrder(
 			GoodDefinition const& new_good,
-			CountryInstance const* const new_country_nullable,
+			const std::optional<size_t> new_country_index_optional,
 			const fixed_point_t new_quantity,
 			const actor_t new_actor,
 			const callback_t new_after_trade
 		) : GoodMarketSellOrder {
-				new_country_nullable,
+				new_country_index_optional,
 				new_quantity,
 				new_actor,
 				new_after_trade

src/openvic-simulation/population/Pop.cpp

@@ -4,6 +4,7 @@
 #include <concepts> // IWYU pragma: keep for lambda
 #include <cstddef>
 #include <cstdint>
+#include <optional>
 #include <ranges>
 
 #include "openvic-simulation/country/CountryParty.hpp"
@@ -596,6 +597,10 @@ void Pop::pop_tick_without_cleanup(
 	OV_DO_FOR_ALL_NEED_CATEGORIES(ALLOCATE_FOR_NEEDS)
 	#undef ALLOCATE_FOR_NEEDS
 
+	const std::optional<size_t> country_index_optional = country_to_report_economy_nullable == nullptr
+		? std::nullopt
+		: std::optional<size_t>{country_to_report_economy_nullable->get_index()};
+
 	for (auto it = good_keys.begin(); it < good_keys.end(); it++) {
 		const ptrdiff_t i = it - good_keys.begin();
 		const fixed_point_t max_quantity_to_buy = max_quantity_to_buy_per_good[i];
@@ -609,7 +614,7 @@ void Pop::pop_tick_without_cleanup(
 
 		market_instance.place_buy_up_to_order({
 			good_definition,
-			country_to_report_economy_nullable,
+			country_index_optional,
 			max_quantity_to_buy,
 			money_to_spend,
 			this,
@@ -621,7 +626,7 @@ void Pop::pop_tick_without_cleanup(
 		market_instance.place_market_sell_order(
 			{
 				*artisanal_output_good,
-				country_to_report_economy_nullable,
+				country_index_optional,
 				artisanal_produce_left_to_sell,
 				this,
 				after_sell