Split identifier registry

src/openvic-simulation/DefinitionManager.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "openvic-simulation/country/CountryDefinition.hpp"
+#include "openvic-simulation/country/CountryDefinitionManager.hpp"
 #include "openvic-simulation/defines/Define.hpp"
 #include "openvic-simulation/diplomacy/DiplomaticAction.hpp"
 #include "openvic-simulation/economy/EconomyManager.hpp"

src/openvic-simulation/InstanceManager.hpp

@@ -9,14 +9,14 @@
 #include "openvic-simulation/country/CountryInstanceDeps.hpp"
 #include "openvic-simulation/country/CountryInstanceManager.hpp"
 #include "openvic-simulation/diplomacy/CountryRelation.hpp"
-#include "openvic-simulation/economy/GoodInstance.hpp"
+#include "openvic-simulation/economy/GoodInstanceManager.hpp"
 #include "openvic-simulation/economy/production/ArtisanalProducerDeps.hpp"
 #include "openvic-simulation/economy/production/ResourceGatheringOperationDeps.hpp"
 #include "openvic-simulation/economy/trading/MarketInstance.hpp"
 #include "openvic-simulation/map/MapInstance.hpp"
 #include "openvic-simulation/map/Mapmode.hpp"
 #include "openvic-simulation/map/ProvinceInstanceDeps.hpp"
-#include "openvic-simulation/military/UnitInstanceGroup.hpp"
+#include "openvic-simulation/military/UnitInstanceManager.hpp"
 #include "openvic-simulation/misc/GameAction.hpp"
 #include "openvic-simulation/misc/SimulationClock.hpp"
 #include "openvic-simulation/politics/PoliticsInstanceManager.hpp"

src/openvic-simulation/core/template/FunctionalConcepts.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <concepts>
+#include <functional>
+
+namespace OpenVic {
+#define FWD(...) static_cast<decltype(__VA_ARGS__)>(__VA_ARGS__)
+	template<typename Fn, typename Return = void, typename... Args>
+	concept Functor = requires(Fn&& fn, Args&&... args) {
+		{ std::invoke(FWD(fn), FWD(args)...) } -> std::same_as<Return>;
+	};
+
+	template<typename Fn, typename Return = void, typename... Args>
+	concept FunctorConvertible = requires(Fn&& fn, Args&&... args) {
+		{ std::invoke(FWD(fn), FWD(args)...) } -> std::convertible_to<Return>;
+	};
+
+	template<typename Fn, typename... Args>
+	concept Callback = Functor<Fn, bool, Args...>;
+#undef FWD
+}

src/openvic-simulation/country/CountryDefinition.cpp

@@ -2,23 +2,11 @@
 
 #include <string_view>
 
-#include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>
-
-#include "openvic-simulation/dataloader/Dataloader.hpp"
-#include "openvic-simulation/dataloader/NodeTools.hpp"
-#include "openvic-simulation/DefinitionManager.hpp"
-#include "openvic-simulation/politics/Government.hpp"
-#include "openvic-simulation/politics/Ideology.hpp"
-#include "openvic-simulation/politics/PartyPolicy.hpp"
 #include "openvic-simulation/population/Culture.hpp"
 #include "openvic-simulation/types/Colour.hpp"
