Split identifier registry

src/openvic-simulation/InstanceManager.cpp

@@ -4,6 +4,7 @@
 #include "openvic-simulation/console/ConsoleInstance.hpp"
 #include "openvic-simulation/core/stl/containers/TypedSpan.hpp"
 #include "openvic-simulation/misc/GameAction.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry_Search.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 #include "openvic-simulation/utility/ThreadDeps.hpp"
 
@@ -67,8 +68,12 @@ InstanceManager::InstanceManager(
 		},
 		new_definition_manager.get_pop_manager().get_pop_types(),
 		new_definition_manager.get_politics_manager().get_issue_manager().get_reform_groups(),
-		new_definition_manager.get_military_manager().get_unit_type_manager().get_regiment_types(),
-		new_definition_manager.get_military_manager().get_unit_type_manager().get_ship_types(),
+		get_values(
+			new_definition_manager.get_military_manager().get_unit_type_manager().get_regiment_types()
+		),
+		get_values(
+			new_definition_manager.get_military_manager().get_unit_type_manager().get_ship_types()
+		),
 		new_definition_manager.get_pop_manager().get_stratas(),
 		new_definition_manager.get_research_manager().get_technology_manager().get_technologies(),
 		new_definition_manager.get_military_manager().get_unit_type_manager()
