Add type-safe pop_sum_t for large value sums of pops and refactor pop_size_t to be type-safe

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

@@ -226,4 +226,9 @@ namespace OpenVic {
 	concept mul_add_assignable = requires(Lhs& lhs, const A a, const B b) {
 		{ lhs += a * b } -> std::same_as<Lhs&>;
 	};
+
+	template<typename Lhs, typename Rhs = Lhs>
+	concept equalable = requires(Lhs const& lhs, Rhs const& rhs) {
+		{ lhs == rhs } -> std::convertible_to<bool>;
+	};
 }

src/openvic-simulation/country/CountryInstance.cpp

@@ -43,7 +43,8 @@
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/population/PopSize.hpp"
+#include "openvic-simulation/population/PopSum.hpp"
 #include "openvic-simulation/types/UnitBranchType.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
@@ -1341,8 +1342,8 @@ void CountryInstance::_update_budget() {
 	OpenVic immediately updates both.
 	*/
 
-	pop_size_t total_non_colonial_population = 0;
-	pop_size_t administrators = 0;
+	pop_sum_t total_non_colonial_population = 0;
+	pop_sum_t administrators = 0;
 	for (State const* const state_ptr : states) {
 		if (state_ptr == nullptr) {
 			continue;
@@ -1353,7 +1354,7 @@ void CountryInstance::_update_budget() {
 			continue;
 		}
 
-		IndexedFlatMap<PopType, pop_size_t> const& state_population_by_type = state.get_population_by_type();
+		IndexedFlatMap<PopType, pop_sum_t> const& state_population_by_type = state.get_population_by_type();
 
 		for (auto const& [pop_type, size] : state_population_by_type) {
 			if (pop_type.is_administrator) {
@@ -1369,10 +1370,10 @@ void CountryInstance::_update_budget() {
 	} else {		
 		administrator_percentage.set(fixed_point_t(administrators) / total_non_colonial_population);
 
-		const fixed_point_t desired_administrators = desired_administrator_percentage.get_untracked() * total_non_colonial_population;
+		const fixed_point_t desired_administrators = desired_administrator_percentage.get_untracked() * type_safe::get(total_non_colonial_population);
 		const fixed_point_t administrative_efficiency_from_administrators_unclamped = std::min(
 			fixed_point_t::mul_div(
-				administrators,
+				type_safe::get(administrators),
 				fixed_point_t::_1 + get_modifier_effect_value(*modifier_effect_cache.get_administrative_efficiency()),
 				desired_administrators
 			)
@@ -1398,7 +1399,7 @@ void CountryInstance::_update_budget() {
 		projected_education_spending_unscaled_by_slider_running_total += size * education_salary_base_by_pop_type.at(pop_type).get_untracked();
 		projected_military_spending_unscaled_by_slider_running_total += size * military_salary_base_by_pop_type.at(pop_type).get_untracked();
 		projected_pensions_spending_unscaled_by_slider_running_total += size * calculate_pensions_base(pop_type);
-		projected_unemployment_subsidies_spending_unscaled_by_slider_running_total += get_unemployed_pops_by_type(pop_type)
+		projected_unemployment_subsidies_spending_unscaled_by_slider_running_total += type_safe::get(get_unemployed_pops_by_type(pop_type))
 			* calculate_unemployment_subsidies_base(pop_type);
 	}
 

src/openvic-simulation/dataloader/Dataloader.cpp

@@ -240,11 +240,11 @@ string_set_t Dataloader::lookup_dirs_in_dir(std::string_view path) const {
 	return ret;
 }
 
-template<std::derived_from<detail::BasicParser> Parser, bool (*parse_func)(Parser&)>
+template<std::derived_from<ovdl::detail::BasicParser> Parser, bool (*parse_func)(Parser&)>
 static Parser _run_ovdl_parser(fs::path const& path) {
 	Parser parser;
 	memory::string buffer;
-	auto error_log_stream = detail::make_callback_stream<char>(
+	auto error_log_stream = ovdl::detail::make_callback_stream<char>(
 		[](void const* s, std::streamsize n, void* user_data) -> std::streamsize {
 			if (s != nullptr && n > 0 && user_data != nullptr) {
 				static_cast<memory::string*>(user_data)->append(static_cast<char const*>(s), n);

src/openvic-simulation/dataloader/NodeTools.hpp

@@ -199,21 +199,49 @@ using namespace std::string_view_literals;
 			return expect_uint(callback, base);
 		}
 
+		template<derived_from_specialization_of<type_safe::strong_typedef> T, typename AsT = type_safe::underlying_type<T>>
+		NodeCallback auto expect_strong_typedef(callback_t<T>& callback, int base = 10) {
+			if constexpr (std::unsigned_integral<AsT>) {
+				return expect_uint64(
+					[callback](uint64_t val) mutable -> bool {
+						if (val <= static_cast<uint64_t>(std::numeric_limits<AsT>::max())) {
+							return callback(T(val));
+						}
+						spdlog::error_s(
+							"Invalid uint: {} (valid range: [0, {}])", val,
+							static_cast<uint64_t>(std::numeric_limits<AsT>::max())
+						);
+						return false;
+					},
+					base
+				);
+			} else {
+				return expect_int64(
+					[callback](int64_t val) mutable -> bool {
+						if (val >= static_cast<int64_t>(std::numeric_limits<AsT>::min()) &&
+							val <= static_cast<int64_t>(std::numeric_limits<AsT>::max())) {
+							return callback(T(val));
+						}
+						spdlog::error_s(
+							"Invalid int: {} (valid range: [{}, {}])", val,
+							static_cast<int64_t>(std::numeric_limits<AsT>::min()),
+							static_cast<int64_t>(std::numeric_limits<AsT>::max())
+						);
+						return false;
+					},
+					base
+				);
+			}
+		}
+		template<derived_from_specialization_of<type_safe::strong_typedef> T, typename AsT = type_safe::underlying_type<T>>
+		NodeCallback auto expect_strong_typedef(callback_t<T>&& callback, int base = 10) {
+			return expect_strong_typedef<T, AsT>(callback, base);
+		}
+
 		template<derived_from_specialization_of<type_safe::strong_typedef> T>
 		requires std::unsigned_integral<type_safe::underlying_type<T>>
 		NodeCallback auto expect_index(callback_t<T>& callback, int base = 10) {
-			using underlying_type = type_safe::underlying_type<T>;
-
-			return expect_uint64([callback](uint64_t val) mutable -> bool {
-				if (val <= static_cast<uint64_t>(std::numeric_limits<underlying_type>::max())) {
-					return callback(T(val));
-				}
-				spdlog::error_s(
-					"Invalid uint: {} (valid range: [0, {}])",
-					val, static_cast<uint64_t>(std::numeric_limits<underlying_type>::max()) 
-				);
-				return false;
-			}, base);
+			return expect_strong_typedef<T>(callback, base);
 		}
 		template<derived_from_specialization_of<type_safe::strong_typedef> T>
 		requires std::unsigned_integral<type_safe::underlying_type<T>>

src/openvic-simulation/defines/MilitaryDefines.cpp

@@ -1,7 +1,5 @@
 #include "MilitaryDefines.hpp"
 
-#include <cstdint>
-
 #include "openvic-simulation/military/CombatWidth.hpp"
 
 #include <type_safe/strong_typedef.hpp>
@@ -20,12 +18,9 @@ node_callback_t MilitaryDefines::expect_defines() {
 		"DIG_IN_INCREASE_EACH_DAYS", ONE_EXACTLY, expect_days(assign_variable_callback(dig_in_increase_each_days)),
 		"REINFORCE_SPEED", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(reinforce_speed)),
 		"COMBAT_DIFFICULTY_IMPACT", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(combat_difficulty_impact)),
-		"BASE_COMBAT_WIDTH", ONE_EXACTLY, expect_int<int8_t>([this](int8_t val)->bool{
-			base_combat_width = combat_width_t(static_cast<type_safe::underlying_type<combat_width_t>>(val));
-			return true;
-		}),
-		"POP_MIN_SIZE_FOR_REGIMENT", ONE_EXACTLY, expect_uint(assign_variable_callback(min_pop_size_for_regiment)),
-		"POP_SIZE_PER_REGIMENT", ONE_EXACTLY, expect_uint(assign_variable_callback(pop_size_per_regiment)),
+		"BASE_COMBAT_WIDTH", ONE_EXACTLY, expect_strong_typedef<combat_width_t>(assign_variable_callback(base_combat_width)),
+		"POP_MIN_SIZE_FOR_REGIMENT", ONE_EXACTLY, expect_strong_typedef<pop_size_t>(assign_variable_callback(min_pop_size_for_regiment)),
+		"POP_SIZE_PER_REGIMENT", ONE_EXACTLY, expect_strong_typedef<pop_size_t>(assign_variable_callback(pop_size_per_regiment)),
 		"SOLDIER_TO_POP_DAMAGE", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(soldier_to_pop_damage)),
 		"LAND_SPEED_MODIFIER", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(land_speed_modifier)),
 		"NAVAL_SPEED_MODIFIER", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(naval_speed_modifier)),

src/openvic-simulation/defines/MilitaryDefines.hpp

@@ -4,7 +4,7 @@
 #include "openvic-simulation/military/CombatWidth.hpp"
 #include "openvic-simulation/types/Date.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {

src/openvic-simulation/defines/PopsDefines.cpp

@@ -75,8 +75,8 @@ node_callback_t PopsDefines::expect_defines() {
 		"MOVEMENT_SUPPORT_UH_FACTOR", ONE_EXACTLY, expect_fixed_point(assign_variable_callback(movement_support_uh_factor)),
 		"REBEL_OCCUPATION_STRENGTH_BONUS", ONE_EXACTLY,
 			expect_fixed_point(assign_variable_callback(rebel_occupation_strength_bonus)),
-		"LARGE_POPULATION_LIMIT", ONE_EXACTLY, expect_uint(assign_variable_callback(large_population_limit)),
+		"LARGE_POPULATION_LIMIT", ONE_EXACTLY, expect_strong_typedef<pop_sum_t>(assign_variable_callback(large_population_limit)),
 		"LARGE_POPULATION_INFLUENCE_PENALTY_CHUNK", ONE_EXACTLY,
-			expect_uint(assign_variable_callback(large_population_influence_penalty_chunk))
+			expect_strong_typedef<pop_sum_t>(assign_variable_callback(large_population_influence_penalty_chunk))
 	);
 }

src/openvic-simulation/defines/PopsDefines.hpp

@@ -2,7 +2,7 @@
 
 #include "openvic-simulation/dataloader/NodeTools.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/population/PopSum.hpp"
 #include "openvic-simulation/types/ProvinceLifeRating.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
@@ -71,8 +71,8 @@ namespace OpenVic {
 		fixed_point_t PROPERTY(nationalist_movement_mil_cap);
 		fixed_point_t PROPERTY(movement_support_uh_factor);
 		fixed_point_t PROPERTY(rebel_occupation_strength_bonus);
-		pop_size_t PROPERTY(large_population_limit, 0);
-		pop_size_t PROPERTY(large_population_influence_penalty_chunk, 0);
+		pop_sum_t PROPERTY(large_population_limit, 0);
+		pop_sum_t PROPERTY(large_population_influence_penalty_chunk, 0);
 
 		PopsDefines();
 

src/openvic-simulation/economy/production/ArtisanalProducer.cpp

@@ -72,8 +72,8 @@ void ArtisanalProducer::artisan_tick_handler::calculate_inputs(
 	//throughput scalar, the minimum of stockpile / base_desired_quantity
 	//inputs_bought_fraction uses base_desired_quantity as population size is cancelled in the production and input calculations.
 	const pop_size_t pop_size = pop.get_size();
-	fixed_point_t inputs_bought_numerator = pop_size,
-		inputs_bought_denominator = production_type.base_workforce_size,
+	fixed_point_t inputs_bought_numerator = type_safe::get(pop_size),
+		inputs_bought_denominator = type_safe::get(production_type.base_workforce_size),
 		inputs_bought_fraction_v = inputs_bought_numerator / inputs_bought_denominator;
 
 	distinct_goods_to_buy = 0;
@@ -479,7 +479,7 @@ std::optional<fixed_point_t> ArtisanalProducer::estimate_production_type_score(
 fixed_point_t ArtisanalProducer::calculate_production_type_score(
 	const fixed_point_t revenue,
 	const fixed_point_t costs,
-	const pop_size_t workforce
+	const pop_sum_t workforce
 ) {
 	if (costs >= revenue) {
 		return 0;

src/openvic-simulation/economy/production/ArtisanalProducer.hpp

@@ -7,7 +7,6 @@
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
 #include "openvic-simulation/types/fixed_point/Fraction.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {
@@ -23,6 +22,8 @@ namespace OpenVic {
 	struct ProductionType;
 	struct ProvinceInstance;
 	struct RandomU32;
+	struct pop_size_t;
+	struct pop_sum_t;
 
 	struct ArtisanalProducer {
 	private:
@@ -48,7 +49,7 @@ namespace OpenVic {
 		static fixed_point_t calculate_production_type_score(
 			const fixed_point_t revenue,
 			const fixed_point_t costs,
-			const pop_size_t workforce
+			const pop_sum_t workforce
 		);
 
 	public:

src/openvic-simulation/economy/production/Employee.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/population/PopSize.hpp"
 
 namespace OpenVic {
 	struct CountryInstance;

src/openvic-simulation/economy/production/FactoryProducer.hpp

@@ -5,7 +5,7 @@
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp"
 #include "openvic-simulation/types/OrderedContainers.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/population/PopSize.hpp"
 #include "openvic-simulation/utility/Getters.hpp"
 
 namespace OpenVic {

src/openvic-simulation/economy/production/ProductionType.cpp

@@ -8,6 +8,7 @@
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/population/PopManager.hpp"
 #include "openvic-simulation/population/PopType.hpp"
+#include "openvic-simulation/population/PopSum.hpp"
 
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
@@ -28,7 +29,7 @@ ProductionType::ProductionType(
 	const std::optional<Job> new_owner,
 	memory::vector<Job>&& new_jobs,
 	const template_type_t new_template_type,
-	const pop_size_t new_base_workforce_size,
+	const pop_sum_t new_base_workforce_size,
 	fixed_point_map_t<GoodDefinition const*>&& new_input_goods,
 	GoodDefinition const& new_output_good,
 	const fixed_point_t new_base_output_quantity,
@@ -139,7 +140,7 @@ bool ProductionTypeManager::add_production_type(
 	std::optional<Job> owner,
 	memory::vector<Job>&& jobs,
 	const ProductionType::template_type_t template_type,
-	const pop_size_t base_workforce_size,
+	const pop_sum_t base_workforce_size,
 	fixed_point_map_t<GoodDefinition const*>&& input_goods,
 	GoodDefinition const* const output_good,
 	const fixed_point_t base_output_quantity,
@@ -327,7 +328,7 @@ bool ProductionTypeManager::load_production_types_file(
 			memory::vector<Job> jobs;
 			ProductionType::template_type_t template_type { FACTORY };
 			GoodDefinition const* output_good = nullptr;
-			pop_size_t base_workforce_size = 0;
+			pop_sum_t base_workforce_size = 0;
 			fixed_point_map_t<GoodDefinition const*> input_goods, maintenance_requirements;
 			fixed_point_t base_output_quantity = 0;
 			memory::vector<ProductionType::bonus_t> bonuses;
@@ -360,7 +361,7 @@ bool ProductionTypeManager::load_production_types_file(
 				"employees", ZERO_OR_ONE, _expect_job_list(good_definition_manager, pop_manager, move_variable_callback(jobs)),
 				"type", ZERO_OR_ONE,
 					expect_identifier(expect_mapped_string(template_type_map, assign_variable_callback(template_type))),
-				"workforce", ZERO_OR_ONE, expect_uint(assign_variable_callback(base_workforce_size)),
+				"workforce", ZERO_OR_ONE, expect_strong_typedef<pop_size_t>(assign_variable_callback(base_workforce_size)),
 				"input_goods", ZERO_OR_ONE,
 					good_definition_manager.expect_good_definition_decimal_map(move_variable_callback(input_goods)),
 				"output_goods", ZERO_OR_ONE,

src/openvic-simulation/economy/production/ProductionType.hpp

@@ -6,7 +6,7 @@
 #include "openvic-simulation/types/IdentifierRegistry.hpp"
 #include "openvic-simulation/types/IndexedFlatMap.hpp"
 #include "openvic-simulation/types/fixed_point/FixedPoint.hpp"
-#include "openvic-simulation/types/PopSize.hpp"
+#include "openvic-simulation/population/PopSum.hpp"
 #include "openvic-simulation/types/PopSprite.hpp"
 #include "openvic-simulation/utility/Containers.hpp"
 
@@ -65,7 +65,7 @@ namespace OpenVic {
 	public:
 		GoodDefinition const& output_good;
 		const template_type_t template_type;
-		const pop_size_t base_workforce_size;
+		const pop_sum_t base_workforce_size;
 		const fixed_point_t base_output_quantity;
 
 		ProductionType(
@@ -74,7 +74,7 @@ namespace OpenVic {
 			const std::optional<Job> new_owner,
 			memory::vector<Job>&& new_jobs,
 			const template_type_t new_template_type,
-			const pop_size_t new_base_workforce_size,
+			const pop_sum_t new_base_workforce_size,
 			fixed_point_map_t<GoodDefinition const*>&& new_input_goods,
 			GoodDefinition const& new_output_good,
 			const fixed_point_t new_base_output_quantity,
@@ -123,7 +123,7 @@ namespace OpenVic {
 			std::optional<Job> owner,
 			memory::vector<Job>&& jobs,
 			const ProductionType::template_type_t template_type,
-			const pop_size_t base_workforce_size,
+			const pop_sum_t base_workforce_size,
 			fixed_point_map_t<GoodDefinition const*>&& input_goods,
 			GoodDefinition const* const output_good,
 			const fixed_point_t base_output_quantity,