-#include "openvic-simulation/types/FixedVector.hpp"
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
-#include "openvic-simulation/types/TypedIndices.hpp"
-#include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
-using namespace OpenVic::NodeTools;
 
 CountryDefinition::CountryDefinition(
 	std::string_view new_identifier,
@@ -43,201 +31,4 @@ CountryDefinition::CountryDefinition(
 	secondary_unit_colour { new_secondary_unit_colour },
 	tertiary_unit_colour { new_tertiary_unit_colour } {}
 
-bool CountryDefinitionManager::add_country(
-	std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture,
-	IdentifierRegistry<CountryParty>&& parties, CountryDefinition::unit_names_map_t&& unit_names, bool dynamic_tag,
-	CountryDefinition::government_colour_map_t&& alternative_colours
-) {
-	if (identifier.empty()) {
-		spdlog::error_s("Invalid country identifier - empty!");
-		return false;
-	}
-	if (!valid_basic_identifier(identifier)) {
-		spdlog::error_s(
-			"Invalid country identifier: {} (can only contain alphanumeric characters and underscores)", identifier
-		);
-		return false;
-	}
-	if (graphical_culture == nullptr) {
-		spdlog::error_s("Null graphical culture for country {}", identifier);
-		return false;
-	}
-
-	static constexpr colour_t default_colour = colour_t::fill_as(colour_t::max_value);
-
-	return country_definitions.emplace_item(
-		identifier, //
-		identifier, colour, CountryDefinition::index_t { get_country_definition_count() }, *graphical_culture,
-		std::move(parties), std::move(unit_names), 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
-	);
-}
-
-bool CountryDefinitionManager::load_countries(
-	DefinitionManager const& definition_manager, Dataloader const& dataloader, ast::NodeCPtr root
-) {
-	static constexpr std::string_view common_dir = "common/";
-	bool is_dynamic = false;
-
-	const bool ret = expect_dictionary_reserve_length(
-		country_definitions,
-		[this, &definition_manager, &is_dynamic, &dataloader](std::string_view key, ast::NodeCPtr value) -> bool {
-			if (key == "dynamic_tags") {
-				return expect_bool([&is_dynamic](bool val) -> bool {
-					if (val == is_dynamic) {
-						spdlog::warn_s("Redundant \"is_dynamic\", already {}", val ? "true" : "false");
-					} else {
-						if (is_dynamic) {
-							spdlog::warn_s("Changing \"is_dynamic\" back to false");
-						}
-						is_dynamic = val;
-					}
-					return true;
-				})(value);
-			}
-			if (expect_string(
-				[this, &definition_manager, is_dynamic, &dataloader, &key](std::string_view filepath) -> bool {
-					if (load_country_data_file(
-						definition_manager, key, is_dynamic,
-						Dataloader::parse_defines(
-							dataloader.lookup_file(append_string_views(common_dir, filepath))
-						).get_file_node()
-					)) {
-						return true;
-					}
-					spdlog::critical_s("Failed to load country data file: {}", filepath);
-					return false;
-				}
-			)(value)) {
-				return true;
-			}
-			spdlog::critical_s("Failed to load country: {}", key);
-			return false;
-		}
-	)(root);
-	lock_country_definitions();
-	return ret;
-}
-
-bool CountryDefinitionManager::load_country_colours(ast::NodeCPtr root) {
-	return country_definitions.expect_item_dictionary_and_default(
-		[](std::string_view key, ast::NodeCPtr value) -> bool {
-			spdlog::warn_s("country_colors.txt references country tag {} which is not defined!", key);
-			return true;
-		},
-		[](CountryDefinition& country, ast::NodeCPtr colour_node) -> bool {
-			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)),
-				"color3", ONE_EXACTLY, expect_colour(assign_variable_callback(country.tertiary_unit_colour))
-			)(colour_node);
-		}
-	)(root);
-}
-
-node_callback_t CountryDefinitionManager::load_country_party(
-	PoliticsManager const& politics_manager, IdentifierRegistry<CountryParty>& country_parties
-) const {
-	return [&politics_manager, &country_parties](ast::NodeCPtr value) -> bool {
-		std::string_view party_name;
-		Date start_date, end_date;
-		Ideology const* ideology = nullptr;
-		memory::FixedVector<PartyPolicy const*, party_policy_group_index_t> policies {
-			party_policy_group_index_t(politics_manager.get_issue_manager().get_party_policy_group_count()),
-			nullptr
-		};
-
-		bool ret = expect_dictionary_keys_and_default(
-			[&politics_manager, &policies, &party_name](std::string_view key, ast::NodeCPtr value) -> bool {
-				return politics_manager.get_issue_manager().expect_party_policy_group_str(
-					[&politics_manager, &policies, value, &party_name](PartyPolicyGroup const& party_policy_group) -> bool {
-						PartyPolicy const*& policy = policies[party_policy_group.index];
-
-						if (policy != nullptr) {
-							spdlog::error_s(
-								"Country party \"{}\" has duplicate entry for party policy group \"{}\"",
-								party_name, party_policy_group
-							);
-							return false;
-						}
-
-						return politics_manager.get_issue_manager().expect_party_policy_identifier(
-							[&party_policy_group, &policy](PartyPolicy const& party_policy) -> bool {
-								if (&party_policy.group == &party_policy_group) {
-									policy = &party_policy;
-									return true;
-								}
-
-								// TODO - change this back to error/false once TGC no longer has this issue
-								spdlog::warn_s(
-									"Invalid party policy \"{}\", group is \"{}\" when \"{}\" was expected.",
-									party_policy,
-									party_policy.group,
-									party_policy_group
-								);
-								return true;
-							}
-						)(value);
-					}
-				)(key);
-			},
-			"name", ONE_EXACTLY, expect_string(assign_variable_callback(party_name)),
-			"start_date", ONE_EXACTLY, expect_date(assign_variable_callback(start_date)),
-			"end_date", ONE_EXACTLY, expect_date(assign_variable_callback(end_date)),
-			"ideology", ONE_EXACTLY,
-				politics_manager.get_ideology_manager().expect_ideology_identifier(assign_variable_callback_pointer(ideology))
-		)(value);
-
-		if (ideology == nullptr) {
-			spdlog::warn_s("Country party {} has no ideology, defaulting to nullptr / no ideology", party_name);
-		}
-
-		ret &= country_parties.emplace_item(
-			party_name,
-			duplicate_warning_callback,
-			party_name, start_date, end_date, ideology, std::move(policies)
-		);
-
-		return ret;
-	};
-}
-
-bool CountryDefinitionManager::load_country_data_file(
-	DefinitionManager const& definition_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root
-) {
-	colour_t colour;
-	GraphicalCultureType const* graphical_culture;
-	IdentifierRegistry<CountryParty> parties { "country parties" };
-	CountryDefinition::unit_names_map_t unit_names;
-	CountryDefinition::government_colour_map_t alternative_colours;
-	bool ret = expect_dictionary_keys_and_default(
-		[&definition_manager, &alternative_colours](std::string_view key, ast::NodeCPtr value) -> bool {
-			return definition_manager.get_politics_manager().get_government_type_manager().expect_government_type_str(
-				[&alternative_colours, value](GovernmentType const& government_type) -> bool {
-					return expect_colour(map_callback(alternative_colours, &government_type))(value);
-				}
-			)(key);
-		},
-		"color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)),
-		"graphical_culture", ONE_EXACTLY,
-			definition_manager.get_pop_manager().get_culture_manager().expect_graphical_culture_type_identifier(
-				assign_variable_callback_pointer(graphical_culture)
-			),
-		"party", ZERO_OR_MORE, load_country_party(definition_manager.get_politics_manager(), parties),
-		"unit_names", ZERO_OR_ONE,
-			definition_manager.get_military_manager().get_unit_type_manager().expect_unit_type_dictionary_reserve_length(
-				unit_names,
-				[&unit_names](UnitType const& unit, ast::NodeCPtr value) -> bool {
-					return name_list_callback(map_callback(unit_names, &unit))(value);
-				}
-			)
-	)(root);
-
-	ret &= add_country(
-		name, colour, graphical_culture, std::move(parties), std::move(unit_names), is_dynamic, std::move(alternative_colours)
-	);
-	return ret;
-}
-
 template struct fmt::formatter<OpenVic::CountryDefinition>;

