diff --git a/src/openvic-simulation/country/CountryDefinition.cpp b/src/openvic-simulation/country/CountryDefinition.cpp index 95634bed..1fa14738 100644 --- a/src/openvic-simulation/country/CountryDefinition.cpp +++ b/src/openvic-simulation/country/CountryDefinition.cpp @@ -2,14 +2,6 @@ #include -#include - -#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/IdentifierRegistry.hpp" @@ -72,167 +64,4 @@ bool CountryDefinitionManager::add_country( ); } -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(StringUtils::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& 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; - IndexedFlatMap policies { politics_manager.get_issue_manager().get_party_policy_groups() }; - - 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.at(party_policy_group); - - 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.get_issue_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.get_issue_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 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; diff --git a/src/openvic-simulation/country/CountryDefinition.hpp b/src/openvic-simulation/country/CountryDefinition.hpp index 21362402..ec28ea99 100644 --- a/src/openvic-simulation/country/CountryDefinition.hpp +++ b/src/openvic-simulation/country/CountryDefinition.hpp @@ -34,11 +34,9 @@ namespace OpenVic { unit_names_map_t PROPERTY(unit_names); const bool PROPERTY_CUSTOM_PREFIX(dynamic_tag, is); government_colour_map_t PROPERTY(alternative_colours); - colour_t PROPERTY(primary_unit_colour); - colour_t PROPERTY(secondary_unit_colour); - colour_t PROPERTY(tertiary_unit_colour); - // Unit colours not const due to being added after construction - + colour_t PROPERTY_RW(primary_unit_colour); + colour_t PROPERTY_RW(secondary_unit_colour); + colour_t PROPERTY_RW(tertiary_unit_colour); public: CountryDefinition( @@ -56,23 +54,14 @@ namespace OpenVic { private: IdentifierRegistry IDENTIFIER_REGISTRY(country_definition); - NodeTools::node_callback_t load_country_party( - PoliticsManager const& politics_manager, IdentifierRegistry& country_parties - ) const; - public: + IDENTIFIER_REGISTRY_NON_CONST_ACCESSORS(country_definition); + bool add_country( std::string_view identifier, colour_t colour, GraphicalCultureType const* graphical_culture, IdentifierRegistry&& 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 - ); }; } diff --git a/src/openvic-simulation/dataloader/Dataloader.cpp b/src/openvic-simulation/dataloader/Dataloader.cpp index 9b5557c7..c73e3466 100644 --- a/src/openvic-simulation/dataloader/Dataloader.cpp +++ b/src/openvic-simulation/dataloader/Dataloader.cpp @@ -13,9 +13,11 @@ #include #include "openvic-simulation/DefinitionManager.hpp" +#include "openvic-simulation/dataloader/parse/CountryParser.hpp" #include "openvic-simulation/interface/UI.hpp" #include "openvic-simulation/misc/GameRulesManager.hpp" #include "openvic-simulation/misc/SoundEffect.hpp" +#include "openvic-simulation/utility/Error.hpp" #include "openvic-simulation/utility/Logger.hpp" #include "openvic-simulation/utility/StringUtils.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -926,6 +928,49 @@ bool Dataloader::_load_sound_effect_defines(DefinitionManager& definition_manage } +static constexpr std::string_view common_folder = "common/"; +static constexpr std::string_view countries_file = "common/countries.txt"; +static constexpr std::string_view country_colours_file = "common/country_colors.txt"; + +Error Dataloader::_load_countries(DefinitionManager& definition_manager) { + CountryParser country_parser { + definition_manager.get_politics_manager().get_government_type_manager().get_government_type_registry(), + definition_manager.get_pop_manager().get_culture_manager().get_graphical_culture_type_registry(), + definition_manager.get_military_manager().get_unit_type_manager().get_unit_type_registry(), + definition_manager.get_politics_manager().get_issue_manager().get_party_policy_group_registry(), + definition_manager.get_politics_manager().get_issue_manager().get_party_policy_registry(), + definition_manager.get_politics_manager().get_ideology_manager().get_ideology_registry(), + parse_defines(lookup_file(countries_file)) + }; + + if (Error err = country_parser.load_country_list(); err != Error::OK) { + spdlog::critical_s("Failed to load country list!"); + return err; + } + + if (Error err = country_parser.load_countries_from( // + common_folder, *this, definition_manager.get_country_definition_manager() + ); + err != Error::OK // + ) { + spdlog::critical_s("Failed to load countries!"); + return err; + } + + if (Error err = country_parser.load_country_colours( + parse_defines(lookup_file(country_colours_file)).get_file_node(), + definition_manager.get_country_definition_manager() + ); + err != Error::OK // + ) { + spdlog::critical_s("Failed to load country colours!"); + return err; + } + + return Error::OK; +} + + bool Dataloader::load_defines( GameRulesManager const& game_rules_manager, DefinitionManager& definition_manager @@ -938,8 +983,6 @@ bool Dataloader::load_defines( static constexpr std::string_view defines_file = "common/defines.lua"; static constexpr std::string_view buildings_file = "common/buildings.txt"; static constexpr std::string_view bookmark_file = "common/bookmarks.txt"; - static constexpr std::string_view countries_file = "common/countries.txt"; - static constexpr std::string_view country_colours_file = "common/country_colors.txt"; static constexpr std::string_view culture_file = "common/cultures.txt"; static constexpr std::string_view governments_file = "common/governments.txt"; static constexpr std::string_view graphical_culture_type_file = "common/graphicalculturetype.txt"; @@ -1135,18 +1178,11 @@ bool Dataloader::load_defines( spdlog::critical_s("Failed to load bookmarks!"); ret = false; } - if (!definition_manager.get_country_definition_manager().load_countries( - definition_manager, *this, parse_defines(lookup_file(countries_file)).get_file_node() - )) { - spdlog::critical_s("Failed to load countries!"); - ret = false; - } - if (!definition_manager.get_country_definition_manager().load_country_colours( - parse_defines(lookup_file(country_colours_file)).get_file_node() - )) { - spdlog::critical_s("Failed to load country colours!"); + + if(_load_countries(definition_manager) != Error::OK) { ret = false; } + if (!definition_manager.get_pop_manager().get_culture_manager().load_culture_file( definition_manager.get_country_definition_manager(), parse_defines(lookup_file(culture_file)).get_file_node() )) { diff --git a/src/openvic-simulation/dataloader/Dataloader.hpp b/src/openvic-simulation/dataloader/Dataloader.hpp index 54662d23..9611bd21 100644 --- a/src/openvic-simulation/dataloader/Dataloader.hpp +++ b/src/openvic-simulation/dataloader/Dataloader.hpp @@ -10,6 +10,7 @@ #include "openvic-simulation/dataloader/ModManager.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/Concepts.hpp" +#include "openvic-simulation/utility/Error.hpp" #include @@ -43,6 +44,7 @@ namespace OpenVic { bool _load_sound_effect_defines(DefinitionManager& definition_manager) const; bool _load_decisions(DefinitionManager& definition_manager); bool _load_history(DefinitionManager& definition_manager, bool unused_history_file_warnings) const; + Error _load_countries(DefinitionManager& definition_manager); bool should_ignore_path(fs::path const& path, path_span_t replace_paths) const; diff --git a/src/openvic-simulation/dataloader/parse/CountryParser.cpp b/src/openvic-simulation/dataloader/parse/CountryParser.cpp new file mode 100644 index 00000000..5fd37b10 --- /dev/null +++ b/src/openvic-simulation/dataloader/parse/CountryParser.cpp @@ -0,0 +1,230 @@ +#include "CountryParser.hpp" + +#include +#include + +#include + +#include "openvic-simulation/country/CountryDefinition.hpp" +#include "openvic-simulation/dataloader/Dataloader.hpp" +#include "openvic-simulation/dataloader/NodeTools.hpp" +#include "openvic-simulation/military/UnitType.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/Date.hpp" +#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/utility/Containers.hpp" +#include "openvic-simulation/utility/Error.hpp" +#include "openvic-simulation/utility/Logger.hpp" +#include "openvic-simulation/utility/StringUtils.hpp" +#include "openvic-simulation/utility/Typedefs.hpp" + +using namespace OpenVic; + +CountryParser::CountryParser( + IdentifierRegistry const& government_type_registry, // + IdentifierRegistry const& graphical_culture_type_registry, // + IdentifierPointerRegistry const& unit_type_registry, // + IdentifierRegistry const& policy_group_registry, // + IdentifierRegistry const& party_policy_registry, // + IdentifierRegistry const& ideology_registry, // + ovdl::v2script::Parser list_parser +) + : government_type_registry { &government_type_registry }, // + graphical_culture_type_registry { &graphical_culture_type_registry }, // + unit_type_registry { &unit_type_registry }, // + policy_group_registry { &policy_group_registry }, // + party_policy_registry { &party_policy_registry }, // + ideology_registry { &ideology_registry }, // + list_parser { std::move(list_parser) } {} + +Error CountryParser::load_country_list() { + using namespace NodeTools; + + bool is_dynamic = false; + + const bool ret = + expect_dictionary_reserve_length(tags, [this, &is_dynamic](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); + } + + std::string_view path; + if (expect_string(assign_variable_callback(path))(value)) { + tags.emplace_back(key, path, is_dynamic); + return true; + } + + spdlog::critical_s("Failed to load tag {} in country list.", key); + return false; + })(list_parser.get_file_node()); + + return ret ? Error::OK : Error::FAILED; +} + + +Error CountryParser::load_countries_from( + std::string_view common_folder, Dataloader& dataloader, CountryDefinitionManager& manager +) { + Error err; + + for (TagData const& data : tags) { + const fs::path path = dataloader.lookup_file(StringUtils::append_string_views(common_folder, data.path)); + if (Error load_err = load_country(data.tag, data.is_dynamic, Dataloader::parse_defines(path).get_file_node(), manager); + load_err != Error::OK) { + err = load_err; + } + } + return err; +} + +OV_SPEED_INLINE NodeTools::NodeCallback auto CountryParser::_expect_country_party( // + IdentifierRegistry& r_parties_registry +) { + using namespace NodeTools; + + return [this, &r_parties_registry](ast::NodeCPtr value) -> bool { + std::string_view party_name; + Date start_date, end_date; + Ideology const* ideology = nullptr; + IndexedFlatMap policies { policy_group_registry->get_items() }; + + bool ret = expect_dictionary_keys_and_default( + [&policies, &party_name, this](std::string_view key, ast::NodeCPtr value) -> bool { + return policy_group_registry->expect_item_str( + [this, &policies, value, &party_name](PartyPolicyGroup const& party_policy_group) -> bool { + PartyPolicy const*& policy = policies.at(party_policy_group); + + if (policy != nullptr) { + spdlog::error_s( + "Country party \"{}\" has duplicate entry for party policy group \"{}\"", + party_name, party_policy_group + ); + return false; + } + + return party_policy_registry->expect_item_identifier( + [&policy, &party_policy_group](PartyPolicy const& party_policy) -> bool { + if (&party_policy.get_issue_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.get_issue_group(), + party_policy_group + ); + return true; + }, false + )(value); + }, false, false + )(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, + ideology_registry->expect_item_identifier(assign_variable_callback_pointer(ideology), false) + )(value); + + if (ideology == nullptr) { + spdlog::warn_s("Country party {} has no ideology, defaulting to nullptr / no ideology", party_name); + } + + ret &= r_parties_registry.emplace_item( + party_name, duplicate_warning_callback, party_name, start_date, end_date, ideology, std::move(policies) + ); + + return ret; + }; +} + +Error CountryParser::load_country( + std::string_view tag, bool is_dynamic_tag, ast::NodeCPtr country_root, CountryDefinitionManager& definition_manager +) { + using namespace NodeTools; + + colour_t colour; + GraphicalCultureType const* graphical_culture; + IdentifierRegistry parties { "country parties" }; + CountryDefinition::unit_names_map_t unit_names; + CountryDefinition::government_colour_map_t alternative_colours; + + bool ret = expect_dictionary_keys_and_default( + [this, &alternative_colours](std::string_view key, ast::NodeCPtr value) -> bool { + return government_type_registry->expect_item_str( + [&alternative_colours, value](GovernmentType const& government_type) -> bool { + return expect_colour(map_callback(alternative_colours, &government_type))(value); + }, false, false + )(key); + }, + "color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)), + "graphical_culture", ONE_EXACTLY, + graphical_culture_type_registry->expect_item_identifier( + assign_variable_callback_pointer(graphical_culture) + ), + "party", ZERO_OR_MORE, _expect_country_party(parties), + "unit_names", ZERO_OR_ONE, + unit_type_registry->expect_item_dictionary_reserve_length( + unit_names, + [&unit_names](UnitType const& unit, ast::NodeCPtr value) -> bool { + return name_list_callback(map_callback(unit_names, &unit))(value); + } + ) + )(country_root); + + ret &= definition_manager.add_country( + tag, colour, graphical_culture, std::move(parties), std::move(unit_names), is_dynamic_tag, + std::move(alternative_colours) + ); + + return ret ? Error::OK : Error::FAILED; +} + +NodeTools::node_callback_t CountryParser::expect_country_party(IdentifierRegistry& r_parties_registry) { + return _expect_country_party(r_parties_registry); +} + +Error CountryParser::load_country_colours(ast::NodeCPtr colours_root, CountryDefinitionManager& manager) { + using namespace NodeTools; + + const bool ret = manager.expect_country_definition_dictionary_and_default( + [](std::string_view key, ast::NodeCPtr value) -> bool { + spdlog::warn_s("country_colors references country tag {} which is not defined!", key); + return true; + }, + [](CountryDefinition& country, ast::NodeCPtr colour_node) -> bool { + colour_t primary, secondary, tertiary; + + const bool ret = expect_dictionary_keys( + "color1", ONE_EXACTLY, expect_colour(assign_variable_callback(primary)), + "color2", ONE_EXACTLY, expect_colour(assign_variable_callback(secondary)), + "color3", ONE_EXACTLY, expect_colour(assign_variable_callback(tertiary)) + )(colour_node); + + country.set_primary_unit_colour(primary); + country.set_secondary_unit_colour(secondary); + country.set_tertiary_unit_colour(tertiary); + + return ret; + } + )(colours_root); + + return ret ? Error::OK : Error::FAILED; +} diff --git a/src/openvic-simulation/dataloader/parse/CountryParser.hpp b/src/openvic-simulation/dataloader/parse/CountryParser.hpp new file mode 100644 index 00000000..cea8114b --- /dev/null +++ b/src/openvic-simulation/dataloader/parse/CountryParser.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include + +#include +#include + +#include "openvic-simulation/country/CountryDefinition.hpp" +#include "openvic-simulation/country/CountryParty.hpp" +#include "openvic-simulation/dataloader/Dataloader.hpp" +#include "openvic-simulation/dataloader/NodeTools.hpp" +#include "openvic-simulation/military/UnitType.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/IdentifierRegistry.hpp" +#include "openvic-simulation/utility/Containers.hpp" +#include "openvic-simulation/utility/Error.hpp" + +namespace OpenVic { + class CountryParser { + IdentifierRegistry const* government_type_registry; + IdentifierRegistry const* graphical_culture_type_registry; + IdentifierPointerRegistry const* unit_type_registry; + IdentifierRegistry const* policy_group_registry; + IdentifierRegistry const* party_policy_registry; + IdentifierRegistry const* ideology_registry; + + ovdl::v2script::Parser list_parser; + + OV_SPEED_INLINE NodeTools::NodeCallback auto _expect_country_party( // + IdentifierRegistry& r_parties_registry + ); + + public: + struct TagData { + std::string_view tag; + std::string_view path; + bool is_dynamic = false; + }; + + private: + memory::vector PROPERTY(tags); + + public: + CountryParser( + IdentifierRegistry const& government_type_registry, // + IdentifierRegistry const& graphical_culture_type_registry, // + IdentifierPointerRegistry const& unit_type_registry, // + IdentifierRegistry const& policy_group_registry, // + IdentifierRegistry const& party_policy_registry, // + IdentifierRegistry const& ideology_registry, // + ovdl::v2script::Parser list_parser + ); + + Error load_country_list(); + Error load_countries_from(std::string_view common_folder, Dataloader& dataloader, CountryDefinitionManager& manager); + + NodeTools::node_callback_t expect_country_party(IdentifierRegistry& r_parties_registry); + + Error load_country( // + std::string_view tag, bool is_dynamic_tag, ast::NodeCPtr country_root, CountryDefinitionManager& manager + ); + + Error load_country_colours(ast::NodeCPtr colours_root, CountryDefinitionManager& manager); + }; +} diff --git a/src/openvic-simulation/types/IdentifierRegistry.hpp b/src/openvic-simulation/types/IdentifierRegistry.hpp index 9bb7b4bc..110d6fdc 100644 --- a/src/openvic-simulation/types/IdentifierRegistry.hpp +++ b/src/openvic-simulation/types/IdentifierRegistry.hpp @@ -760,5 +760,8 @@ public: \ NodeTools::Callback auto callback \ ) const_kw { \ return registry.expect_item_dictionary_reserve_length(reservable, callback); \ + } \ + constexpr decltype(registry) const_kw& get_##singular##_registry() const_kw { \ + return registry; \ } }