@@ -115,7 +120,9 @@ InstanceManager::InstanceManager(
 		good_instance_manager,
 		new_definition_manager.get_define_manager().get_pops_defines(),
 		new_definition_manager.get_pop_manager().get_pop_types(),
-		new_definition_manager.get_military_manager().get_unit_type_manager().get_regiment_types(),
+		get_values(
+			new_definition_manager.get_military_manager().get_unit_type_manager().get_regiment_types()
+		),
 		thread_pool
 	},
 	unit_instance_manager {
@@ -244,7 +251,7 @@ bool InstanceManager::setup() {
 			definition_manager.get_define_manager().get_pops_defines(),
 			definition_manager.get_economy_manager().get_production_type_manager(),
 			definition_manager.get_modifier_manager().get_static_modifier_cache(),
-			country_index_t(definition_manager.get_country_definition_manager().get_country_definition_count()),
+			country_index_t(definition_manager.get_country_definition_manager().get_country_definitions().size()),
 			good_index_t(definition_manager.get_economy_manager().get_good_definition_manager().get_good_definition_count()),
 			strata_index_t(definition_manager.get_pop_manager().get_strata_count())
 		},

src/openvic-simulation/console/ConsoleInstance.cpp

@@ -22,6 +22,7 @@
 #include "openvic-simulation/research/Technology.hpp"
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/Date.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry_Search.hpp"
 
 using namespace OpenVic;
 using namespace std::string_view_literals;
@@ -222,15 +223,14 @@ CountryInstance* ConsoleInstance::validate_country_tag(std::string_view value_st
 		return nullptr;
 	}
 
-	CountryDefinition const* const country_definition_ptr = instance_manager
-		.definition_manager.get_country_definition_manager()
-		.get_country_definition_by_identifier(value_string);
+	auto const& country_definitions = instance_manager.definition_manager.get_country_definition_manager().get_country_definitions();
+	const auto it = find(country_definitions, value_string);
 
-	if (country_definition_ptr == nullptr) {
+	if (it == country_definitions.end()) {
 		write_error("Unknown country");
 		return nullptr;
 	}
-	return &instance_manager.get_country_instance_manager().get_country_instance_by_index(country_definition_ptr->index);
+	return &instance_manager.get_country_instance_manager().get_country_instance_by_index((*it).index);
 }
 
 Event const* ConsoleInstance::validate_event_id(std::string_view value_string) {

src/openvic-simulation/country/CountryDefinition.hpp

@@ -11,8 +11,8 @@
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/HasIndex.hpp"
-#include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 
 namespace OpenVic {
@@ -23,7 +23,6 @@ namespace OpenVic {
 	/* Generic information about a TAG */
 	struct CountryDefinition : HasIdentifierAndColour, HasIndex<CountryDefinition, country_index_t> {
 		friend struct CountryDefinitionManager;
-		IdentifierRegistry<CountryParty> IDENTIFIER_REGISTRY_CUSTOM_PLURAL(party, parties);
 
 	private:
 		memory::FixedVector< // for each ship type
@@ -41,6 +40,7 @@ namespace OpenVic {
 
 	public:
 		const bool is_dynamic_tag;
+		const OwningRegistry<CountryParty, std::size_t> parties;
 		GraphicalCultureType const& graphical_culture;
 
 		OV_ALWAYS_INLINE bool is_rebel_country() const {

src/openvic-simulation/country/CountryDefinitionManager.cpp

@@ -14,6 +14,8 @@
 #include "openvic-simulation/types/ConstructorTags.hpp"
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry_Modify.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry_NodeTools.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
@@ -44,9 +46,10 @@ bool CountryDefinitionManager::add_country(
 
 	static constexpr colour_t default_colour = colour_t::fill_as(colour_t::max_value);
 
-	return country_definitions.emplace_item(
+	return try_emplace_item(
+		country_definitions,
 		identifier,
-		identifier, colour, country_index_t(country_definitions.size()), *graphical_culture,
+		identifier, colour, country_definitions.size(), *graphical_culture,
 		std::move(parties), std::move(ship_names), is_dynamic_tag, std::move(alternative_colours),
 		/* Default to country colour for the chest and grey for the others. Update later if necessary. */
 		colour, default_colour, default_colour
@@ -63,8 +66,8 @@ bool CountryDefinitionManager::load_countries(
 
 	const bool ret = expect_dictionary_and_length(
 		[this](const std::size_t country_count) -> std::size_t {
-			reserve_country_definitions(country_count);
-			return get_country_definitions_capacity();
+			country_definitions.clear_and_reserve(country_index_t(country_count));
+			return country_count;
 		},
 		[this, &definition_manager, &is_dynamic, &dataloader](std::string_view key, ovdl::v2script::ast::Node const* value) -> bool {
 			if (key == "dynamic_tags") {
@@ -100,7 +103,7 @@ bool CountryDefinitionManager::load_countries(
 			return false;
 		}
 	)(root);
-	lock_country_definitions();
+	lock_registry(country_definitions);
 	return ret;
 }
 
@@ -109,16 +112,13 @@ bool CountryDefinitionManager::load_country_colours(ovdl::v2script::ast::Node co
 		NodeTools::default_length_callback,
 		NodeTools::expect_assign(
 			[this](std::string_view identifier, ovdl::v2script::ast::Node const* node) -> bool {
-				//temporary fix till OwningRegistry replaces this entirely
-				CountryDefinition* country_definition_ptr = const_cast<CountryDefinition*>(
-					get_country_definition_by_identifier(identifier)
-				);
-				if (country_definition_ptr == nullptr) {
+				const auto it = find(country_definitions, identifier);
+				if (it == country_definitions.end()) {
 					spdlog::warn_s("country_colors.txt references country tag {} which is not defined!", identifier);
 					return true;
 				}
 
-				CountryDefinition& country = *country_definition_ptr;
+				CountryDefinition& country = *it;
 				return expect_dictionary_keys(
 					"color1", ONE_EXACTLY, expect_colour(assign_variable_callback(country.primary_unit_colour)),
 					"color2", ONE_EXACTLY, expect_colour(assign_variable_callback(country.secondary_unit_colour)),
@@ -217,9 +217,9 @@ bool CountryDefinitionManager::load_country_data_file(
 ) {
 	colour_t colour;
 	GraphicalCultureType const* graphical_culture;
-	auto const& unit_type_manager = definition_manager.get_military_manager().get_unit_type_manager();
+	auto const& ship_types = definition_manager.get_military_manager().get_unit_type_manager().get_ship_types();
 	decltype(CountryDefinition::ship_names) ship_names {
-		ship_type_index_t(unit_type_manager.get_ship_type_count()),
+		ship_types.size(),
 		[](const ship_type_index_t) { return create_empty; }
 	};
 	decltype(CountryDefinition::alternative_colours) alternative_colours;
@@ -238,10 +238,11 @@ bool CountryDefinitionManager::load_country_data_file(
 				assign_variable_callback_pointer(graphical_culture)
 			),
 		"party", ZERO_OR_MORE, load_country_party(definition_manager.get_politics_manager(), party_dtos),
-		"unit_names", ZERO_OR_ONE, unit_type_manager.expect_ship_type_dictionary(
-				[&ship_names](ShipType const& ship_type, ovdl::v2script::ast::Node const* value) -> bool {
+		"unit_names", ZERO_OR_ONE, expect_item_dictionary(
+				ship_types,
+				[&ship_names](const ship_type_index_t ship_type_index, ovdl::v2script::ast::Node const* value) -> bool {
 					return name_list_callback(
-						[&ship_names, ship_type_index = ship_type.index](memory::FixedVector<memory::string>&& names) -> bool {
+						[&ship_names, ship_type_index](memory::FixedVector<memory::string>&& names) -> bool {
 							ship_names[ship_type_index] = std::move(names);
 							return true;
 						}
@@ -250,17 +251,17 @@ bool CountryDefinitionManager::load_country_data_file(
 			)
 	)(root);
 
-	IdentifierRegistry<CountryParty> parties { "country parties" };
-	parties.reserve(party_dtos.size());
+	OwningRegistry<CountryParty, std::size_t> parties { create_empty, party_dtos.size() };
 
 	for (CountryPartyDto& dto : party_dtos) {
-		ret &= parties.emplace_item(
+		ret &= try_emplace_item(
+			parties,
 			dto.identifier,
-			duplicate_warning_callback,
+			duplicate_warning_cb,
 			dto.identifier, dto.start_date, dto.end_date, dto.ideology, std::move(dto.policies)
 		);
 	}
-	parties.lock();
+	lock_registry(parties);
 
 	ret &= add_country(
 		name, colour, graphical_culture,

src/openvic-simulation/country/CountryDefinitionManager.hpp

@@ -5,6 +5,7 @@
 #include "openvic-simulation/country/CountryDefinition.hpp"
 #include "openvic-simulation/dataloader/Node_forwarded.hpp"
 #include "openvic-simulation/types/ConstructorTags.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry.hpp"
 #include "openvic-simulation/types/TypedIndices.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
@@ -15,10 +16,10 @@ namespace OpenVic {
 
 	struct CountryDefinitionManager {
 	private:
-		IdentifierRegistry<CountryDefinition> IDENTIFIER_REGISTRY(country_definition);
+		OwningRegistry<CountryDefinition, country_index_t> PROPERTY(country_definitions);
 
 	public:
-		constexpr CountryDefinitionManager() {}
+		constexpr CountryDefinitionManager() : country_definitions(create_empty) {}
 
 		bool add_country(
 			std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture,

src/openvic-simulation/country/CountryInstance.cpp

@@ -1638,7 +1638,9 @@ void CountryInstance::_update_military() {
 			fixed_point_t::parse_raw(regular_army_size),
 			fixed_point_t::parse_raw(
 				7 * (
-					1 + unit_type_manager.get_regiment_type_count()
+					1 + type_safe::get(
+						unit_type_manager.get_regiment_types().size()
+					)
 				)
 			)
 		)

src/openvic-simulation/country/CountryInstanceManager.cpp

@@ -11,6 +11,7 @@
 #include "openvic-simulation/history/CountryHistory.hpp"
 #include "openvic-simulation/military/UnitInstanceGroup.hpp"
 #include "openvic-simulation/population/Pop.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry_Search.hpp"
 #include "openvic-simulation/utility/ThreadPool.hpp"
 
 #if defined(__APPLE__)
@@ -38,21 +39,21 @@ CountryInstanceManager::CountryInstanceManager(
 		regiment_types
 	},
 	country_instances {
-		country_index_t(new_country_definition_manager.get_country_definition_count()),
+		new_country_definition_manager.get_country_definitions().size(),
 		[
 			this,
 			&new_country_definition_manager,
 			&country_instance_deps
 		](const country_index_t country_index)->auto{
 			return std::make_tuple(
-				std::ref(*new_country_definition_manager.get_country_definition_by_index(country_index)),
+				std::ref(new_country_definition_manager.get_country_definitions()[country_index]),
 				std::ref(shared_country_values),
 				std::ref(country_instance_deps)
 			);
 		}
 	}
 {
-	assert(new_country_definition_manager.country_definitions_are_locked());
+	assert(new_country_definition_manager.get_country_definitions().is_locked());
 	great_powers.reserve(new_country_defines.get_great_power_rank());
 	secondary_powers.reserve(new_country_defines.get_max_secondary_power_count());
 }
@@ -186,17 +187,20 @@ CountryDefinition const* find_country_definition_by_identifier(
 	CountryDefinitionManager const& country_definition_manager,
 	std::string_view identifier
 ) {
-	return country_definition_manager.get_country_definition_by_identifier(identifier);
+	const auto it = find(country_definition_manager.get_country_definitions(), identifier);
+	return it == country_definition_manager.get_country_definitions().end()
+		? nullptr
+		: &*it;
 }
 
 CountryInstance* CountryInstanceManager::get_country_instance_by_identifier(std::string_view identifier) {
-	CountryDefinition const* country_definition = country_definition_manager.get_country_definition_by_identifier(identifier);
+	CountryDefinition const* country_definition = find_country_definition_by_identifier(country_definition_manager, identifier);
 	return country_definition == nullptr
 		? nullptr
 		: &(country_instances[country_definition->index]);
 }
 CountryInstance const* CountryInstanceManager::get_country_instance_by_identifier(std::string_view identifier) const {
-	CountryDefinition const* country_definition = country_definition_manager.get_country_definition_by_identifier(identifier);
+	CountryDefinition const* country_definition = find_country_definition_by_identifier(country_definition_manager, identifier);
 	return country_definition == nullptr
 		? nullptr
 		: &(country_instances[country_definition->index]);

src/openvic-simulation/dataloader/Dataloader.cpp

@@ -21,6 +21,7 @@
 #include "openvic-simulation/interface/UI.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/misc/SoundEffect.hpp"
+#include "openvic-simulation/types/registries/OwningRegistry_Search.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
@@ -605,19 +606,17 @@ bool Dataloader::_load_history(DefinitionManager& definition_manager, bool unuse
 				const memory::string filename = file.stem().string<char>(memory::string::allocator_type{});
 				const std::string_view country_id = extract_basic_identifier_prefix(filename);
 
-				CountryDefinitionManager const& country_definition_manager = definition_manager.get_country_definition_manager();
-				CountryDefinition const* country = country_definition_manager.get_country_definition_by_identifier(
-					country_id
-				);
-				if (country == nullptr) {
+				auto const& country_definitions = definition_manager.get_country_definition_manager().get_country_definitions();
+				const auto it = find(country_definitions, country_id);
+				if (it == country_definitions.end()) {
 					if (unused_history_file_warnings) {
 						spdlog::warn_s("Found history file for non-existent country: {}", country_id);
 					}
 					return true;
 				}
 
 				return country_history_manager.load_country_history_file(
-					definition_manager, *this, *country,
+					definition_manager, *this, *it,
 					definition_manager.get_politics_manager().get_ideology_manager().get_ideologies(),
 					definition_manager.get_politics_manager().get_government_type_manager().get_government_types(),
 					parse_defines(file).get_file_node()

src/openvic-simulation/dataloader/IdentifierPolicy.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <cstdint>
+
+namespace OpenVic {
+	enum struct IdentifierSyntax : uint8_t {
+		Either,
+		Identifier, // ENG
+		String // "ENG"
+	};
+	struct IdentifierValidation {
+		bool allow_empty = false;
+		bool warn_on_invalid = false;
+	};
+}