src/openvic-simulation/country/CountryDefinition.hpp

@@ -2,8 +2,6 @@
 
 #include <string_view>
 
-#include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>
-
 #include "openvic-simulation/core/Typedefs.hpp"
 #include "openvic-simulation/country/CountryParty.hpp"
 #include "openvic-simulation/types/HasIdentifier.hpp"
@@ -14,18 +12,15 @@
 
 namespace OpenVic {
 	struct CountryDefinitionManager;
-	class Dataloader;
-	struct DefinitionManager;
 	struct GraphicalCultureType;
 	struct GovernmentType;
-	struct PoliticsManager;
 	struct UnitType;
 
 	/* Generic information about a TAG */
 	struct CountryDefinition : HasIdentifierAndColour, HasIndex<CountryDefinition, country_index_t> {
 		friend struct CountryDefinitionManager;
 
-		using unit_names_map_t = ordered_map<UnitType const*, name_list_t>;
+		using unit_names_map_t = ordered_map<UnitType const*, memory::vector<memory::string>>;
 		using government_colour_map_t = ordered_map<GovernmentType const*, colour_t>;
 
 	private:
@@ -58,29 +53,6 @@ namespace OpenVic {
 
 		// TODO - get_colour including alternative colours
 	};
-
-	struct CountryDefinitionManager {
-	private:
-		IdentifierRegistry<CountryDefinition> IDENTIFIER_REGISTRY(country_definition);
-
-		NodeTools::node_callback_t load_country_party(
-			PoliticsManager const& politics_manager, IdentifierRegistry<CountryParty>& country_parties
-		) const;
-
-	public:
-		bool add_country(
-			std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture,
-			IdentifierRegistry<CountryParty>&& parties, CountryDefinition::unit_names_map_t&& unit_names, bool dynamic_tag,
-			CountryDefinition::government_colour_map_t&& alternative_colours
-		);
-
-		bool load_country_colours(ast::NodeCPtr root);
-
-		bool load_countries(DefinitionManager const& definition_manager, Dataloader const& dataloader, ast::NodeCPtr root);
-		bool load_country_data_file(
-			DefinitionManager const& definition_manager, std::string_view name, bool is_dynamic, ast::NodeCPtr root
-		);
-	};
 }
 
 extern template struct fmt::formatter<OpenVic::CountryDefinition>;