Merge pull request #641 from OpenVicProject/expose_const_fields_market

Expose const fields directly in market types

Author: wvpm

src/openvic-simulation/country/CountryInstance.cpp

@@ -1885,15 +1885,15 @@ void CountryInstance::update_gamestate(const Date today, MapInstance& map_instan
 }
 
 void CountryInstance::after_buy(void* actor, BuyResult const& buy_result) {
-	const fixed_point_t quantity_bought = buy_result.get_quantity_bought();
+	const fixed_point_t quantity_bought = buy_result.quantity_bought;
 
 	if (quantity_bought <= 0) {
 		return;
 	}
 
 	CountryInstance& country = *static_cast<CountryInstance*>(actor);
-	good_data_t& good_data = country.goods_data.at_index(buy_result.get_good_definition().get_index());
-	const fixed_point_t money_spent = buy_result.get_money_spent_total();
+	good_data_t& good_data = country.goods_data.at_index(buy_result.good_definition.get_index());
+	const fixed_point_t money_spent = buy_result.money_spent_total;
 	country.cash_stockpile -= money_spent;
 	country.actual_national_stockpile_spending += money_spent;
 	good_data.stockpile_amount += quantity_bought;
@@ -1903,15 +1903,15 @@ void CountryInstance::after_buy(void* actor, BuyResult const& buy_result) {
 }
 
 void CountryInstance::after_sell(void* actor, SellResult const& sell_result, memory::vector<fixed_point_t>& reusable_vector) {
-	const fixed_point_t quantity_sold = sell_result.get_quantity_sold();
+	const fixed_point_t quantity_sold = sell_result.quantity_sold;
 
 	if (quantity_sold <= 0) {
 		return;
 	}
 
 	CountryInstance& country = *static_cast<CountryInstance*>(actor);
-	good_data_t& good_data = country.goods_data.at_index(sell_result.get_good_definition().get_index());
-	const fixed_point_t money_gained = sell_result.get_money_gained();
+	good_data_t& good_data = country.goods_data.at_index(sell_result.good_definition.get_index());
+	const fixed_point_t money_gained = sell_result.money_gained;
 	country.cash_stockpile += money_gained;
 	country.actual_national_stockpile_income += money_gained;
 	good_data.stockpile_amount -= quantity_sold;

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

@@ -159,7 +159,7 @@ void ResourceGatheringOperation::rgo_tick(memory::vector<fixed_point_t>& reusabl
 
 void ResourceGatheringOperation::after_sell(void* actor, SellResult const& sell_result, memory::vector<fixed_point_t>& reusable_vector) {
 	ResourceGatheringOperation& rgo = *static_cast<ResourceGatheringOperation*>(actor);
-	rgo.revenue_yesterday = sell_result.get_money_gained();
+	rgo.revenue_yesterday = sell_result.money_gained;
 	rgo.pay_employees(reusable_vector);
 }
 

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

@@ -6,12 +6,12 @@ namespace OpenVic {
 	struct GoodDefinition;
 
 	struct BuyResult {
-	private:
-		GoodDefinition const& PROPERTY(good_definition);
-		const fixed_point_t PROPERTY(quantity_bought);
-		const fixed_point_t PROPERTY(money_spent_total);
-		const fixed_point_t PROPERTY(money_spent_on_imports);
 	public:
+		GoodDefinition const& good_definition;
+		const fixed_point_t quantity_bought;
+		const fixed_point_t money_spent_total;
+		const fixed_point_t money_spent_on_imports;
+
 		constexpr BuyResult(
 			GoodDefinition const& new_good_definition,
 			const fixed_point_t new_quantity_bought,

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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "openvic-simulation/economy/trading/BuyResult.hpp"
-#include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
 	struct CountryInstance;
@@ -11,13 +10,14 @@ namespace OpenVic {
 		using callback_t = void(*)(const actor_t, BuyResult const&);
 
 	private:
-		CountryInstance const* const PROPERTY(country_nullable);
-		const fixed_point_t PROPERTY(max_quantity);
-		const fixed_point_t PROPERTY(money_to_spend);
 		const actor_t actor;
 		const callback_t after_trade;
 
 	public:
+		CountryInstance const* const country_nullable;
+		const fixed_point_t max_quantity;
+		const fixed_point_t money_to_spend;
+
 		constexpr GoodBuyUpToOrder(
 			CountryInstance const* const new_country_nullable,
 			const fixed_point_t new_max_quantity,
@@ -42,10 +42,9 @@ namespace OpenVic {
 	};
 
 	struct BuyUpToOrder : GoodBuyUpToOrder {
-	private:
-		GoodDefinition const& PROPERTY(good);
-
 	public:
+		GoodDefinition const& good;
+
 		constexpr BuyUpToOrder(
 			GoodDefinition const& new_good,
 			CountryInstance const* const new_country_nullable,

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

@@ -105,7 +105,7 @@ void GoodMarket::execute_orders(
 				max_affordable_price = affordable_price;
 			}
 
-			demand_sum += buy_up_to_order.get_max_quantity();
+			demand_sum += buy_up_to_order.max_quantity;
 			buy_up_to_order.call_after_trade(BuyResult::no_purchase_result(good_definition));
 		}
 
@@ -123,11 +123,11 @@ 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.get_country_nullable();
+			CountryInstance const* const country_nullable = market_sell_order.country_nullable;
 			if (country_nullable != nullptr) {
-				supply_per_country.at(*country_nullable) += market_sell_order.get_quantity();
+				supply_per_country.at(*country_nullable) += market_sell_order.quantity;
 			}
-			supply_sum += market_sell_order.get_quantity();
+			supply_sum += market_sell_order.quantity;
 		}
 		memory::vector<fixed_point_t>& quantity_bought_per_order = reusable_vectors[0];
 		memory::vector<fixed_point_t>& purchasing_power_per_order = reusable_vectors[1];
@@ -139,8 +139,8 @@ void GoodMarket::execute_orders(
 		fixed_point_t purchasing_power_sum = 0;
 		for (size_t i = 0; i < buy_up_to_orders.size(); i++) {
 			GoodBuyUpToOrder const& buy_up_to_order = buy_up_to_orders[i];
-			const fixed_point_t max_quantity = buy_up_to_order.get_max_quantity();
-			const fixed_point_t money_to_spend = buy_up_to_order.get_money_to_spend();
+			const fixed_point_t max_quantity = buy_up_to_order.max_quantity;
+			const fixed_point_t money_to_spend = buy_up_to_order.money_to_spend;
 
 			if (game_rules_manager.get_use_optimal_pricing()) {
 				const fixed_point_t affordable_price = buy_up_to_order.get_affordable_price();
@@ -185,13 +185,13 @@ void GoodMarket::execute_orders(
 				someone_bought_max_quantity = false;
 				for (size_t i = 0; i < buy_up_to_orders.size(); i++) {
 					GoodBuyUpToOrder const& buy_up_to_order = buy_up_to_orders[i];
-					const fixed_point_t max_quantity = buy_up_to_order.get_max_quantity();
+					const fixed_point_t max_quantity = buy_up_to_order.max_quantity;
 					fixed_point_t& distributed_supply = quantity_bought_per_order[i];
 					if (distributed_supply == max_quantity) {
 						continue;
 					}
 
-					CountryInstance const* const country_nullable = buy_up_to_order.get_country_nullable();
+					CountryInstance const* const country_nullable = buy_up_to_order.country_nullable;
 					if (country_nullable != nullptr) {
 						//subtract as it might be updated below
 						actual_bought_per_country.at(*country_nullable) -= distributed_supply;
@@ -247,14 +247,14 @@ void GoodMarket::execute_orders(
 
 					for (size_t i = 0; i < buy_up_to_orders.size(); i++) {
 						GoodBuyUpToOrder const& buy_up_to_order = buy_up_to_orders[i];
-						if (quantity_bought_per_order[i] == buy_up_to_order.get_max_quantity()) {
+						if (quantity_bought_per_order[i] == buy_up_to_order.max_quantity) {
 							continue;
 						}
 
-						if (buy_up_to_order.get_money_to_spend() >= new_price * buy_up_to_order.get_max_quantity()) {
-							quantity_bought_per_order[i] = buy_up_to_order.get_max_quantity();
-							remaining_supply -= buy_up_to_order.get_max_quantity();
-							money_left_to_spend_sum -= buy_up_to_order.get_money_to_spend();
+						if (buy_up_to_order.money_to_spend >= new_price * buy_up_to_order.max_quantity) {
+							quantity_bought_per_order[i] = buy_up_to_order.max_quantity;
+							remaining_supply -= buy_up_to_order.max_quantity;
+							money_left_to_spend_sum -= buy_up_to_order.money_to_spend;
 						}
 					}
 				}
@@ -274,11 +274,11 @@ void GoodMarket::execute_orders(
 				const fixed_point_t quantity_bought
 					= quantity_bought_per_order[i]
 					= std::min(
-					buy_up_to_order.get_max_quantity(),
-					buy_up_to_order.get_money_to_spend() / new_price
+					buy_up_to_order.max_quantity,
+					buy_up_to_order.money_to_spend / new_price
 				);
 
-				CountryInstance const* const country_nullable = buy_up_to_order.get_country_nullable();
+				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];
 				}
@@ -300,7 +300,7 @@ void GoodMarket::execute_orders(
 		if (quantity_traded_yesterday == supply_sum) {
 			//everything was sold
 			for (GoodMarketSellOrder const& market_sell_order : market_sell_orders) {
-				const fixed_point_t quantity_sold = market_sell_order.get_quantity();
+				const fixed_point_t quantity_sold = market_sell_order.quantity;
 				fixed_point_t money_gained;
 				if (quantity_sold == 0) {
 					money_gained = 0;
@@ -331,21 +331,21 @@ void GoodMarket::execute_orders(
 			const fixed_point_t total_quantity_traded_as_export = quantity_traded_yesterday - total_quantity_traded_domestically;
 			const fixed_point_t total_quantity_offered_as_export = supply_sum - total_quantity_traded_domestically;
 			for (GoodMarketSellOrder const& market_sell_order : market_sell_orders) {
-				const fixed_point_t quantity_offered = market_sell_order.get_quantity();
+				const fixed_point_t quantity_offered = market_sell_order.quantity;
 
 				fixed_point_t quantity_sold_domestically;
 				fixed_point_t quantity_offered_as_export;
-				CountryInstance const* const country_nullable = market_sell_order.get_country_nullable();
+				CountryInstance const* const country_nullable = market_sell_order.country_nullable;
 				if (country_nullable == nullptr) {
 					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);
 					quantity_sold_domestically = total_bought_domestically >= total_domestic_supply
-						? market_sell_order.get_quantity()
+						? quantity_offered
 						: fixed_point_t::mul_div(
-							market_sell_order.get_quantity(),
+							quantity_offered,
 							total_bought_domestically,
 							total_domestic_supply //> 0 as we're selling
 						);
@@ -417,7 +417,7 @@ void GoodMarket::execute_buy_orders(
 			);
 
 			fixed_point_t money_spent_on_imports;			
-			CountryInstance const* const country_nullable = buy_up_to_order.get_country_nullable();
+			CountryInstance const* const country_nullable = buy_up_to_order.country_nullable;
 			if (country_nullable == nullptr) {
 				//could be trade between native Americans and tribal Africa, so it's all imported
 				money_spent_on_imports = money_spent_total;

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

@@ -5,6 +5,7 @@
 #include "openvic-simulation/economy/GoodInstance.hpp"
 #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/utility/Containers.hpp"
 #include "openvic-simulation/utility/ThreadPool.hpp"
 #include "openvic-simulation/utility/Typedefs.hpp"
@@ -34,11 +35,11 @@ GoodInstance const& MarketInstance::get_good_instance(GoodDefinition const& good
 }
 
 void MarketInstance::place_buy_up_to_order(BuyUpToOrder&& buy_up_to_order) {
-	GoodDefinition const& good = buy_up_to_order.get_good();
-	if (OV_unlikely(buy_up_to_order.get_max_quantity() <= 0)) {
+	GoodDefinition const& good = buy_up_to_order.good;
+	if (OV_unlikely(buy_up_to_order.max_quantity <= 0)) {
 		spdlog::error_s(
 			"Received BuyUpToOrder for {} with max quantity {}",
-			good, buy_up_to_order.get_max_quantity()
+			good, buy_up_to_order.max_quantity
 		);
 		buy_up_to_order.call_after_trade(BuyResult::no_purchase_result(good));
 		return;
@@ -49,22 +50,24 @@ void MarketInstance::place_buy_up_to_order(BuyUpToOrder&& buy_up_to_order) {
 }
 
 void MarketInstance::place_market_sell_order(MarketSellOrder&& market_sell_order, memory::vector<fixed_point_t>& reusable_vector) {
-	GoodDefinition const& good = market_sell_order.get_good();
-	if (OV_unlikely(market_sell_order.get_quantity() <= 0)) {
+	GoodDefinition const& good = market_sell_order.good;
+	const fixed_point_t quantity = market_sell_order.quantity;
+
+	if (OV_unlikely(quantity <= 0)) {
 		spdlog::error_s(
 			"Received MarketSellOrder for {} with quantity {}",
-			good, market_sell_order.get_quantity()
+			good, quantity
 		);
-		market_sell_order.call_after_trade(SellResult::no_sales_result(market_sell_order.get_good()), reusable_vector);
+		market_sell_order.call_after_trade(SellResult::no_sales_result(good), reusable_vector);
 		return;
 	}
 
 	if (good.get_is_money()) {
 		market_sell_order.call_after_trade(
 			{
-				market_sell_order.get_good(),
-				market_sell_order.get_quantity(),
-				market_sell_order.get_quantity() * country_defines.get_gold_to_worker_pay_rate() * good.get_base_price()
+				market_sell_order.good,
+				quantity,
+				quantity * country_defines.get_gold_to_worker_pay_rate() * good.get_base_price()
 			},
 			reusable_vector
 		);

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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "openvic-simulation/economy/trading/SellResult.hpp"
-#include "openvic-simulation/utility/Getters.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 
 namespace OpenVic {
@@ -13,12 +12,13 @@ namespace OpenVic {
 		using callback_t = void (*)(actor_t, SellResult const&, memory::vector<fixed_point_t>&);
 
 	private:
-		CountryInstance const* const PROPERTY(country_nullable);
-		const fixed_point_t PROPERTY(quantity);
 		const actor_t actor;
 		const callback_t after_trade;
 
 	public:
+		CountryInstance const* const country_nullable;
+		const fixed_point_t quantity;
+
 		constexpr GoodMarketSellOrder(
 			CountryInstance const* const new_country_nullable,
 			const fixed_point_t new_quantity,
@@ -36,10 +36,9 @@ namespace OpenVic {
 	};
 
 	struct MarketSellOrder : GoodMarketSellOrder {
-	private:
-		GoodDefinition const& PROPERTY(good);
-
 	public:
+		GoodDefinition const& good;
+
 		constexpr MarketSellOrder(
 			GoodDefinition const& new_good,
 			CountryInstance const* const new_country_nullable,

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

@@ -6,11 +6,11 @@ namespace OpenVic {
 	struct GoodDefinition;
 
 	struct SellResult {
-	private:
-		GoodDefinition const& PROPERTY(good_definition);
-		const fixed_point_t PROPERTY(quantity_sold);
-		const fixed_point_t PROPERTY(money_gained);
 	public:
+		GoodDefinition const& good_definition;
+		const fixed_point_t quantity_sold;
+		const fixed_point_t money_gained;
+
 		constexpr SellResult(
 			GoodDefinition const& new_good_definition,
 			const fixed_point_t new_quantity_sold,

src/openvic-simulation/population/Pop.cpp

@@ -633,7 +633,7 @@ void Pop::pop_tick_without_cleanup(
 }
 
 void Pop::after_buy(void* actor, BuyResult const& buy_result) {
-	const fixed_point_t quantity_bought = buy_result.get_quantity_bought();
+	const fixed_point_t quantity_bought = buy_result.quantity_bought;
 
 	if (quantity_bought == 0) {
 		return;
@@ -643,14 +643,14 @@ void Pop::after_buy(void* actor, BuyResult const& buy_result) {
 	ProvinceInstance& location_never_null = *pop.get_location();
 	CountryInstance* const country_to_report_economy_nullable = location_never_null.get_country_to_report_economy();
 
-	fixed_point_t money_spent = buy_result.get_money_spent_total();
-	pop.yesterdays_import_value += buy_result.get_money_spent_on_imports();
+	fixed_point_t money_spent = buy_result.money_spent_total;
+	pop.yesterdays_import_value += buy_result.money_spent_on_imports;
 	if (country_to_report_economy_nullable != nullptr) {
-		const fixed_point_t tariff = country_to_report_economy_nullable->apply_tariff(buy_result.get_money_spent_on_imports());
+		const fixed_point_t tariff = country_to_report_economy_nullable->apply_tariff(buy_result.money_spent_on_imports);
 		money_spent += tariff;
 	}
 
-	GoodDefinition const& good_definition = buy_result.get_good_definition();
+	GoodDefinition const& good_definition = buy_result.good_definition;
 	fixed_point_t quantity_left_to_consume = quantity_bought;
 	if (pop.artisanal_producer_optional.has_value()) {
 		if (quantity_left_to_consume <= 0) {
@@ -705,8 +705,8 @@ void Pop::after_buy(void* actor, BuyResult const& buy_result) {
 }
 
 void Pop::after_sell(void* actor, SellResult const& sell_result, memory::vector<fixed_point_t>& reusable_vector) {
-	if (sell_result.get_money_gained() > 0) {
-		static_cast<Pop*>(actor)->add_artisanal_revenue(sell_result.get_money_gained());
+	if (sell_result.money_gained > 0) {
+		static_cast<Pop*>(actor)->add_artisanal_revenue(sell_result.money_gained);
 	}
 }