Add type-safe pop_sum_t for large value sums of pops

Refactor pop_size_t to be type-safe

Move pop_size_t to population/PopSize.hpp
Add equalable to Concepts.hpp
Add expect_strong_typedef to NodeTools.hpp
Add `&& equalable<ValueType, OtherValueType>` requirement to IndexedFlatMap's divide_assign_handle_zero

Author: Spartan322

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

@@ -223,4 +223,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

@@ -42,7 +42,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"
@@ -1340,8 +1341,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;
@@ -1352,7 +1353,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) {
@@ -1365,13 +1366,13 @@ void CountryInstance::_update_budget() {
 	if (total_non_colonial_population == 0) {
 		administrative_efficiency_from_administrators.set(fixed_point_t::_1);
 		administrator_percentage.set(fixed_point_t::_0);
-	} else {		
-		administrator_percentage.set(fixed_point_t::parse(administrators) / total_non_colonial_population);
+	} else {
+		administrator_percentage.set(fixed_point_t::parse(type_safe::get(administrators)) / type_safe::get(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
 			)
@@ -1397,7 +1398,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/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

@@ -15,8 +15,8 @@ node_callback_t MilitaryDefines::expect_defines() {
 		"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_uint(assign_variable_callback(base_combat_width)),
-		"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)),
+		"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

@@ -3,7 +3,7 @@
 #include "openvic-simulation/dataloader/NodeTools.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

@@ -71,8 +71,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;
@@ -478,7 +478,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

@@ -6,7 +6,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 {
@@ -22,6 +21,8 @@ namespace OpenVic {
 	struct ProductionType;
 	struct ProvinceInstance;
 	struct RandomU32;
+	struct pop_size_t;
+	struct pop_sum_t;
 
 	struct ArtisanalProducer {
 	private:
@@ -47,7 +48,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;