Added map_callback and expect_item_dictionary_reserve_length

24 files changed, 428 insertions, 318 deletions

diff --git a/src/openvic-simulation/country/Country.cpp b/src/openvic-simulation/country/Country.cpp
index 299407c..463d1bf 100644
--- a/src/openvic-simulation/country/Country.cpp
+++ b/src/openvic-simulation/country/Country.cpp
@@ -1,10 +1,6 @@
 #include "Country.hpp"
 
-#include <filesystem>
 #include <string_view>
-#include <system_error>
-#include <unordered_map>
-#include <vector>
 
 #include <openvic-dataloader/v2script/AbstractSyntaxTree.hpp>
 
@@ -125,8 +121,7 @@ node_callback_t CountryManager::load_country_party(
 						return politics_manager.get_issue_manager().expect_issue_identifier(
 							[&policies, &group](Issue const& issue) -> bool {
 								if (&issue.get_group() == &group) {
-									policies.emplace(&group, &issue);
-									return true;
+									return map_callback(policies, &group)(&issue);
 								}
 								// TODO - change this back to error/false once TGC no longer has this issue
 								Logger::warning("Invalid policy ", issue.get_identifier(), ", group is ",
@@ -161,19 +156,10 @@ bool CountryManager::load_country_data_file(
 	Country::unit_names_map_t unit_names;
 	Country::government_colour_map_t alternative_colours;
 	bool ret = expect_dictionary_keys_and_default(
-		[&game_manager, &alternative_colours, &name](std::string_view key, ast::NodeCPtr value) -> bool {
+		[&game_manager, &alternative_colours](std::string_view key, ast::NodeCPtr value) -> bool {
 			return game_manager.get_politics_manager().get_government_type_manager().expect_government_type_str(
-				[&alternative_colours, &name, &value](GovernmentType const& government_type) -> bool {
-					if (alternative_colours.contains(&government_type)) {
-						Logger::error(
-							"Country ", name, " has duplicate entry for ", government_type.get_identifier(),
-							" alternative colour"
-						);
-						return false;
-					}
-					return expect_colour([&alternative_colours, &government_type](colour_t colour) -> bool {
-						return alternative_colours.emplace(&government_type, std::move(colour)).second;
-					})(value);
+				[&alternative_colours, value](GovernmentType const& government_type) -> bool {
+					return expect_colour(map_callback(alternative_colours, &government_type))(value);
 				}
 			)(key);
 		},
@@ -184,15 +170,10 @@ bool CountryManager::load_country_data_file(
 			),
 		"party", ZERO_OR_MORE, load_country_party(game_manager.get_politics_manager(), parties),
 		"unit_names", ZERO_OR_ONE,
-			game_manager.get_military_manager().get_unit_manager().expect_unit_dictionary(
-				[&unit_names, &name](Unit const& unit, ast::NodeCPtr value) -> bool {
-					if (unit_names.contains(&unit)) {
-						Logger::error("Country ", name, " has duplicate entry for ", unit.get_identifier(), " name list");
-						return false;
-					}
-					return name_list_callback([&unit_names, &unit](std::vector<std::string>&& list) -> bool {
-						return unit_names.emplace(&unit, std::move(list)).second;
-					})(value);
+			game_manager.get_military_manager().get_unit_manager().expect_unit_dictionary_reserve_length(
+				unit_names,
+				[&unit_names](Unit const& unit, ast::NodeCPtr value) -> bool {
+					return name_list_callback(map_callback(unit_names, &unit))(value);
 				}
 			)
 	)(root);
diff --git a/src/openvic-simulation/country/Country.hpp b/src/openvic-simulation/country/Country.hpp
index 76254a2..5f60534 100644
--- a/src/openvic-simulation/country/Country.hpp
+++ b/src/openvic-simulation/country/Country.hpp
@@ -51,7 +51,7 @@ namespace OpenVic {
 	struct Country : HasIdentifierAndColour {
 		friend struct CountryManager;
 
-		using unit_names_map_t = ordered_map<Unit const*, std::vector<std::string>>;
+		using unit_names_map_t = ordered_map<Unit const*, name_list_t>;
 		using government_colour_map_t = ordered_map<GovernmentType const*, colour_t>;
 
 	private:
diff --git a/src/openvic-simulation/dataloader/Dataloader.hpp b/src/openvic-simulation/dataloader/Dataloader.hpp
index 069ccec..de72fcd 100644
--- a/src/openvic-simulation/dataloader/Dataloader.hpp
+++ b/src/openvic-simulation/dataloader/Dataloader.hpp
@@ -2,7 +2,6 @@
 
 #include <openvic-dataloader/csv/Parser.hpp>
 #include <openvic-dataloader/v2script/Parser.hpp>
-#include <unordered_map> //keep this here or mac builds will fail
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 
diff --git a/src/openvic-simulation/dataloader/NodeTools.cpp b/src/openvic-simulation/dataloader/NodeTools.cpp
index 4612f77..957aa01 100644
--- a/src/openvic-simulation/dataloader/NodeTools.cpp
+++ b/src/openvic-simulation/dataloader/NodeTools.cpp
@@ -400,9 +400,9 @@ node_callback_t NodeTools::expect_dictionary_key_map(key_map_t key_map) {
 	);
 }
 
-node_callback_t NodeTools::name_list_callback(callback_t<std::vector<std::string>&&> callback) {
+node_callback_t NodeTools::name_list_callback(callback_t<name_list_t&&> callback) {
 	return [callback](ast::NodeCPtr node) -> bool {
-		std::vector<std::string> list;
+		name_list_t list;
 		bool ret = expect_list_reserve_length(
 			list, expect_identifier_or_string(vector_callback<std::string_view>(list))
 		)(node);
@@ -411,6 +411,17 @@ node_callback_t NodeTools::name_list_callback(callback_t<std::vector<std::string
 	};
 }
 
+std::ostream& OpenVic::operator<<(std::ostream& stream, name_list_t const& name_list) {
+	stream << '[';
+	if (!name_list.empty()) {
+		stream << name_list.front();
+		std::for_each(name_list.begin() + 1, name_list.end(), [&stream](std::string const& name) -> void {
+			stream << ", " << name;
+		});
+	}
+	return stream << ']';
+}
+
 callback_t<std::string_view> NodeTools::assign_variable_callback_string(std::string& var) {
 	return assign_variable_callback_cast<std::string_view>(var);
 }
diff --git a/src/openvic-simulation/dataloader/NodeTools.hpp b/src/openvic-simulation/dataloader/NodeTools.hpp
index 00ba02d..b3fce16 100644
--- a/src/openvic-simulation/dataloader/NodeTools.hpp
+++ b/src/openvic-simulation/dataloader/NodeTools.hpp
@@ -11,6 +11,7 @@
 
 #include "openvic-simulation/types/Colour.hpp"
 #include "openvic-simulation/types/Date.hpp"
+#include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
 #include "openvic-simulation/types/Vector.hpp"
 
@@ -28,6 +29,9 @@ namespace OpenVic {
 	using string_set_t = ordered_set<std::string>;
 	using case_insensitive_string_set_t = case_insensitive_ordered_set<std::string>;
 
+	using name_list_t = std::vector<std::string>;
+	std::ostream& operator<<(std::ostream& stream, name_list_t const& name_list);
+
 	namespace NodeTools {
 
 		template<typename Fn, typename Return = void, typename... Args>
@@ -234,21 +238,22 @@ namespace OpenVic {
 			t.reserve(size_t {});
 		};
 		template<Reservable T>
+		LengthCallback auto reserve_length_callback(T& t) {
+			return [&t](size_t size) -> size_t {
+				t.reserve(size);
+				return size;
+			};
+		}
+		template<Reservable T>
 		NodeCallback auto expect_list_reserve_length(T& t, NodeCallback auto callback) {
-			return expect_list_and_length(
-				[&t](size_t size) -> size_t {
-					t.reserve(t.size() + size);
-					return size;
-				},
-				callback
-			);
+			return expect_list_and_length(reserve_length_callback(t), callback);
 		}
 		template<Reservable T>
 		NodeCallback auto expect_dictionary_reserve_length(T& t, KeyValueCallback auto callback) {
 			return expect_list_reserve_length(t, expect_assign(callback));
 		}
 
-		node_callback_t name_list_callback(callback_t<std::vector<std::string>&&> callback);
+		node_callback_t name_list_callback(callback_t<name_list_t&&> callback);
 
 		template<typename T, class Hash, class KeyEqual>
 		Callback<std::string_view> auto expect_mapped_string(
@@ -351,10 +356,32 @@ namespace OpenVic {
 			};
 		}
 
-		template<typename T, typename...SetArgs>
+		template<typename T, typename U, typename...SetArgs>
+		Callback<T> auto set_callback(tsl::ordered_set<U, SetArgs...>& set) {
+			return [&set](T val) -> bool {
+				if (!set.emplace(std::move(val)).second) {
+					Logger::warning("Duplicate set entry: \"", val, "\"");
+				}
+				return true;
+			};
+		}
+
+		template<std::derived_from<HasIdentifier> T, typename...SetArgs>
 		Callback<T const&> auto set_callback_pointer(tsl::ordered_set<T const*, SetArgs...>& set) {
 			return [&set](T const& val) -> bool {
-				set.insert(&val);
+				if (!set.emplace(&val).second) {
+					Logger::warning("Duplicate set entry: \"", &val, "\"");
+				}
+				return true;
+			};
+		}
+
+		template<std::derived_from<HasIdentifier> Key, typename Value, typename... MapArgs>
+		Callback<Value> auto map_callback(tsl::ordered_map<Key const*, Value, MapArgs...>& map, Key const* key) {
+			return [&map, key](Value value) -> bool {
+				if (!map.emplace(key, std::move(value)).second) {
+					Logger::warning("Duplicate map entry with key: \"", key, "\"");
+				}
 				return true;
 			};
 		}
diff --git a/src/openvic-simulation/diplomacy/DiplomaticAction.cpp b/src/openvic-simulation/diplomacy/DiplomaticAction.cpp
index c1aa3df..d10eda3 100644
--- a/src/openvic-simulation/diplomacy/DiplomaticAction.cpp
+++ b/src/openvic-simulation/diplomacy/DiplomaticAction.cpp
@@ -9,13 +9,12 @@
 using namespace OpenVic;
 
 DiplomaticActionType::DiplomaticActionType(DiplomaticActionType::Initializer&& initializer)
-	: commit_action_caller { std::move(initializer.commit) },
-	  allowed_to_commit { std::move(initializer.allowed) }, get_acceptance { std::move(initializer.get_acceptance) } {}
+  : commit_action_caller { std::move(initializer.commit) },
+	allowed_to_commit { std::move(initializer.allowed) }, get_acceptance { std::move(initializer.get_acceptance) } {}
 
 CancelableDiplomaticActionType::CancelableDiplomaticActionType(CancelableDiplomaticActionType::Initializer&& initializer)
 	: allowed_to_cancel{std::move(initializer.allowed_cancel)}, DiplomaticActionType(std::move(initializer)) {}
 
-
 DiplomaticActionManager::DiplomaticActionManager() {}
 
 bool DiplomaticActionManager::add_diplomatic_action(
@@ -49,7 +48,7 @@ DiplomaticActionTickCache DiplomaticActionManager::create_diplomatic_action_tick
 			result.acceptance = type.get_acceptance(result.argument);
 		}
 	});
-	
+
 	return result;
 }
 
@@ -78,38 +77,38 @@ bool DiplomaticActionManager::setup_diplomatic_actions() {
 		}
 	);
 	result &= add_diplomatic_action(
-		"give_military_access", 
+		"give_military_access",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
-		"increase_relations", 
+		"increase_relations",
 		{
 			.commit = [](Argument& arg) {},
 			.allowed = [](const Argument& arg) { return false; },
 		}
 	);
 	result &= add_diplomatic_action(
-		"decrease_relations", 
+		"decrease_relations",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
-		"war_subsidies", 
+		"war_subsidies",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
-		"declare_war", 
+		"declare_war",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
-		"offer_peace", 
+		"offer_peace",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
-		"command_units", 
+		"command_units",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
-		"discredit", 
+		"discredit",
 		{ [](Argument& arg) {} }
 	);
 	result &= add_diplomatic_action(
diff --git a/src/openvic-simulation/history/CountryHistory.cpp b/src/openvic-simulation/history/CountryHistory.cpp
index 96a0b7c..3b4dfd8 100644
--- a/src/openvic-simulation/history/CountryHistory.cpp
+++ b/src/openvic-simulation/history/CountryHistory.cpp
@@ -1,7 +1,6 @@
 #include "CountryHistory.hpp"
 
 #include "openvic-simulation/GameManager.hpp"
-#include <string_view>
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
@@ -28,22 +27,20 @@ bool CountryHistoryMap::_load_history_entry(
 	DecisionManager const& decision_manager = game_manager.get_decision_manager();
 
 	return expect_dictionary_keys_and_default(
-		[this, &game_manager, &dataloader, &deployment_manager, &issue_manager,
-			&technology_manager, &invention_manager, &country_manager, &entry](std::string_view key, ast::NodeCPtr value) -> bool {
+		[this, &game_manager, &dataloader, &deployment_manager, &issue_manager, &technology_manager, &invention_manager,
+			&country_manager, &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) {
 						Logger::warning(
-							"Listing ", reform.get_identifier(), " as belonging to the reform group ",
-							reform_group->get_identifier(), " when it actually belongs to ",
-							reform.get_reform_group().get_identifier(), " in history of ", entry.get_country().get_identifier()
+							"Listing ", reform.get_identifier(), " as belonging to the reform group ", reform_group,
+							" when it actually belongs to ", reform.get_reform_group(), " in history of ", entry.get_country()
 						);
 					}
 					if (std::find(entry.reforms.begin(), entry.reforms.end(), &reform) != entry.reforms.end()) {
 						Logger::error(
-							"Redefinition of reform ", reform.get_identifier(), " in history of ",
-							entry.get_country().get_identifier()
+							"Redefinition of reform ", reform.get_identifier(), " in history of ", entry.get_country()
 						);
 						return false;
 					}
@@ -55,36 +52,14 @@ bool CountryHistoryMap::_load_history_entry(
 			{
 				Technology const* technology = technology_manager.get_technology_by_identifier(key);
 				if (technology != nullptr) {
-					return expect_int_bool(
-						[&entry, technology](bool flag) -> bool {
-							if (!entry.technologies.emplace(technology, flag).second) {
-								Logger::error(
-									"Duplicate entry for technology ", technology->get_identifier(), " in history of ",
-									entry.get_country().get_identifier(), " at date ", entry.get_date()
-								);
-								return false;
-							}
-							return true;
-						}
-					)(value);
+					return expect_int_bool(map_callback(entry.technologies, technology))(value);
 				}
 			}
 
 			{
 				Invention const* invention = invention_manager.get_invention_by_identifier(key);
 				if (invention != nullptr) {
-					return expect_bool(
-						[&entry, invention](bool flag) -> bool {
-							if (!entry.inventions.emplace(invention, flag).second) {
-								Logger::error(
-									"Duplicate entry for invention ", invention->get_identifier(), " in history of ",
-									entry.get_country().get_identifier(), " at date ", entry.get_date()
-								);
-								return false;
-							}
-							return true;
-						}
-					)(value);
+					return expect_bool(map_callback(entry.inventions, invention))(value);
 				}
 			}
 
@@ -113,12 +88,10 @@ bool CountryHistoryMap::_load_history_entry(
 		"prestige", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.prestige)),
 		"ruling_party", ZERO_OR_ONE, country.expect_party_identifier(assign_variable_callback_pointer(entry.ruling_party)),
 		"last_election", ZERO_OR_ONE, expect_date(assign_variable_callback(entry.last_election)),
-		"upper_house", ZERO_OR_ONE, politics_manager.get_ideology_manager().expect_ideology_dictionary(
+		"upper_house", ZERO_OR_ONE, politics_manager.get_ideology_manager().expect_ideology_dictionary_reserve_length(
+			entry.upper_house,
 			[&entry](Ideology const& ideology, ast::NodeCPtr value) -> bool {
-				return expect_fixed_point([&entry, &ideology](fixed_point_t val) -> bool {
-					entry.upper_house[&ideology] = val;
-					return true;
-				})(value);
+				return expect_fixed_point(map_callback(entry.upper_house, &ideology))(value);
 			}
 		),
 		"oob", ZERO_OR_ONE, expect_identifier_or_string(
@@ -134,9 +107,11 @@ bool CountryHistoryMap::_load_history_entry(
 		"schools", ZERO_OR_ONE, technology_manager.expect_technology_school_identifier(
 			assign_variable_callback_pointer(entry.tech_school)
 		),
-		"foreign_investment", ZERO_OR_ONE, country_manager.expect_country_decimal_map(move_variable_callback(entry.foreign_investment)),
+		"foreign_investment", ZERO_OR_ONE,
+			country_manager.expect_country_decimal_map(move_variable_callback(entry.foreign_investment)),
 		"literacy", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.literacy)),
-		"non_state_culture_literacy", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.nonstate_culture_literacy)),
+		"non_state_culture_literacy", ZERO_OR_ONE,
+			expect_fixed_point(assign_variable_callback(entry.nonstate_culture_literacy)),
 		"consciousness", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.consciousness)),
 		"nonstate_consciousness", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.nonstate_consciousness)),
 		"is_releasable_vassal", ZERO_OR_ONE, expect_bool(assign_variable_callback(entry.releasable_vassal)),
@@ -153,7 +128,7 @@ bool CountryHistoryMap::_load_history_entry(
 						if (flag_expected) {
 							Logger::error(
 								"Government key found when expect flag type override for ", government_type,
-								" in history of ", entry.get_country().get_identifier()
+								" in history of ", entry.get_country()
 							);
 							ret = false;
 						}
@@ -173,22 +148,19 @@ bool CountryHistoryMap::_load_history_entry(
 							/* If the first government type is null, the "government" section will have already output
 							 * an error, so no need to output another one here. */
 							if (government_type != nullptr && flag_override_government_type != nullptr) {
-								ret &= entry.government_flag_overrides.emplace(
-									government_type, flag_override_government_type
-								).second;
+								ret &= map_callback(entry.government_flag_overrides, government_type)(flag_override_government_type);
 							}
 							return ret;
 						} else {
 							Logger::error(
 								"Flag key found when expecting government type for flag type override in history of ",
-								entry.get_country().get_identifier()
+								entry.get_country()
 							);
 							return false;
 						}
 					} else {
 						Logger::error(
-							"Invalid key ", id, " in government flag overrides in history of ",
-							entry.get_country().get_identifier()
+							"Invalid key ", id, " in government flag overrides in history of ", entry.get_country()
 						);
 						return false;
 					}
@@ -196,20 +168,15 @@ bool CountryHistoryMap::_load_history_entry(
 			)(value);
 			if (flag_expected) {
 				Logger::error(
-					"Missing flag type override for government type ", government_type, " in history of ",
-					entry.get_country().get_identifier()
+					"Missing flag type override for government type ", government_type, " in history of ", entry.get_country()
 				);
 				ret = false;
 			}
 			return ret;
 		},
 		"colonial_points", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(entry.colonial_points)),
-		"set_country_flag", ZERO_OR_MORE, expect_identifier_or_string([&entry](std::string_view flag) -> bool {
-			return entry.country_flags.emplace(flag).second;
-		}),
-		"set_global_flag", ZERO_OR_MORE, expect_identifier_or_string([&entry](std::string_view flag) -> bool {
-			return entry.global_flags.emplace(flag).second;
-		})
+		"set_country_flag", ZERO_OR_MORE, expect_identifier_or_string(set_callback<std::string_view>(entry.country_flags)),
+		"set_global_flag", ZERO_OR_MORE, expect_identifier_or_string(set_callback<std::string_view>(entry.global_flags))
 	)(root);
 }
 
@@ -231,7 +198,7 @@ CountryHistoryMap const* CountryHistoryManager::get_country_history(Country cons
 	if (country_registry != country_histories.end()) {
 		return &country_registry->second;
 	} else {
-		Logger::error("Attempted to access history of country ", country->get_identifier(), " but none has been defined!");
+		Logger::error("Attempted to access history of country ", country, " but none has been defined!");
 		return nullptr;
 	}
 }
@@ -240,10 +207,7 @@ bool CountryHistoryManager::load_country_history_file(
 	GameManager& game_manager, Dataloader const& dataloader, Country const& country, ast::NodeCPtr root
 ) {
 	if (locked) {
-		Logger::error(
-			"Attempted to load country history file for ", country.get_identifier(),
-			" after country history registry was locked!"
-		);
+		Logger::error("Attempted to load country history file for ", country, " after country history registry was locked!");
 		return false;
 	}
 
@@ -258,7 +222,7 @@ bool CountryHistoryManager::load_country_history_file(
 		if (result.second) {
 			it = result.first;
 		} else {
-			Logger::error("Failed to create country history map for country ", country.get_identifier());
+			Logger::error("Failed to create country history map for country ", country);
 			return false;
 		}
 	}
diff --git a/src/openvic-simulation/history/ProvinceHistory.cpp b/src/openvic-simulation/history/ProvinceHistory.cpp
index f5e5187..4117450 100644
--- a/src/openvic-simulation/history/ProvinceHistory.cpp
+++ b/src/openvic-simulation/history/ProvinceHistory.cpp
@@ -35,10 +35,15 @@ bool ProvinceHistoryMap::_load_history_entry(
 			// used for province buildings like forts or railroads
 			BuildingType const* building_type = building_type_manager.get_building_type_by_identifier(key);
 			if (building_type != nullptr) {
-				return expect_uint<BuildingType::level_t>([&entry, building_type](BuildingType::level_t level) -> bool {
-					entry.province_buildings[building_type] = level;
-					return true;
-				})(value);
+				if (building_type->is_in_province()) {
+					return expect_uint<BuildingType::level_t>(map_callback(entry.province_buildings, building_type))(value);
+				} else {
+					Logger::error(
+						"Attempted to add state building \"", building_type, "\" at top scope of province history for ",
+						entry.get_province()
+					);
+					return false;
+				}
 			}
 
 			return _load_history_sub_entry_callback(game_manager, entry.get_date(), value, key, value);
@@ -65,27 +70,39 @@ bool ProvinceHistoryMap::_load_history_entry(
 			Ideology const* ideology = nullptr;
 			fixed_point_t amount = 0; // percent I do believe
 
-			const bool ret = expect_dictionary_keys(
+			bool ret = expect_dictionary_keys(
 				"ideology", ONE_EXACTLY, ideology_manager.expect_ideology_identifier(
 					assign_variable_callback_pointer(ideology)
 				),
 				"loyalty_value", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(amount))
 			)(node);
-			entry.party_loyalties[ideology] = amount;
+			if (ideology != nullptr) {
+				ret &= map_callback(entry.party_loyalties, ideology)(amount);
+			}
 			return ret;
 		},
 		"state_building", ZERO_OR_MORE, [&building_type_manager, &entry](ast::NodeCPtr node) -> bool {
 			BuildingType const* building_type = nullptr;
 			uint8_t level = 0;
 
-			const bool ret = expect_dictionary_keys(
+			bool ret = expect_dictionary_keys(
 				"level", ONE_EXACTLY, expect_uint(assign_variable_callback(level)),
 				"building", ONE_EXACTLY, building_type_manager.expect_building_type_identifier(
 					assign_variable_callback_pointer(building_type)
 				),
 				"upgrade", ZERO_OR_ONE, success_callback // doesn't appear to have an effect
 			)(node);
-			entry.state_buildings[building_type] = level;
+			if (building_type != nullptr) {
+				if (!building_type->is_in_province()) {
+					ret &= map_callback(entry.state_buildings, building_type)(level);
+				} else {
+					Logger::error(
+						"Attempted to add province building \"", building_type, "\" to state building list of province history for ",
+						entry.get_province()
+					);
+					ret = false;
+				}
+			}
 			return ret;
 		}
 	)(root);
@@ -174,7 +191,8 @@ bool ProvinceHistoryEntry::_load_province_pop_history(
 ) {
 	PopManager const& pop_manager = game_manager.get_pop_manager();
 	RebelManager const& rebel_manager = game_manager.get_politics_manager().get_rebel_manager();
-	return pop_manager.expect_pop_type_dictionary(
+	return pop_manager.expect_pop_type_dictionary_reserve_length(
+		pops,
 		[this, &pop_manager, &rebel_manager, non_integer_size](PopType const& pop_type, ast::NodeCPtr pop_node) -> bool {
 			return pop_manager.load_pop_into_vector(rebel_manager, pops, pop_type, pop_node, non_integer_size);
 		}
diff --git a/src/openvic-simulation/map/Map.cpp b/src/openvic-simulation/map/Map.cpp
index 27079f4..1415e2c 100644
--- a/src/openvic-simulation/map/Map.cpp
+++ b/src/openvic-simulation/map/Map.cpp
@@ -893,6 +893,8 @@ bool Map::load_continent_file(ModifierManager const& modifier_manager, ast::Node
 				[&prov_list](Province const& province) -> bool {
 					if (province.continent == nullptr) {
 						prov_list.emplace_back(&province);
+					} else {
+						Logger::warning("Province ", province, " found in multiple continents");
 					}
 					return true;
 				}
diff --git a/src/openvic-simulation/map/Province.cpp b/src/openvic-simulation/map/Province.cpp
index 1c3c76f..acabbf8 100644
--- a/src/openvic-simulation/map/Province.cpp
+++ b/src/openvic-simulation/map/Province.cpp
@@ -36,12 +36,10 @@ bool Province::load_positions(BuildingTypeManager const& building_type_manager,
 		"factory", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.factory)),
 		"building_construction", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.building_construction)),
 		"military_construction", ZERO_OR_ONE, expect_fvec2(assign_variable_callback(positions.military_construction)),
-		"building_position", ZERO_OR_ONE, building_type_manager.expect_building_type_dictionary(
+		"building_position", ZERO_OR_ONE, building_type_manager.expect_building_type_dictionary_reserve_length(
+			positions.building_position,
 			[this](BuildingType const& type, ast::NodeCPtr value) -> bool {
-				return expect_fvec2([this, &type](fvec2_t position) -> bool {
-					positions.building_position.emplace(&type, std::move(position));
-					return true;
-				})(value);
+				return expect_fvec2(map_callback(positions.building_position, &type))(value);
 			}
 		),
 		"building_rotation", ZERO_OR_ONE, building_type_manager.expect_building_type_decimal_map(
diff --git a/src/openvic-simulation/military/Wargoal.cpp b/src/openvic-simulation/military/Wargoal.cpp
index 174cd09..6351ce3 100644
--- a/src/openvic-simulation/military/Wargoal.cpp
+++ b/src/openvic-simulation/military/Wargoal.cpp
@@ -122,10 +122,15 @@ bool WargoalTypeManager::load_wargoal_file(ast::NodeCPtr root) {
 					};
 					const decltype(peace_modifier_map)::const_iterator it = peace_modifier_map.find(key);
 					if (it != peace_modifier_map.end()) {
-						return expect_fixed_point([&modifiers, peace_modifier = it->second](fixed_point_t val) -> bool {
-							modifiers[peace_modifier] = val;
-							return true;
-						})(value);
+						return expect_fixed_point(
+							[&modifiers, &identifier, &key, peace_modifier = it->second](fixed_point_t val) -> bool {
+								if (modifiers.emplace(peace_modifier, val).second) {
+									return true;
+								}
+								Logger::error("Duplicate peace modifier ", key, " in wargoal ", identifier, "!");
+								return false;
+							}
+						)(value);
 					}
 
 					Logger::error("Modifier ", key, " in wargoal ", identifier, " is invalid.");
diff --git a/src/openvic-simulation/misc/Event.cpp b/src/openvic-simulation/misc/Event.cpp
index eb5f7da..d6750c1 100644
--- a/src/openvic-simulation/misc/Event.cpp
+++ b/src/openvic-simulation/misc/Event.cpp
@@ -196,7 +196,9 @@ bool EventManager::load_event_file(IssueManager const& issue_manager, ast::NodeC
 bool EventManager::load_on_action_file(ast::NodeCPtr root) {
 	bool ret = expect_dictionary([this](std::string_view identifier, ast::NodeCPtr node) -> bool {
 		OnAction::weight_map_t weighted_events;
-		bool ret = expect_dictionary([this, &identifier, &weighted_events](std::string_view weight_str, ast::NodeCPtr event_node) -> bool {
+		bool ret = expect_dictionary_reserve_length(
+			weighted_events,
+			[this, &identifier, &weighted_events](std::string_view weight_str, ast::NodeCPtr event_node) -> bool {
 				bool ret = false;
 				uint64_t weight = StringUtils::string_to_uint64(weight_str, &ret);
 				if (!ret) {
@@ -208,7 +210,7 @@ bool EventManager::load_on_action_file(ast::NodeCPtr root) {
 				ret &= expect_event_identifier(assign_variable_callback_pointer(event))(event_node);
 
 				if (event != nullptr) {
-					ret &= weighted_events.emplace(event, weight).second;
+					ret &= map_callback(weighted_events, event)(weight);
 				} else {
 					Logger::warning(
 						"Non-existing event ", event->get_identifier(), " loaded on action ", identifier, "with weight",
diff --git a/src/openvic-simulation/misc/Modifier.cpp b/src/openvic-simulation/misc/Modifier.cpp
index c83fcf0..2d95f0d 100644
--- a/src/openvic-simulation/misc/Modifier.cpp
+++ b/src/openvic-simulation/misc/Modifier.cpp
@@ -372,12 +372,7 @@ key_value_callback_t ModifierManager::_modifier_effect_callback(
 ) const {
 	const auto add_modifier_cb = [this, &modifier, effect_validator](ModifierEffect const* effect, ast::NodeCPtr value) -> bool {
 		if (effect_validator(*effect)) {
-			if (!modifier.values.contains(effect)) {
-				return expect_fixed_point(assign_variable_callback(modifier.values[effect]))(value);
-			} else {
-				Logger::error("Duplicate modifier effect: ", effect->get_identifier());
-				return false;
-			}
+			return expect_fixed_point(map_callback(modifier.values, effect))(value);
 		} else {
 			Logger::error("Failed to validate modifier effect: ", effect->get_identifier());
 			return false;
@@ -424,7 +419,10 @@ node_callback_t ModifierManager::expect_validated_modifier_value_and_default(
 ) const {
 	return [this, modifier_callback, default_callback, effect_validator](ast::NodeCPtr root) -> bool {
 		ModifierValue modifier;
-		bool ret = expect_dictionary(_modifier_effect_callback(modifier, default_callback, effect_validator))(root);
+		bool ret = expect_dictionary_reserve_length(
+			modifier.values,
+			_modifier_effect_callback(modifier, default_callback, effect_validator)
+		)(root);
 		ret &= modifier_callback(std::move(modifier));
 		return ret;
 	};
diff --git a/src/openvic-simulation/politics/NationalFocus.cpp b/src/openvic-simulation/politics/NationalFocus.cpp
index e509039..c2084be 100644
--- a/src/openvic-simulation/politics/NationalFocus.cpp
+++ b/src/openvic-simulation/politics/NationalFocus.cpp
@@ -11,16 +11,18 @@ NationalFocus::NationalFocus(
 	NationalFocusGroup const& new_group,
 	ModifierValue&& new_modifiers,
 	pop_promotion_map_t&& new_encouraged_promotion,
-	party_loyalty_map_t&& new_encouraged_loyalty,
 	production_map_t&& new_encouraged_production,
+	Ideology const* new_loyalty_ideology,
+	fixed_point_t new_loyalty_value,
 	ConditionScript&& new_limit
 ) : HasIdentifier { new_identifier },
 	icon { new_icon },
 	group { new_group },
 	modifiers { std::move(new_modifiers) },
 	encouraged_promotion { std::move(new_encouraged_promotion) },
-	encouraged_loyalty { std::move(new_encouraged_loyalty) },
 	encouraged_production { std::move(new_encouraged_production) },
+	loyalty_ideology { new_loyalty_ideology },
+	loyalty_value { new_loyalty_value },
 	limit { std::move(new_limit) } {}
 
 bool NationalFocus::parse_scripts(GameManager const& game_manager) {
@@ -41,8 +43,9 @@ inline bool NationalFocusManager::add_national_focus(
 	NationalFocusGroup const& group,
 	ModifierValue&& modifiers,
 	NationalFocus::pop_promotion_map_t&& encouraged_promotion,
-	NationalFocus::party_loyalty_map_t&& encouraged_loyalty,
 	NationalFocus::production_map_t&& encouraged_production,
+	Ideology const* loyalty_ideology,
+	fixed_point_t loyalty_value,
 	ConditionScript&& limit
 ) {
 	if (identifier.empty()) {
@@ -53,74 +56,79 @@ inline bool NationalFocusManager::add_national_focus(
 		Logger::error("Invalid icon ", icon, " for national focus ", identifier);
 		return false;
 	}
+	if ((loyalty_ideology == nullptr) != (loyalty_value == 0)) {
+		Logger::warning(
+			"Party loyalty incorrectly defined for national focus ", identifier, ": ideology = ", loyalty_ideology,
+			", value = ", loyalty_value
+		);
+	}
 	return national_foci.add_item({
-		identifier, icon, group, std::move(modifiers), std::move(encouraged_promotion), std::move(encouraged_loyalty),
-		std::move(encouraged_production), std::move(limit)
+		identifier, icon, group, std::move(modifiers), std::move(encouraged_promotion), std::move(encouraged_production),
+		loyalty_ideology, loyalty_value, std::move(limit)
 	});
 }
 
-bool NationalFocusManager::load_national_foci_file(PopManager const& pop_manager, IdeologyManager const& ideology_manager, GoodManager const& good_manager, ModifierManager const& modifier_manager, ast::NodeCPtr root) {
-	bool ret = expect_dictionary_reserve_length(national_focus_groups, [this](std::string_view identifier, ast::NodeCPtr node) -> bool {
-		return add_national_focus_group(identifier);
-	})(root);
+bool NationalFocusManager::load_national_foci_file(
+	PopManager const& pop_manager, IdeologyManager const& ideology_manager, GoodManager const& good_manager,
+	ModifierManager const& modifier_manager, ast::NodeCPtr root
+) {
+	size_t expected_national_foci = 0;
+	bool ret = expect_dictionary_reserve_length(
+		national_focus_groups,
+		[this, &expected_national_foci](std::string_view identifier, ast::NodeCPtr node) -> bool {
+			return expect_length(add_variable_callback(expected_national_foci))(node) & add_national_focus_group(identifier);
+		}
+	)(root);
 	lock_national_focus_groups();
 
-	ret &= expect_national_focus_group_dictionary([this, &pop_manager, &ideology_manager, &good_manager, &modifier_manager](NationalFocusGroup const& group, ast::NodeCPtr node) -> bool {
-		bool ret = expect_dictionary([this, &group, &pop_manager, &ideology_manager, &good_manager, &modifier_manager](std::string_view identifier, ast::NodeCPtr node) -> bool {
-			uint8_t icon;
+	national_foci.reserve(expected_national_foci);
+
+	ret &= expect_national_focus_group_dictionary([this, &pop_manager, &ideology_manager, &good_manager, &modifier_manager](
+		NationalFocusGroup const& group, ast::NodeCPtr group_node
+	) -> bool {
+		return expect_dictionary([this, &group, &pop_manager, &ideology_manager, &good_manager, &modifier_manager](
+			std::string_view identifier, ast::NodeCPtr node
+		) -> bool {
+			uint8_t icon = 0;
 			ModifierValue modifiers;
 			NationalFocus::pop_promotion_map_t promotions;
-			NationalFocus::party_loyalty_map_t loyalties;
 			NationalFocus::production_map_t production;
+			Ideology const* loyalty_ideology = nullptr;
+			fixed_point_t loyalty_value = 0;
 			ConditionScript limit { scope_t::PROVINCE | scope_t::COUNTRY, scope_t::PROVINCE | scope_t::COUNTRY, scope_t::NO_SCOPE };
 
-			Ideology const* last_specified_ideology = nullptr; // weird, I know
-
 			bool ret = modifier_manager.expect_modifier_value_and_keys_and_default(
 				move_variable_callback(modifiers),
-				[&promotions, &pop_manager, &production, &good_manager, &modifiers, &modifier_manager](std::string_view key, ast::NodeCPtr value) -> bool {
+				[&promotions, &pop_manager, &production, &good_manager, &modifiers, &modifier_manager](
+					std::string_view key, ast::NodeCPtr value
+				) -> bool {
 					PopType const* pop_type = pop_manager.get_pop_type_by_identifier(key);
 					if (pop_type != nullptr) {
-						fixed_point_t boost;
-						bool ret = expect_fixed_point(assign_variable_callback(boost))(value);
-						promotions[pop_type] = boost;
-						return ret;
+						return expect_fixed_point(map_callback(promotions, pop_type))(value);
 					}
 					Good const* good = good_manager.get_good_by_identifier(key);
 					if (good != nullptr) {
-						fixed_point_t boost;
-						bool ret = expect_fixed_point(assign_variable_callback(boost))(value);
-						production[good] = boost;
-						return ret;
+						return expect_fixed_point(map_callback(production, good))(value);
 					}
 					return key_value_invalid_callback(key, value);
 				},
 				"icon", ONE_EXACTLY, expect_uint(assign_variable_callback(icon)),
-				"ideology", ZERO_OR_MORE, ideology_manager.expect_ideology_identifier(assign_variable_callback_pointer(last_specified_ideology)),
-				"loyalty_value", ZERO_OR_MORE, [&identifier, &last_specified_ideology, &loyalties](ast::NodeCPtr value) -> bool {
-					if (last_specified_ideology == nullptr) {
-						Logger::error("In national focus ", identifier, ": No ideology selected for loyalty_value!");
-						return false;
-					}
-					fixed_point_t boost;
-					bool ret = expect_fixed_point(assign_variable_callback(boost))(value);
-					loyalties[last_specified_ideology] += boost;
-					return ret;
-				},
+				"ideology", ZERO_OR_ONE,
+					ideology_manager.expect_ideology_identifier(assign_variable_callback_pointer(loyalty_ideology)),
+				"loyalty_value", ZERO_OR_ONE, expect_fixed_point(assign_variable_callback(loyalty_value)),
 				"limit", ZERO_OR_ONE, limit.expect_script(),
 				"has_flashpoint", ZERO_OR_ONE, success_callback, // special case, include in limit
 				"own_provinces", ZERO_OR_ONE, success_callback, // special case, include in limit
 				"outliner_show_as_percent", ZERO_OR_ONE, success_callback // special case
 			)(node);
 
-			add_national_focus(
-				identifier, icon, group, std::move(modifiers), std::move(promotions), std::move(loyalties),
-				std::move(production), std::move(limit)
+			ret &= add_national_focus(
+				identifier, icon, group, std::move(modifiers), std::move(promotions), std::move(production),
+				loyalty_ideology, loyalty_value, std::move(limit)
 			);
 
 			return ret;
-		})(node);
-		return ret;
+		})(group_node);
 	})(root);
 	lock_national_foci();
 
diff --git a/src/openvic-simulation/politics/NationalFocus.hpp b/src/openvic-simulation/politics/NationalFocus.hpp
index 44e58e3..6e064f1 100644
--- a/src/openvic-simulation/politics/NationalFocus.hpp
+++ b/src/openvic-simulation/politics/NationalFocus.hpp
@@ -23,7 +23,6 @@ namespace OpenVic {
 
 	public:
 		using pop_promotion_map_t = fixed_point_map_t<PopType const*>;
-		using party_loyalty_map_t = fixed_point_map_t<Ideology const*>;
 		using production_map_t = fixed_point_map_t<Good const*>;
 
 	private:
@@ -31,8 +30,9 @@ namespace OpenVic {
 		NationalFocusGroup const& PROPERTY(group);
 		ModifierValue PROPERTY(modifiers);
 		pop_promotion_map_t PROPERTY(encouraged_promotion);
-		party_loyalty_map_t PROPERTY(encouraged_loyalty);
 		production_map_t PROPERTY(encouraged_production);
+		Ideology const* PROPERTY(loyalty_ideology);
+		fixed_point_t PROPERTY(loyalty_value);
 		ConditionScript PROPERTY(limit);
 
 		NationalFocus(
@@ -41,8 +41,9 @@ namespace OpenVic {
 			NationalFocusGroup const& new_group,
 			ModifierValue&& new_modifiers,
 			pop_promotion_map_t&& new_encouraged_promotion,
-			party_loyalty_map_t&& new_encouraged_loyalty,
 			production_map_t&& new_encouraged_production,
+			Ideology const* new_loyalty_ideology,
+			fixed_point_t new_loyalty_value,
 			ConditionScript&& new_limit
 		);
 
@@ -66,8 +67,9 @@ namespace OpenVic {
 			NationalFocusGroup const& group,
 			ModifierValue&& modifiers,
 			NationalFocus::pop_promotion_map_t&& encouraged_promotion,
-			NationalFocus::party_loyalty_map_t&& encouraged_loyalty,
 			NationalFocus::production_map_t&& encouraged_production,
+			Ideology const* loyalty_ideology,
+			fixed_point_t loyalty_value,
 			ConditionScript&& limit
 		);
 
diff --git a/src/openvic-simulation/politics/Rebel.cpp b/src/openvic-simulation/politics/Rebel.cpp
index 6370786..f86bb51 100644
--- a/src/openvic-simulation/politics/Rebel.cpp
+++ b/src/openvic-simulation/politics/Rebel.cpp
@@ -115,17 +115,14 @@ bool RebelManager::load_rebels_file(
 				"icon", ONE_EXACTLY, expect_uint(assign_variable_callback(icon)),
 				"area", ONE_EXACTLY, expect_identifier(expect_mapped_string(area_map, assign_variable_callback(area))),
 				"break_alliance_on_win", ZERO_OR_ONE, expect_bool(assign_variable_callback(break_alliance_on_win)),
-				"government", ONE_EXACTLY, government_type_manager.expect_government_type_dictionary(
-					[this, &government_type_manager, &desired_governments](GovernmentType const& from,
-						ast::NodeCPtr value) -> bool {
-						if (desired_governments.contains(&from)) {
-							Logger::error("Duplicate \"from\" government type in rebel type: ", from.get_identifier());
-							return false;
-						}
+				"government", ONE_EXACTLY, government_type_manager.expect_government_type_dictionary_reserve_length(
+					desired_governments,
+					[this, &government_type_manager, &desired_governments](
+						GovernmentType const& from, ast::NodeCPtr value
+					) -> bool {
 						return government_type_manager.expect_government_type_identifier(
 							[&desired_governments, &from](GovernmentType const& to) -> bool {
-								desired_governments.emplace(&from, &to);
-								return true;
+								return map_callback(desired_governments, &from)(&to);
 							}
 						)(value);
 					}
diff --git a/src/openvic-simulation/politics/Rule.cpp b/src/openvic-simulation/politics/Rule.cpp
index 9ac992a..19e92af 100644
--- a/src/openvic-simulation/politics/Rule.cpp
+++ b/src/openvic-simulation/politics/Rule.cpp
@@ -109,8 +109,8 @@ bool RuleSet::set_rule(Rule const* rule, bool value) {
 		Logger::error("Invalid rule - null!");
 		return false;
 	}
-	rule_map_t& rule_map = rule_groups[rule->get_group()];
-	return rule_groups[rule->get_group()].emplace(rule, value).second;
+	rule_groups[rule->get_group()][rule] = value;
+	return true;
 }
 
 RuleSet& RuleSet::operator|=(RuleSet const& right) {
@@ -193,10 +193,9 @@ node_callback_t RuleManager::expect_rule_set(callback_t<RuleSet&&> ruleset_callb
 				if (rule != nullptr) {
 					return expect_bool(
 						[&ruleset, rule](bool value) -> bool {
-							if (!ruleset.rule_groups[rule->get_group()].emplace(rule, value).second) {
-								Logger::warning("Duplicate rule entry: ", rule, " - ignoring!");
-							}
-							return true;
+							/* Wrapped in a lambda function so that the rule group is only initialised
+							 * if the value bool is successfully parsed. */
+							return map_callback(ruleset.rule_groups[rule->get_group()], rule)(value);
 						}
 					)(rule_value);
 				} else {
diff --git a/src/openvic-simulation/pop/Culture.cpp b/src/openvic-simulation/pop/Culture.cpp
index 9b9d6c2..2cd6005 100644
--- a/src/openvic-simulation/pop/Culture.cpp
+++ b/src/openvic-simulation/pop/Culture.cpp
@@ -16,7 +16,7 @@ CultureGroup::CultureGroup(
 
 Culture::Culture(
 	std::string_view new_identifier, colour_t new_colour, CultureGroup const& new_group,
-	std::vector<std::string>&& new_first_names, std::vector<std::string>&& new_last_names
+	name_list_t&& new_first_names, name_list_t&& new_last_names
 ) : HasIdentifierAndColour { new_identifier, new_colour, false }, group { new_group },
 	first_names { std::move(new_first_names) }, last_names { std::move(new_last_names) } {}
 
@@ -51,8 +51,8 @@ bool CultureManager::add_culture_group(
 }
 
 bool CultureManager::add_culture(
-	std::string_view identifier, colour_t colour, CultureGroup const& group, std::vector<std::string>&& first_names,
-	std::vector<std::string>&& last_names
+	std::string_view identifier, colour_t colour, CultureGroup const& group, name_list_t&& first_names,
+	name_list_t&& last_names
 ) {
 	if (!culture_groups.is_locked()) {
 		Logger::error("Cannot register cultures until culture groups are locked!");
@@ -99,7 +99,7 @@ bool CultureManager::_load_culture(
 ) {
 
 	colour_t colour = colour_t::null();
-	std::vector<std::string> first_names, last_names;
+	name_list_t first_names, last_names;
 
 	bool ret = expect_dictionary_keys(
 		"color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)),
diff --git a/src/openvic-simulation/pop/Culture.hpp b/src/openvic-simulation/pop/Culture.hpp
index 1c6b75f..c8dfe7a 100644
--- a/src/openvic-simulation/pop/Culture.hpp
+++ b/src/openvic-simulation/pop/Culture.hpp
@@ -40,14 +40,14 @@ namespace OpenVic {
 
 	private:
 		CultureGroup const& PROPERTY(group);
-		const std::vector<std::string> PROPERTY(first_names);
-		const std::vector<std::string> PROPERTY(last_names);
+		const name_list_t PROPERTY(first_names);
+		const name_list_t PROPERTY(last_names);
 
 		// TODO - radicalism, primary tag
 
 		Culture(
 			std::string_view new_identifier, colour_t new_colour, CultureGroup const& new_group,
-			std::vector<std::string>&& new_first_names, std::vector<std::string>&& new_last_names
+			name_list_t&& new_first_names, name_list_t&& new_last_names
 		);
 
 	public:
@@ -75,8 +75,8 @@ namespace OpenVic {
 		);
 
 		bool add_culture(
-			std::string_view identifier, colour_t colour, CultureGroup const& group, std::vector<std::string>&& first_names,
-			std::vector<std::string>&& last_names
+			std::string_view identifier, colour_t colour, CultureGroup const& group, name_list_t&& first_names,
+			name_list_t&& last_names
 		);
 
 		bool load_graphical_culture_type_file(ast::NodeCPtr root);
diff --git a/src/openvic-simulation/pop/Pop.cpp b/src/openvic-simulation/pop/Pop.cpp
index ce310e1..0c70842 100644
--- a/src/openvic-simulation/pop/Pop.cpp
+++ b/src/openvic-simulation/pop/Pop.cpp
@@ -194,14 +194,12 @@ bool PopManager::load_pop_type_file(
 		"country_migration_target", ZERO_OR_ONE, country_migration_target.expect_conditional_weight(ConditionalWeight::FACTOR),
 		"migration_target", ZERO_OR_ONE, migration_target.expect_conditional_weight(ConditionalWeight::FACTOR),
 		"promote_to", ZERO_OR_ONE, assign_variable_callback(promote_to_node),
-		"ideologies", ZERO_OR_ONE, ideology_manager.expect_ideology_dictionary(
+		"ideologies", ZERO_OR_ONE, ideology_manager.expect_ideology_dictionary_reserve_length(
+			ideologies,
 			[&filestem, &ideologies](Ideology const& ideology, ast::NodeCPtr node) -> bool {
 				ConditionalWeight weight { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
 				bool ret = weight.expect_conditional_weight(ConditionalWeight::FACTOR)(node);
-				if (!ideologies.emplace(&ideology, std::move(weight)).second) {
-					Logger::error("Duplicate ideology in pop type ", filestem, " ideology weights: ", ideology);
-					ret = false;
-				}
+				ret &= map_callback(ideologies, &ideology)(std::move(weight));
 				return ret;
 			}
 		),
@@ -233,7 +231,8 @@ bool PopManager::load_delayed_parse_pop_type_data(IssueManager const& issue_mana
 	for (size_t index = 0; index < delayed_parse_promote_to_and_issues_nodes.size(); ++index) {
 		const auto [promote_to_node, issues_node] = delayed_parse_promote_to_and_issues_nodes[index];
 		PopType* pop_type = pop_types.get_item_by_index(index);
-		if (promote_to_node != nullptr && !expect_pop_type_dictionary(
+		if (promote_to_node != nullptr && !expect_pop_type_dictionary_reserve_length(
+			pop_type->promote_to,
 			[pop_type](PopType const& type, ast::NodeCPtr node) -> bool {
 				if (pop_type == &type) {
 					Logger::error("Pop type ", type, " cannot have promotion weight to itself!");
@@ -241,17 +240,15 @@ bool PopManager::load_delayed_parse_pop_type_data(IssueManager const& issue_mana
 				}
 				ConditionalWeight weight { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
 				bool ret = weight.expect_conditional_weight(ConditionalWeight::FACTOR)(node);
-				if (!pop_type->promote_to.emplace(&type, std::move(weight)).second) {
-					Logger::error("Duplicate pop type in pop type ", pop_type, " promotion weights: ", type);
-					ret = false;
-				}
+				ret &= map_callback(pop_type->promote_to, &type)(std::move(weight));
 				return ret;
 			}
 		)(promote_to_node)) {
 			Logger::error("Errors parsing pop type ", pop_type, " promotion weights!");
 			ret = false;
 		}
-		if (issues_node != nullptr && !expect_dictionary(
+		if (issues_node != nullptr && !expect_dictionary_reserve_length(
+			pop_type->issues,
 			[pop_type, &issue_manager](std::string_view key, ast::NodeCPtr node) -> bool {
 				Issue const* issue = issue_manager.get_issue_by_identifier(key);
 				if (issue == nullptr) {
@@ -263,10 +260,7 @@ bool PopManager::load_delayed_parse_pop_type_data(IssueManager const& issue_mana
 				}
 				ConditionalWeight weight { scope_t::POP, scope_t::POP, scope_t::NO_SCOPE };
 				bool ret = weight.expect_conditional_weight(ConditionalWeight::FACTOR)(node);
-				if (!pop_type->issues.emplace(issue, std::move(weight)).second) {
-					Logger::error("Duplicate issue in pop type ", pop_type, " issue weights: ", issue->get_identifier());
-					ret = false;
-				}
+				ret &= map_callback(pop_type->issues, issue)(std::move(weight));
 				return ret;
 			}
 		)(issues_node)) {
diff --git a/src/openvic-simulation/scripts/Condition.cpp b/src/openvic-simulation/scripts/Condition.cpp
index 73b3606..ce18824 100644
--- a/src/openvic-simulation/scripts/Condition.cpp
+++ b/src/openvic-simulation/scripts/Condition.cpp
@@ -721,7 +721,7 @@ node_callback_t ConditionManager::expect_condition_node_list(
 		};
 
 		bool ret = conditions.expect_item_dictionary_and_default(
-			expect_node, top_scope ? top_scope_fallback : key_value_invalid_callback
+			top_scope ? top_scope_fallback : key_value_invalid_callback, expect_node
 		)(node);
 		if (!ret) {
 			Logger::error("Error parsing condition node:\n", node);
diff --git a/src/openvic-simulation/types/HasIdentifier.hpp b/src/openvic-simulation/types/HasIdentifier.hpp
new file mode 100644
index 0000000..9457e75
--- /dev/null
+++ b/src/openvic-simulation/types/HasIdentifier.hpp
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <ostream>
+
+#include "openvic-simulation/types/Colour.hpp"
+#include "openvic-simulation/utility/Getters.hpp"
+
+namespace OpenVic {
+	constexpr bool valid_basic_identifier_char(char c) {
+		return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9') || c == '_';
+	}
+	constexpr bool valid_basic_identifier(std::string_view identifier) {
+		return std::all_of(identifier.begin(), identifier.end(), valid_basic_identifier_char);
+	}
+	constexpr std::string_view extract_basic_identifier_prefix(std::string_view identifier) {
+		size_t len = 0;
+		while (len < identifier.size() && valid_basic_identifier_char(identifier[len])) {
+			++len;
+		}
+		return { identifier.data(), len };
+	}
+
+	/*
+	 * Base class for objects with a non-empty string identifier. Uniquely named instances of a type derived from this class
+	 * can be entered into an IdentifierRegistry instance.
+	 */
+	class HasIdentifier {
+		const std::string PROPERTY(identifier);
+
+	protected:
+		HasIdentifier(std::string_view new_identifier): identifier { new_identifier } {
+			assert(!identifier.empty());
+		}
+
+	public:
+		HasIdentifier(HasIdentifier const&) = delete;
+		HasIdentifier(HasIdentifier&&) = default;
+		HasIdentifier& operator=(HasIdentifier const&) = delete;
+		HasIdentifier& operator=(HasIdentifier&&) = delete;
+	};
+
+	inline std::ostream& operator<<(std::ostream& stream, HasIdentifier const& obj) {
+		return stream << obj.get_identifier();
+	}
+	inline std::ostream& operator<<(std::ostream& stream, HasIdentifier const* obj) {
+		return obj != nullptr ? stream << *obj : stream << "<NULL>";
+	}
+
+	/*
+	 * Base class for objects with associated colour information.
+	 */
+	template<IsColour ColourT>
+	class _HasColour {
+		const ColourT PROPERTY(colour);
+
+	protected:
+		_HasColour(ColourT new_colour, bool cannot_be_null): colour { new_colour } {
+			assert(!cannot_be_null || !colour.is_null());
+		}
+
+	public:
+		_HasColour(_HasColour const&) = delete;
+		_HasColour(_HasColour&&) = default;
+		_HasColour& operator=(_HasColour const&) = delete;
+		_HasColour& operator=(_HasColour&&) = delete;
+	};
+
+	/*
+	 * Base class for objects with a unique string identifier and associated colour information.
+	 */
+	template<IsColour ColourT>
+	class _HasIdentifierAndColour : public HasIdentifier, public _HasColour<ColourT> {
+	protected:
+		_HasIdentifierAndColour(std::string_view new_identifier, ColourT new_colour, bool cannot_be_null)
+			: HasIdentifier { new_identifier }, _HasColour<ColourT> { new_colour, cannot_be_null } {}
+
+	public:
+		_HasIdentifierAndColour(_HasIdentifierAndColour const&) = delete;
+		_HasIdentifierAndColour(_HasIdentifierAndColour&&) = default;
+		_HasIdentifierAndColour& operator=(_HasIdentifierAndColour const&) = delete;
+		_HasIdentifierAndColour& operator=(_HasIdentifierAndColour&&) = delete;
+	};
+
+	using HasIdentifierAndColour = _HasIdentifierAndColour<colour_t>;
+	using HasIdentifierAndAlphaColour = _HasIdentifierAndColour<colour_argb_t>;
+}
diff --git a/src/openvic-simulation/types/IdentifierRegistry.hpp b/src/openvic-simulation/types/IdentifierRegistry.hpp
index 53a68a5..04198b0 100644
--- a/src/openvic-simulation/types/IdentifierRegistry.hpp
+++ b/src/openvic-simulation/types/IdentifierRegistry.hpp
@@ -1,93 +1,14 @@
 #pragma once
 
-#include <cassert>
 #include <vector>
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
+#include "openvic-simulation/types/HasIdentifier.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 namespace OpenVic {
-
-	constexpr bool valid_basic_identifier_char(char c) {
-		return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9') || c == '_';
-	}
-	constexpr bool valid_basic_identifier(std::string_view identifier) {
-		return std::all_of(identifier.begin(), identifier.end(), valid_basic_identifier_char);
-	}
-	constexpr std::string_view extract_basic_identifier_prefix(std::string_view identifier) {
-		size_t len = 0;
-		while (len < identifier.size() && valid_basic_identifier_char(identifier[len])) {
-			++len;
-		}
-		return { identifier.data(), len };
-	}
-
-	/*
-	 * Base class for objects with a non-empty string identifier. Uniquely named instances of a type derived from this class
-	 * can be entered into an IdentifierRegistry instance.
-	 */
-	class HasIdentifier {
-		const std::string PROPERTY(identifier);
-
-	protected:
-		HasIdentifier(std::string_view new_identifier): identifier { new_identifier } {
-			assert(!identifier.empty());
-		}
-
-	public:
-		HasIdentifier(HasIdentifier const&) = delete;
-		HasIdentifier(HasIdentifier&&) = default;
-		HasIdentifier& operator=(HasIdentifier const&) = delete;
-		HasIdentifier& operator=(HasIdentifier&&) = delete;
-	};
-
-	inline std::ostream& operator<<(std::ostream& stream, HasIdentifier const& obj) {
-		return stream << obj.get_identifier();
-	}
-	inline std::ostream& operator<<(std::ostream& stream, HasIdentifier const* obj) {
-		return obj != nullptr ? stream << *obj : stream << "<NULL>";
-	}
-
-	/*
-	 * Base class for objects with associated colour information.
-	 */
-	template<IsColour ColourT>
-	class _HasColour {
-		const ColourT PROPERTY(colour);
-
-	protected:
-		_HasColour(ColourT new_colour, bool cannot_be_null): colour { new_colour } {
-			assert(!cannot_be_null || !colour.is_null());
-		}
-
-	public:
-		_HasColour(_HasColour const&) = delete;
-		_HasColour(_HasColour&&) = default;
-		_HasColour& operator=(_HasColour const&) = delete;
-		_HasColour& operator=(_HasColour&&) = delete;
-	};
-
-	/*
-	 * Base class for objects with a unique string identifier and associated colour information.
-	 */
-	template<IsColour ColourT>
-	class _HasIdentifierAndColour : public HasIdentifier, public _HasColour<ColourT> {
-	protected:
-		_HasIdentifierAndColour(std::string_view new_identifier, ColourT new_colour, bool cannot_be_null)
-			: HasIdentifier { new_identifier }, _HasColour<ColourT> { new_colour, cannot_be_null } {}
-
-	public:
-		_HasIdentifierAndColour(_HasIdentifierAndColour const&) = delete;
-		_HasIdentifierAndColour(_HasIdentifierAndColour&&) = default;
-		_HasIdentifierAndColour& operator=(_HasIdentifierAndColour const&) = delete;
-		_HasIdentifierAndColour& operator=(_HasIdentifierAndColour&&) = delete;
-	};
-
-	using HasIdentifierAndColour = _HasIdentifierAndColour<colour_t>;
-	using HasIdentifierAndAlphaColour = _HasIdentifierAndColour<colour_argb_t>;
-
 	/* Callbacks for trying to add duplicate keys via UniqueKeyRegistry::add_item */
 	static bool duplicate_fail_callback(std::string_view registry_name, std::string_view duplicate_identifier) {
 		Logger::error(
@@ -199,9 +120,17 @@ namespace OpenVic {
 				Logger::error("Failed to reserve space for ", size, " items in ", name, " registry - already locked!");
 			} else {
 				items.reserve(size);
+				identifier_index_map.reserve(size);
 			}
 		}
 
+		static NodeTools::KeyValueCallback auto key_value_invalid_callback(std::string_view name) {
+			return [name](std::string_view key, ast::NodeCPtr) {
+				Logger::error("Invalid ", name, ": ", key);
+				return false;
+			};
+		}
+
 #define GETTERS(CONST) \
 	value_type CONST* get_item_by_identifier(std::string_view identifier) CONST { \
 		const typename decltype(identifier_index_map)::const_iterator it = identifier_index_map.find(identifier); \
@@ -235,12 +164,12 @@ namespace OpenVic {
 	) CONST { \
 		return NodeTools::expect_identifier(expect_item_str(callback, warn)); \
 	} \
-	NodeTools::NodeCallback auto expect_item_dictionary_and_default( \
-		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback, \
-		NodeTools::KeyValueCallback auto default_callback \
+	NodeTools::NodeCallback auto expect_item_assign_and_default( \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
 	) CONST { \
-		return NodeTools::expect_dictionary( \
-			[this, callback, default_callback](std::string_view key, ast::NodeCPtr value) -> bool { \
+		return NodeTools::expect_assign( \
+			[this, default_callback, callback](std::string_view key, ast::NodeCPtr value) -> bool { \
 				value_type CONST* item = get_item_by_identifier(key); \
 				if (item != nullptr) { \
 					return callback(*item, value); \
@@ -250,14 +179,70 @@ namespace OpenVic {
 			} \
 		); \
 	} \
+	NodeTools::NodeCallback auto expect_item_assign( \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
+	) CONST { \
+		return expect_item_assign_and_default(key_value_invalid_callback(name), callback); \
+	} \
+	NodeTools::NodeCallback auto expect_item_dictionary_and_length_and_default( \
+		NodeTools::LengthCallback auto length_callback, \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
+	) CONST { \
+		return NodeTools::expect_list_and_length( \
+			length_callback, expect_item_assign_and_default(default_callback, callback) \
+		); \
+	} \
+	NodeTools::NodeCallback auto expect_item_dictionary_and_length( \
+		NodeTools::LengthCallback auto length_callback, \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
+	) CONST { \
+		return expect_item_dictionary_and_length_and_default( \
+			length_callback, \
+			key_value_invalid_callback(name), \
+			callback \
+		); \
+	} \
+	NodeTools::NodeCallback auto expect_item_dictionary_and_default( \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
+	) CONST { \
+		return expect_item_dictionary_and_length_and_default( \
+			NodeTools::default_length_callback, \
+			default_callback, \
+			callback \
+		); \
+	} \
 	NodeTools::NodeCallback auto expect_item_dictionary( \
 		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
 	) CONST { \
-		return expect_item_dictionary_and_default( \
-			callback, [this](std::string_view key, ast::NodeCPtr) -> bool { \
-				Logger::error("Invalid ", name, ": ", key); \
-				return false; \
-			} \
+		return expect_item_dictionary_and_length_and_default( \
+			NodeTools::default_length_callback, \
+			key_value_invalid_callback(name), \
+			callback \
+		); \
+	} \
+	template<NodeTools::Reservable T> \
+	NodeTools::NodeCallback auto expect_item_dictionary_reserve_length_and_default( \
+		T& t, \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
+	) CONST { \
+		return expect_item_dictionary_and_length_and_default( \
+			NodeTools::reserve_length_callback(t), \
+			default_callback, \
+			callback \
+		); \
+	} \
+	template<NodeTools::Reservable T> \
+	NodeTools::NodeCallback auto expect_item_dictionary_reserve_length( \
+		T& t, \
+		NodeTools::Callback<value_type CONST&, ast::NodeCPtr> auto callback \
+	) CONST { \
+		return expect_item_dictionary_and_length_and_default( \
+			NodeTools::reserve_length_callback(t), \
+			key_value_invalid_callback(name), \
+			callback \
 		); \
 	}
 
@@ -432,15 +417,48 @@ private:
 	) const_kw { \
 		return registry.expect_item_identifier(callback, warn); \
 	} \
+	NodeTools::NodeCallback auto expect_##singular##_assign_and_default( \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
+	) const_kw { \
+		return registry.expect_item_assign_and_default(default_callback, callback); \
+	} \
+	NodeTools::NodeCallback auto expect_##singular##_assign( \
+		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
+	) const_kw { \
+		return registry.expect_item_assign(callback); \
+	} \
+	NodeTools::NodeCallback auto expect_##singular##_dictionary_and_length_and_default( \
+		NodeTools::LengthCallback auto length_callback, \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
+	) const_kw { \
+		return registry.expect_item_dictionary_and_length_and_default(length_callback, default_callback, callback); \
+	} \
 	NodeTools::NodeCallback auto expect_##singular##_dictionary_and_default( \
-		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback, \
-		NodeTools::KeyValueCallback auto default_callback \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
 	) const_kw { \
-		return registry.expect_item_dictionary_and_default(callback, default_callback); \
+		return registry.expect_item_dictionary_and_default(default_callback, callback); \
 	} \
 	NodeTools::NodeCallback auto expect_##singular##_dictionary( \
 		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
 	) const_kw { \
 		return registry.expect_item_dictionary(callback); \
+	} \
+	template<NodeTools::Reservable T> \
+	NodeTools::NodeCallback auto expect_##singular##_dictionary_reserve_length_and_default( \
+		T& t, \
+		NodeTools::KeyValueCallback auto default_callback, \
+		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
+	) const_kw { \
+		return registry.expect_item_dictionary_reserve_length_and_default(t, default_callback, callback); \
+	} \
+	template<NodeTools::Reservable T> \
+	NodeTools::NodeCallback auto expect_##singular##_dictionary_reserve_length( \
+		T& t, \
+		NodeTools::Callback<decltype(registry)::value_type const_kw&, ast::NodeCPtr> auto callback \
+	) const_kw { \
+		return registry.expect_item_dictionary_reserve_length(t, callback); \
 	}
 }
diff --git a/src/openvic-simulation/types/OrderedContainers.hpp b/src/openvic-simulation/types/OrderedContainers.hpp
index 1df9b10..e9f8717 100644
--- a/src/openvic-simulation/types/OrderedContainers.hpp
+++ b/src/openvic-simulation/types/OrderedContainers.hpp
@@ -146,7 +146,7 @@ namespace OpenVic {
 	template<class Key, class T, class Allocator = std::allocator<std::pair<Key, T>>, class IndexType = std::uint_least32_t>
 	using case_insensitive_deque_ordered_map =
 		deque_ordered_map<Key, T, case_insensitive_string_hash, case_insensitive_string_equal, Allocator, IndexType>;
-	
+
 	template<class Key, class T, class Allocator = std::allocator<std::pair<Key, T>>, class IndexType = std::uint_least32_t>
 	using case_insensitive_ordered_map = case_insensitive_vector_ordered_map<Key, T, Allocator, IndexType>;