Refactor politcs and leftovers to use reference_wrapper

Author: wvpm

src/headless/main.cpp

@@ -260,32 +260,31 @@ static bool run_headless(fs::path const& root, memory::vector<memory::string>& m
 	SPDLOG_INFO("===== Ranking system test... =====");
 	if (game_manager.get_instance_manager()) {
 		const auto print_ranking_list = [ //
-		](std::string_view title, OpenVic::forwardable_span<CountryInstance* const> countries) -> void {
+		](std::string_view title, OpenVic::forwardable_span<const std::reference_wrapper<CountryInstance>> countries) -> void {
 			memory::string countries_str;
-			for (CountryInstance* country : countries) {
+			for (CountryInstance& country : countries) {
 				countries_str += fmt::format(
 					"\n\t{} - Total #{} ({}), Prestige #{} ({}), Industry #{} ({}), Military #{} ({})", //
-					*country, //
-					country->get_total_rank(), country->total_score.get_untracked().to_string(1), //
-					country->get_prestige_rank(), country->get_prestige_untracked().to_string(1),
-					country->get_industrial_rank(), country->get_industrial_power_untracked().to_string(1),
-					country->get_military_rank(), country->military_power.get_untracked().to_string(1)
+					country, //
+					country.get_total_rank(), country.total_score.get_untracked().to_string(1), //
+					country.get_prestige_rank(), country.get_prestige_untracked().to_string(1),
+					country.get_industrial_rank(), country.get_industrial_power_untracked().to_string(1),
+					country.get_military_rank(), country.military_power.get_untracked().to_string(1)
 				);
 			}
 			SPDLOG_INFO("{}:{}", title, countries_str);
 		};
 
-		CountryInstanceManager const& country_instance_manager =
-			game_manager.get_instance_manager()->get_country_instance_manager();
+		CountryInstanceManager const& country_instance_manager = game_manager.get_instance_manager()->get_country_instance_manager();
 
-		OpenVic::forwardable_span<CountryInstance* const> great_powers = country_instance_manager.get_great_powers();
+		OpenVic::forwardable_span<const std::reference_wrapper<CountryInstance>> great_powers = country_instance_manager.get_great_powers();
 		print_ranking_list("Great Powers", great_powers);
 		print_ranking_list("Secondary Powers", country_instance_manager.get_secondary_powers());
 		print_ranking_list("All countries", country_instance_manager.get_total_ranking());
 
 		SPDLOG_INFO("===== RGO test... =====");
 		for (size_t i = 0; i < std::min<size_t>(3, great_powers.size()); ++i) {
-			CountryInstance const& great_power = *great_powers[i];
+			CountryInstance const& great_power = great_powers[i];
 			ProvinceInstance const* const capital_province = great_power.get_capital();
 			if (capital_province == nullptr) {
 				spdlog::warn_s("{} has no capital ProvinceInstance set.", great_power);

src/openvic-simulation/country/CountryDefinition.cpp

@@ -159,7 +159,7 @@ node_callback_t CountryDefinitionManager::load_country_party(
 
 						return politics_manager.get_issue_manager().expect_party_policy_identifier(
 							[&party_policy_group, &policy](PartyPolicy const& party_policy) -> bool {
-								if (&party_policy.issue_group == &party_policy_group) {
+								if (&party_policy.group == &party_policy_group) {
 									policy = &party_policy;
 									return true;
 								}
@@ -168,7 +168,7 @@ node_callback_t CountryDefinitionManager::load_country_party(
 								spdlog::warn_s(
 									"Invalid party policy \"{}\", group is \"{}\" when \"{}\" was expected.",
 									party_policy,
-									party_policy.issue_group,
+									party_policy.group,
 									party_policy_group
 								);
 								return true;

src/openvic-simulation/country/CountryInstance.cpp

@@ -639,7 +639,7 @@ bool CountryInstance::set_ruling_party(CountryParty const& new_ruling_party) {
 }
 
 bool CountryInstance::add_reform(Reform const& new_reform) {
-	ReformGroup const& reform_group = new_reform.get_reform_group();
+	ReformGroup const& reform_group = new_reform.group;
 	Reform const*& reform = reforms.at(reform_group);
 
 	if (reform != &new_reform) {
@@ -1211,7 +1211,7 @@ bool CountryInstance::can_research_tech(Technology const& technology, const Date
 
 	const Technology::area_index_t index_in_area = technology.index_in_area;
 
-	return index_in_area == 0 || is_technology_unlocked(*technology.area.get_technologies()[index_in_area - 1]);
+	return index_in_area == 0 || is_technology_unlocked(technology.area.get_technologies()[index_in_area - 1]);
 }
 
 void CountryInstance::start_research(Technology const& technology, const Date today) {

src/openvic-simulation/country/CountryInstanceManager.cpp

@@ -52,7 +52,7 @@ void CountryInstanceManager::update_rankings(const Date today) {
 
 	for (CountryInstance& country : get_country_instances()) {
 		if (country.exists()) {
-			total_ranking.push_back(&country);
+			total_ranking.emplace_back(country);
 		}
 	}
 
@@ -62,37 +62,37 @@ void CountryInstanceManager::update_rankings(const Date today) {
 
 	std::stable_sort(
 		total_ranking.begin(), total_ranking.end(),
-		[](CountryInstance* a, CountryInstance* b) -> bool {
-			const bool a_civilised = a->is_civilised();
-			const bool b_civilised = b->is_civilised();
-			return a_civilised != b_civilised ? a_civilised : a->total_score.get_untracked() > b->total_score.get_untracked();
+		[](CountryInstance& a, CountryInstance& b) -> bool {
+			const bool a_civilised = a.is_civilised();
+			const bool b_civilised = b.is_civilised();
+			return a_civilised != b_civilised ? a_civilised : a.total_score.get_untracked() > b.total_score.get_untracked();
 		}
 	);
 	std::stable_sort(
 		prestige_ranking.begin(), prestige_ranking.end(),
-		[](CountryInstance const* a, CountryInstance const* b) -> bool {
-			return a->get_prestige_untracked() > b->get_prestige_untracked();
+		[](CountryInstance const& a, CountryInstance const& b) -> bool {
+			return a.get_prestige_untracked() > b.get_prestige_untracked();
 		}
 	);
 	std::stable_sort(
 		industrial_power_ranking.begin(), industrial_power_ranking.end(),
-		[](CountryInstance const* a, CountryInstance const* b) -> bool {
-			return a->get_industrial_power_untracked() > b->get_industrial_power_untracked();
+		[](CountryInstance const& a, CountryInstance const& b) -> bool {
+			return a.get_industrial_power_untracked() > b.get_industrial_power_untracked();
 		}
 	);
 	std::stable_sort(
 		military_power_ranking.begin(), military_power_ranking.end(),
-		[](CountryInstance* a, CountryInstance* b) -> bool {
-			return a->military_power.get_untracked() > b->military_power.get_untracked();
+		[](CountryInstance& a, CountryInstance& b) -> bool {
+			return a.military_power.get_untracked() > b.military_power.get_untracked();
 		}
 	);
 
 	for (size_t index = 0; index < total_ranking.size(); ++index) {
 		const size_t rank = index + 1;
-		total_ranking[index]->total_rank = rank;
-		prestige_ranking[index]->prestige_rank = rank;
-		industrial_power_ranking[index]->industrial_rank = rank;
-		military_power_ranking[index]->military_rank = rank;
+		total_ranking[index].get().total_rank = rank;
+		prestige_ranking[index].get().prestige_rank = rank;
+		industrial_power_ranking[index].get().industrial_rank = rank;
+		military_power_ranking[index].get().military_rank = rank;
 	}
 
 	const size_t max_great_power_rank = country_defines.get_great_power_rank();
@@ -103,12 +103,12 @@ void CountryInstanceManager::update_rankings(const Date today) {
 	// Demote great powers who have been below the max great power rank for longer than the demotion grace period and
 	// remove them from the list. We don't just demote them all and clear the list as when rebuilding we'd need to look
 	// ahead for countries below the max great power rank but still within the demotion grace period.
-	std::erase_if(great_powers, [max_great_power_rank, today](CountryInstance* great_power) -> bool {
-		if (OV_likely(great_power->get_country_status() == COUNTRY_STATUS_GREAT_POWER)) {
+	std::erase_if(great_powers, [max_great_power_rank, today](CountryInstance& great_power) -> bool {
+		if (OV_likely(great_power.get_country_status() == COUNTRY_STATUS_GREAT_POWER)) {
 			if (OV_unlikely(
-				great_power->get_total_rank() > max_great_power_rank && great_power->get_lose_great_power_date() < today
+				great_power.get_total_rank() > max_great_power_rank && great_power.get_lose_great_power_date() < today
 			)) {
-				great_power->country_status = COUNTRY_STATUS_CIVILISED;
+				great_power.country_status = COUNTRY_STATUS_CIVILISED;
 				return true;
 			} else {
 				return false;
@@ -119,9 +119,9 @@ void CountryInstanceManager::update_rankings(const Date today) {
 
 	// Demote all secondary powers and clear the list. We will rebuilt the whole list from scratch, so there's no need to
 	// keep countries which are still above the max secondary power rank (they might become great powers instead anyway).
-	for (CountryInstance* secondary_power : secondary_powers) {
-		if (secondary_power->country_status == COUNTRY_STATUS_SECONDARY_POWER) {
-			secondary_power->country_status = COUNTRY_STATUS_CIVILISED;
+	for (CountryInstance& secondary_power : secondary_powers) {
+		if (secondary_power.country_status == COUNTRY_STATUS_SECONDARY_POWER) {
+			secondary_power.country_status = COUNTRY_STATUS_CIVILISED;
 		}
 	}
 	secondary_powers.clear();
@@ -133,41 +133,41 @@ void CountryInstanceManager::update_rankings(const Date today) {
 	const size_t max_power_index = std::clamp(max_secondary_power_rank, max_great_power_rank, total_ranking.size());
 
 	for (size_t index = 0; index < max_power_index; index++) {
-		CountryInstance* country = total_ranking[index];
+		CountryInstance& country = total_ranking[index];
 
-		if (!country->is_civilised()) {
+		if (!country.is_civilised()) {
 			// All further countries are civilised and so ineligible for great or secondary power status.
 			break;
 		}
 
-		if (country->is_great_power()) {
+		if (country.is_great_power()) {
 			// The country already has great power status and is in the great powers list.
 			continue;
 		}
 
-		if (great_powers.size() < max_great_power_rank && country->get_total_rank() <= max_great_power_rank) {
+		if (great_powers.size() < max_great_power_rank && country.get_total_rank() <= max_great_power_rank) {
 			// The country is eligible for great power status and there are still slots available,
 			// so it is promoted and added to the list.
-			country->country_status = COUNTRY_STATUS_GREAT_POWER;
+			country.country_status = COUNTRY_STATUS_GREAT_POWER;
 			great_powers.push_back(country);
-		} else if (country->get_total_rank() <= max_secondary_power_rank) {
+		} else if (country.get_total_rank() <= max_secondary_power_rank) {
 			// The country is eligible for secondary power status and so is promoted and added to the list.
-			country->country_status = COUNTRY_STATUS_SECONDARY_POWER;
-			secondary_powers.push_back(country);
+			country.country_status = COUNTRY_STATUS_SECONDARY_POWER;
+			secondary_powers.emplace_back(country);
 		}
 	}
 
 	// Sort the great powers list by total rank, as pre-existing great powers may have changed rank order and new great
 	// powers will have been added to the end of the list regardless of rank.
-	std::stable_sort(great_powers.begin(), great_powers.end(), [](CountryInstance const* a, CountryInstance const* b) -> bool {
-		return a->get_total_rank() < b->get_total_rank();
+	std::stable_sort(great_powers.begin(), great_powers.end(), [](CountryInstance const& a, CountryInstance const& b) -> bool {
+		return a.get_total_rank() < b.get_total_rank();
 	});
 
 	// Update the lose great power date for all great powers which are above the max great power rank.
 	const Date new_lose_great_power_date = today + lose_great_power_grace_days;
-	for (CountryInstance* great_power : great_powers) {
-		if (great_power->get_total_rank() <= max_great_power_rank) {
-			great_power->lose_great_power_date = new_lose_great_power_date;
+	for (CountryInstance& great_power : great_powers) {
+		if (great_power.get_total_rank() <= max_great_power_rank) {
+			great_power.lose_great_power_date = new_lose_great_power_date;
 		}
 	}
 }

src/openvic-simulation/country/CountryInstanceManager.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <functional>
 #include <string_view>
 
 #include "openvic-simulation/country/CountryInstance.hpp"
@@ -32,13 +33,13 @@ namespace OpenVic {
 
 		OV_IFLATMAP_PROPERTY(CountryDefinition, CountryInstance, country_instance_by_definition);
 
-		memory::vector<CountryInstance*> SPAN_PROPERTY(great_powers);
-		memory::vector<CountryInstance*> SPAN_PROPERTY(secondary_powers);
+		memory::vector<std::reference_wrapper<CountryInstance>> SPAN_PROPERTY(great_powers);
+		memory::vector<std::reference_wrapper<CountryInstance>> SPAN_PROPERTY(secondary_powers);
 
-		memory::vector<CountryInstance*> SPAN_PROPERTY(total_ranking);
-		memory::vector<CountryInstance*> SPAN_PROPERTY(prestige_ranking);
-		memory::vector<CountryInstance*> SPAN_PROPERTY(industrial_power_ranking);
-		memory::vector<CountryInstance*> SPAN_PROPERTY(military_power_ranking);
+		memory::vector<std::reference_wrapper<CountryInstance>> SPAN_PROPERTY(total_ranking);
+		memory::vector<std::reference_wrapper<CountryInstance>> SPAN_PROPERTY(prestige_ranking);
+		memory::vector<std::reference_wrapper<CountryInstance>> SPAN_PROPERTY(industrial_power_ranking);
+		memory::vector<std::reference_wrapper<CountryInstance>> SPAN_PROPERTY(military_power_ranking);
 
 		void update_rankings(const Date today);
 

src/openvic-simulation/economy/BuildingType.cpp

@@ -135,7 +135,7 @@ bool BuildingTypeManager::add_building_type(
 	if (ret) {
 		building_type_types.emplace(building_type_args.type);
 		if (province_building_index.has_value()) {
-			province_building_types.emplace_back(&building_types.back());
+			province_building_types.emplace_back(building_types.back());
 		}
 	}
 

src/openvic-simulation/economy/BuildingType.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <functional>
 #include <optional>
 
 #include "openvic-simulation/modifier/Modifier.hpp"
@@ -112,7 +113,7 @@ namespace OpenVic {
 	private:
 		IdentifierRegistry<BuildingType> IDENTIFIER_REGISTRY(building_type);
 		string_set_t PROPERTY(building_type_types);
-		memory::vector<BuildingType const*> SPAN_PROPERTY(province_building_types);
+		memory::vector<std::reference_wrapper<const BuildingType>> SPAN_PROPERTY(province_building_types);
 		BuildingType const* PROPERTY(infrastructure_building_type);
 		BuildingType const* PROPERTY(port_building_type);
 

src/openvic-simulation/economy/GoodDefinition.cpp

@@ -66,7 +66,7 @@ bool GoodDefinitionManager::add_good_definition(
 		identifier, colour, GoodDefinition::index_t { get_good_definition_count() }, category, base_price, is_available_from_start,
 		is_tradeable, is_money, has_overseas_penalty
 	)) {
-		category.good_definitions.push_back(&get_back_good_definition());
+		category.good_definitions.emplace_back(get_back_good_definition());
 		return true;
 	} else {
 		return false;

src/openvic-simulation/economy/GoodDefinition.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <functional>
+
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/HasIndex.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
@@ -14,7 +16,7 @@ namespace OpenVic {
 		friend struct GoodDefinitionManager;
 
 	private:
-		memory::vector<GoodDefinition const*> SPAN_PROPERTY(good_definitions);
+		memory::vector<std::reference_wrapper<const GoodDefinition>> SPAN_PROPERTY(good_definitions);
 	public:
 		GoodCategory(std::string_view new_identifier);
 		GoodCategory(GoodCategory&&) = default;

src/openvic-simulation/history/CountryHistory.cpp

@@ -96,13 +96,14 @@ bool CountryHistoryMap::_load_history_entry(
 			std::string_view key,
 			ast::NodeCPtr value
 		) -> bool {
-			ReformGroup const* reform_group = issue_manager.get_reform_group_by_identifier(key);
-			if (reform_group != nullptr) {
-				return issue_manager.expect_reform_identifier([&entry, reform_group](Reform const& reform) -> bool {
-					if (&reform.get_reform_group() != reform_group) {
+			ReformGroup const* reform_group_ptr = issue_manager.get_reform_group_by_identifier(key);
+			if (reform_group_ptr != nullptr) {
+				ReformGroup const& reform_group = *reform_group_ptr;
+				return issue_manager.expect_reform_identifier([&entry, &reform_group](Reform const& reform) -> bool {
+					if (reform.group != reform_group) {
 						spdlog::warn_s(
 							"Listing {} as belonging to the reform group {} when it actually belongs to {} in history of {}",
-							reform, *reform_group, reform.get_reform_group(), entry.country
+							reform, reform_group, reform.group, entry.country
 						);
 					}
 					return set_callback_pointer(entry.reforms)(reform);