From f284c423fc56bfebb681c48b48f8acf49ab6f9d8 Mon Sep 17 00:00:00 2001 From: Spartan322 Date: Tue, 20 Jan 2026 12:38:08 -0500 Subject: [PATCH] Move generic containers into core/containers Move tracked allocating containers to memory namespace --- src/openvic-simulation/GameManager.cpp | 6 +- src/openvic-simulation/InstanceManager.hpp | 4 +- .../console/ConsoleInstance.hpp | 4 +- .../{utility => core}/Allocator.hpp | 0 .../container}/BasicIterator.hpp | 0 .../core/container/CaseContainer.hpp | 15 ++ .../container}/ClampedValue.hpp | 0 .../{types => core/container}/CowPtr.hpp | 0 .../{types => core/container}/CowVector.hpp | 4 +- .../{types => core/container}/FixedVector.hpp | 64 +++-- .../container}/HasIdentifier.hpp | 0 .../{types => core/container}/HasIndex.hpp | 0 .../container}/IdentifierRegistry.hpp | 3 +- .../container}/IndexedFlatMap.hpp | 165 ++++++++----- .../container/MutableIterator.hpp} | 2 +- .../core/container/OrderedMap.hpp | 219 ++++++++++++++++++ .../core/container/OrderedSet.hpp | 42 ++++ .../{types => core/container}/RingBuffer.hpp | 0 .../{types => core/container}/StackString.hpp | 0 .../{types => core/container}/TypedSpan.hpp | 0 .../container}/ValueHistory.hpp | 2 +- src/openvic-simulation/core/io/BMP.cpp | 4 +- src/openvic-simulation/core/memory/CowPtr.hpp | 14 ++ .../core/memory/CowVector.hpp | 14 ++ .../core/memory/FixedVector.hpp | 14 ++ .../{types => core/memory}/FlagStrings.cpp | 4 +- .../{types => core/memory}/FlagStrings.hpp | 9 +- .../core/memory/IndexedFlatMap.hpp | 27 +++ .../core/memory/OrderedMap.hpp | 46 ++++ .../core/memory/OrderedSet.hpp | 46 ++++ .../core/memory/RingBuffer.hpp | 14 ++ .../core/memory/StringMap.hpp | 17 ++ .../core/memory/StringSet.hpp | 16 ++ .../core/memory/ValueHistory.hpp | 14 ++ .../core/portable/ForwardableSpan.hpp | 2 +- .../core/template/StringMapCasing.hpp | 90 +++++++ .../country/CountryDefinition.cpp | 4 +- .../country/CountryDefinition.hpp | 12 +- .../country/CountryInstance.cpp | 19 +- .../country/CountryInstance.hpp | 60 ++--- .../country/CountryInstanceManager.cpp | 2 +- .../country/CountryInstanceManager.hpp | 2 +- .../country/CountryParty.hpp | 4 +- .../country/SharedCountryValues.cpp | 1 - .../country/SharedCountryValues.hpp | 2 +- .../dataloader/Dataloader.cpp | 10 +- .../dataloader/Dataloader.hpp | 3 +- .../dataloader/ModManager.cpp | 12 +- .../dataloader/ModManager.hpp | 7 +- .../dataloader/NodeTools.cpp | 5 +- .../dataloader/NodeTools.hpp | 14 +- .../dataloader/Vic2PathSearch.cpp | 4 +- .../diplomacy/CountryRelation.hpp | 9 +- .../diplomacy/DiplomaticAction.cpp | 2 +- .../diplomacy/DiplomaticAction.hpp | 2 +- .../economy/BuildingInstance.hpp | 2 +- .../economy/BuildingType.hpp | 7 +- .../economy/GoodDefinition.cpp | 2 +- .../economy/GoodDefinition.hpp | 6 +- .../economy/GoodInstance.hpp | 6 +- .../economy/production/ArtisanalProducer.cpp | 14 +- .../economy/production/ArtisanalProducer.hpp | 18 +- .../economy/production/FactoryProducer.cpp | 4 +- .../economy/production/FactoryProducer.hpp | 6 +- .../economy/production/ProductionType.cpp | 13 +- .../economy/production/ProductionType.hpp | 4 +- .../production/ResourceGatheringOperation.hpp | 2 +- .../economy/trading/GoodMarket.hpp | 6 +- src/openvic-simulation/history/Bookmark.cpp | 2 +- src/openvic-simulation/history/Bookmark.hpp | 6 +- .../history/CountryHistory.cpp | 3 +- .../history/CountryHistory.hpp | 22 +- src/openvic-simulation/history/HistoryMap.hpp | 6 +- .../history/ProvinceHistory.cpp | 3 +- .../history/ProvinceHistory.hpp | 10 +- .../interface/GFXSprite.hpp | 5 +- src/openvic-simulation/interface/GUI.cpp | 5 +- src/openvic-simulation/interface/LoadBase.hpp | 2 +- src/openvic-simulation/interface/UI.cpp | 2 +- src/openvic-simulation/map/Crime.hpp | 2 +- src/openvic-simulation/map/MapDefinition.cpp | 12 +- src/openvic-simulation/map/MapDefinition.hpp | 6 +- src/openvic-simulation/map/MapInstance.hpp | 3 +- src/openvic-simulation/map/Mapmode.cpp | 6 +- src/openvic-simulation/map/Mapmode.hpp | 6 +- .../map/ProvinceDefinition.hpp | 9 +- .../map/ProvinceInstance.cpp | 4 +- .../map/ProvinceInstance.hpp | 17 +- src/openvic-simulation/map/Region.hpp | 2 +- src/openvic-simulation/map/TerrainType.cpp | 4 +- src/openvic-simulation/map/TerrainType.hpp | 8 +- .../military/Deployment.hpp | 7 +- .../military/LeaderTrait.hpp | 2 +- .../military/UnitInstanceGroup.cpp | 1 - .../military/UnitInstanceGroup.hpp | 8 +- src/openvic-simulation/military/UnitType.cpp | 7 +- src/openvic-simulation/military/UnitType.hpp | 13 +- src/openvic-simulation/military/Wargoal.cpp | 3 +- src/openvic-simulation/military/Wargoal.hpp | 2 +- src/openvic-simulation/misc/Decision.hpp | 2 +- src/openvic-simulation/misc/Event.hpp | 6 +- src/openvic-simulation/misc/SongChance.hpp | 2 +- src/openvic-simulation/misc/SoundEffect.hpp | 4 +- .../modifier/ModifierEffect.hpp | 2 +- .../modifier/ModifierEffectCache.hpp | 2 +- .../modifier/ModifierManager.hpp | 5 +- .../modifier/ModifierValue.cpp | 2 +- src/openvic-simulation/politics/BaseIssue.hpp | 2 +- .../politics/Government.cpp | 3 +- .../politics/Government.hpp | 9 +- src/openvic-simulation/politics/Ideology.hpp | 6 +- .../politics/IssueManager.cpp | 2 +- .../politics/IssueManager.hpp | 2 +- .../politics/NationalFocus.hpp | 4 +- .../politics/NationalValue.hpp | 2 +- .../politics/PartyPolicy.hpp | 2 +- .../politics/PoliticsInstanceManager.hpp | 2 +- src/openvic-simulation/politics/Rebel.cpp | 7 +- src/openvic-simulation/politics/Rebel.hpp | 10 +- src/openvic-simulation/politics/Reform.hpp | 4 +- src/openvic-simulation/politics/Rule.cpp | 7 +- src/openvic-simulation/politics/Rule.hpp | 14 +- src/openvic-simulation/population/Culture.cpp | 2 +- src/openvic-simulation/population/Culture.hpp | 7 +- src/openvic-simulation/population/Pop.cpp | 12 +- src/openvic-simulation/population/Pop.hpp | 9 +- .../population/PopManager.cpp | 5 +- src/openvic-simulation/population/PopType.cpp | 2 +- src/openvic-simulation/population/PopType.hpp | 13 +- .../population/PopValuesFromProvince.hpp | 2 +- .../population/PopsAggregate.cpp | 1 - .../population/PopsAggregate.hpp | 16 +- .../population/Religion.hpp | 4 +- src/openvic-simulation/research/Invention.hpp | 12 +- .../research/Technology.cpp | 2 +- .../research/Technology.hpp | 10 +- src/openvic-simulation/scripts/Condition.cpp | 2 +- src/openvic-simulation/scripts/Condition.hpp | 4 +- src/openvic-simulation/types/Colour.hpp | 2 +- src/openvic-simulation/types/Date.hpp | 2 +- .../types/OrderedContainers.hpp | 206 ---------------- .../types/OrderedContainersMath.hpp | 173 -------------- src/openvic-simulation/types/Signal.hpp | 5 +- src/openvic-simulation/types/Vector.hpp | 2 +- .../types/fixed_point/FixedPoint.hpp | 2 +- .../types/fixed_point/FixedPointMap.hpp | 6 +- src/openvic-simulation/utility/Containers.hpp | 8 - src/openvic-simulation/utility/ThreadPool.cpp | 5 +- .../{types => core/container}/FixedVector.cpp | 4 +- .../{types => core/container}/RingBuffer.cpp | 2 +- tests/src/dataloader/NodeTools.cpp | 9 +- tests/src/economy/trading/GoodMarket.cpp | 2 +- 152 files changed, 1128 insertions(+), 817 deletions(-) rename src/openvic-simulation/{utility => core}/Allocator.hpp (100%) rename src/openvic-simulation/{types => core/container}/BasicIterator.hpp (100%) create mode 100644 src/openvic-simulation/core/container/CaseContainer.hpp rename src/openvic-simulation/{types => core/container}/ClampedValue.hpp (100%) rename src/openvic-simulation/{types => core/container}/CowPtr.hpp (100%) rename src/openvic-simulation/{types => core/container}/CowVector.hpp (99%) rename src/openvic-simulation/{types => core/container}/FixedVector.hpp (74%) rename src/openvic-simulation/{types => core/container}/HasIdentifier.hpp (100%) rename src/openvic-simulation/{types => core/container}/HasIndex.hpp (100%) rename src/openvic-simulation/{types => core/container}/IdentifierRegistry.hpp (99%) rename src/openvic-simulation/{types => core/container}/IndexedFlatMap.hpp (87%) rename src/openvic-simulation/{utility/TslHelper.hpp => core/container/MutableIterator.hpp} (98%) create mode 100644 src/openvic-simulation/core/container/OrderedMap.hpp create mode 100644 src/openvic-simulation/core/container/OrderedSet.hpp rename src/openvic-simulation/{types => core/container}/RingBuffer.hpp (100%) rename src/openvic-simulation/{types => core/container}/StackString.hpp (100%) rename src/openvic-simulation/{types => core/container}/TypedSpan.hpp (100%) rename src/openvic-simulation/{types => core/container}/ValueHistory.hpp (96%) create mode 100644 src/openvic-simulation/core/memory/CowPtr.hpp create mode 100644 src/openvic-simulation/core/memory/CowVector.hpp create mode 100644 src/openvic-simulation/core/memory/FixedVector.hpp rename src/openvic-simulation/{types => core/memory}/FlagStrings.cpp (85%) rename src/openvic-simulation/{types => core/memory}/FlagStrings.hpp (67%) create mode 100644 src/openvic-simulation/core/memory/IndexedFlatMap.hpp create mode 100644 src/openvic-simulation/core/memory/OrderedMap.hpp create mode 100644 src/openvic-simulation/core/memory/OrderedSet.hpp create mode 100644 src/openvic-simulation/core/memory/RingBuffer.hpp create mode 100644 src/openvic-simulation/core/memory/StringMap.hpp create mode 100644 src/openvic-simulation/core/memory/StringSet.hpp create mode 100644 src/openvic-simulation/core/memory/ValueHistory.hpp create mode 100644 src/openvic-simulation/core/template/StringMapCasing.hpp delete mode 100644 src/openvic-simulation/types/OrderedContainers.hpp delete mode 100644 src/openvic-simulation/types/OrderedContainersMath.hpp rename tests/src/{types => core/container}/FixedVector.cpp (98%) rename tests/src/{types => core/container}/RingBuffer.cpp (99%) diff --git a/src/openvic-simulation/GameManager.cpp b/src/openvic-simulation/GameManager.cpp index 369e269e5..4afa5197c 100644 --- a/src/openvic-simulation/GameManager.cpp +++ b/src/openvic-simulation/GameManager.cpp @@ -8,8 +8,8 @@ #include +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/dataloader/Dataloader.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/utility/Logger.hpp" using namespace OpenVic; @@ -76,7 +76,7 @@ bool GameManager::load_mods(memory::vector const& mods_to_find) bool ret = true; - vector_ordered_set load_list; + memory::vector_ordered_set load_list; /* Check loaded mod descriptors for requested mods, using either full name or user directory name * (Historical Project Mod 0.4.6 or HPM both valid, for example), and load them plus their dependencies. @@ -95,7 +95,7 @@ bool GameManager::load_mods(memory::vector const& mods_to_find) } Mod const* mod_ptr = &*it; - vector_ordered_set dependencies = mod_ptr->generate_dependency_list(&ret); + memory::vector_ordered_set dependencies = mod_ptr->generate_dependency_list(&ret); if(!ret) { continue; } diff --git a/src/openvic-simulation/InstanceManager.hpp b/src/openvic-simulation/InstanceManager.hpp index 311727432..dbb1508e2 100644 --- a/src/openvic-simulation/InstanceManager.hpp +++ b/src/openvic-simulation/InstanceManager.hpp @@ -5,6 +5,7 @@ #include #include "openvic-simulation/console/ConsoleInstance.hpp" +#include "openvic-simulation/core/memory/FlagStrings.hpp" #include "openvic-simulation/country/CountryInstanceManager.hpp" #include "openvic-simulation/country/CountryInstanceDeps.hpp" #include "openvic-simulation/diplomacy/CountryRelation.hpp" @@ -21,7 +22,6 @@ #include "openvic-simulation/politics/PoliticsInstanceManager.hpp" #include "openvic-simulation/population/PopDeps.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/FlagStrings.hpp" #include "openvic-simulation/utility/ThreadPool.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -50,7 +50,7 @@ namespace OpenVic { ResourceGatheringOperationDeps rgo_deps; ProvinceInstanceDeps province_instance_deps; - FlagStrings PROPERTY_REF(global_flags); + memory::FlagStrings PROPERTY_REF(global_flags); CountryInstanceManager PROPERTY_REF(country_instance_manager); UnitInstanceManager PROPERTY_REF(unit_instance_manager); diff --git a/src/openvic-simulation/console/ConsoleInstance.hpp b/src/openvic-simulation/console/ConsoleInstance.hpp index a3ebcca37..3b01649dd 100644 --- a/src/openvic-simulation/console/ConsoleInstance.hpp +++ b/src/openvic-simulation/console/ConsoleInstance.hpp @@ -7,9 +7,9 @@ #include #include +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/types/Colour.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/Getters.hpp" @@ -98,7 +98,7 @@ namespace OpenVic { Technology const* validate_tech_name(std::string_view value_string); private: - string_map_t commands; + memory::string_map_t commands; write_func_t write_func; diff --git a/src/openvic-simulation/utility/Allocator.hpp b/src/openvic-simulation/core/Allocator.hpp similarity index 100% rename from src/openvic-simulation/utility/Allocator.hpp rename to src/openvic-simulation/core/Allocator.hpp diff --git a/src/openvic-simulation/types/BasicIterator.hpp b/src/openvic-simulation/core/container/BasicIterator.hpp similarity index 100% rename from src/openvic-simulation/types/BasicIterator.hpp rename to src/openvic-simulation/core/container/BasicIterator.hpp diff --git a/src/openvic-simulation/core/container/CaseContainer.hpp b/src/openvic-simulation/core/container/CaseContainer.hpp new file mode 100644 index 000000000..52114fbdd --- /dev/null +++ b/src/openvic-simulation/core/container/CaseContainer.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include "openvic-simulation/core/template/Concepts.hpp" + +namespace OpenVic { + /* Intermediate struct that "remembers" Case, instead of just decomposing it into its hash and equal components, + * needed so that templates can deduce the Case with which a type was defined. */ + template typename Container, string_map_case Case, typename... Args> + struct template_case_container_t : Container { + using container_t = Container; + using container_t::container_t; + + using case_t = Case; + }; +} diff --git a/src/openvic-simulation/types/ClampedValue.hpp b/src/openvic-simulation/core/container/ClampedValue.hpp similarity index 100% rename from src/openvic-simulation/types/ClampedValue.hpp rename to src/openvic-simulation/core/container/ClampedValue.hpp diff --git a/src/openvic-simulation/types/CowPtr.hpp b/src/openvic-simulation/core/container/CowPtr.hpp similarity index 100% rename from src/openvic-simulation/types/CowPtr.hpp rename to src/openvic-simulation/core/container/CowPtr.hpp diff --git a/src/openvic-simulation/types/CowVector.hpp b/src/openvic-simulation/core/container/CowVector.hpp similarity index 99% rename from src/openvic-simulation/types/CowVector.hpp rename to src/openvic-simulation/core/container/CowVector.hpp index 22b7abb3e..06cd6767d 100644 --- a/src/openvic-simulation/types/CowVector.hpp +++ b/src/openvic-simulation/core/container/CowVector.hpp @@ -12,8 +12,8 @@ #include #include "openvic-simulation/core/Assert.hpp" -#include "openvic-simulation/types/BasicIterator.hpp" -#include "openvic-simulation/utility/Allocator.hpp" +#include "openvic-simulation/core/container/BasicIterator.hpp" +#include "openvic-simulation/core/Allocator.hpp" #include "openvic-simulation/core/Compare.hpp" #include "openvic-simulation/core/template/Concepts.hpp" #include "openvic-simulation/core/Typedefs.hpp" diff --git a/src/openvic-simulation/types/FixedVector.hpp b/src/openvic-simulation/core/container/FixedVector.hpp similarity index 74% rename from src/openvic-simulation/types/FixedVector.hpp rename to src/openvic-simulation/core/container/FixedVector.hpp index ce6a97bb7..6ee9317d4 100644 --- a/src/openvic-simulation/types/FixedVector.hpp +++ b/src/openvic-simulation/core/container/FixedVector.hpp @@ -4,13 +4,14 @@ #include #include #include +#include #include #include "openvic-simulation/core/Assert.hpp" #include "openvic-simulation/core/template/Concepts.hpp" #include "openvic-simulation/core/Typedefs.hpp" -namespace OpenVic::_detail { +namespace OpenVic { //fixed capacity + not movable + not copyable template > class FixedVector { @@ -27,6 +28,7 @@ namespace OpenVic::_detail { using reference = T&; using size_type = size_t; using value_type = T; + using allocator_type = Allocator; constexpr size_t size() const { return _size; } constexpr size_t capacity() const { return _max_size; } @@ -39,15 +41,21 @@ namespace OpenVic::_detail { * @brief Creates an uninitialised vector with fixed capacity */ explicit FixedVector(const size_t capacity) + : FixedVector(capacity, Allocator()) {} + + FixedVector(const size_t capacity, std::type_identity_t const& alloc) : _max_size(capacity), _size(0), - _allocator(), + _allocator(alloc), _data_start_ptr(allocator_traits::allocate(_allocator, capacity)) {} FixedVector(const size_t size, T const& value_for_all_indices) + : FixedVector(size, value_for_all_indices, Allocator()) {} + + FixedVector(const size_t size, T const& value_for_all_indices, std::type_identity_t const& alloc) : _max_size(size), _size(size), - _allocator(), + _allocator(alloc), _data_start_ptr(allocator_traits::allocate(_allocator, size)) { std::fill(_data_start_ptr, _data_start_ptr + size, value_for_all_indices); } @@ -59,9 +67,19 @@ namespace OpenVic::_detail { // The type must be constructible from the generator's single return value && std::constructible_from()(std::declval()))> FixedVector(const size_t size, GeneratorTemplateType&& generator) + : FixedVector(size, std::forward(generator), Allocator()) { + } + + //Generator (size_t i) -> U (where T is constructable from U) + template + // The generator must NOT return a tuple + requires (!specialization_of>, std::tuple>) + // The type must be constructible from the generator's single return value + && std::constructible_from()(std::declval()))> + FixedVector(const size_t size, GeneratorTemplateType&& generator, std::type_identity_t const& alloc) : _max_size(size), _size(size), - _allocator(), + _allocator(alloc), _data_start_ptr(allocator_traits::allocate(_allocator, size)) { for (size_t i = 0; i < size; ++i) { allocator_traits::construct( @@ -88,9 +106,28 @@ namespace OpenVic::_detail { }; } FixedVector(const size_t size, GeneratorTemplateType&& generator) + : FixedVector(size, std::forward(generator), Allocator()) { + } + + //Generator (size_t i) -> std::tuple (where T is constructable from Args) + template + // The generator must return a tuple + requires specialization_of>, std::tuple> + // The tuple must be constructible into a T + && requires(GeneratorTemplateType&& generator) { + { + std::apply( + [](auto&&... args) { + T obj{std::forward(args)...}; + }, + generator(std::declval()) + ) + }; + } + FixedVector(const size_t size, GeneratorTemplateType&& generator, std::type_identity_t const& alloc) : _max_size(size), _size(size), - _allocator(), + _allocator(alloc), _data_start_ptr(allocator_traits::allocate(_allocator, size)) { for (size_t i = 0; i < size; ++i) { std::apply( @@ -115,7 +152,7 @@ namespace OpenVic::_detail { clear(); allocator_traits::deallocate(_allocator, _data_start_ptr, _max_size); } - + using iterator = T*; using const_iterator = const T*; @@ -126,7 +163,7 @@ namespace OpenVic::_detail { iterator end() { return begin() + _size; } const_iterator end() const { return begin() + _size; } const_iterator cend() const { return cbegin() + _size; } - + using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; @@ -198,14 +235,9 @@ namespace OpenVic::_detail { } _size = 0; } - }; -} -#include - -#include "openvic-simulation/utility/MemoryTracker.hpp" - -namespace OpenVic::memory { - template - using FixedVector = _detail::FixedVector>>; + allocator_type get_allocator() const { + return _allocator; + } + }; } \ No newline at end of file diff --git a/src/openvic-simulation/types/HasIdentifier.hpp b/src/openvic-simulation/core/container/HasIdentifier.hpp similarity index 100% rename from src/openvic-simulation/types/HasIdentifier.hpp rename to src/openvic-simulation/core/container/HasIdentifier.hpp diff --git a/src/openvic-simulation/types/HasIndex.hpp b/src/openvic-simulation/core/container/HasIndex.hpp similarity index 100% rename from src/openvic-simulation/types/HasIndex.hpp rename to src/openvic-simulation/core/container/HasIndex.hpp diff --git a/src/openvic-simulation/types/IdentifierRegistry.hpp b/src/openvic-simulation/core/container/IdentifierRegistry.hpp similarity index 99% rename from src/openvic-simulation/types/IdentifierRegistry.hpp rename to src/openvic-simulation/core/container/IdentifierRegistry.hpp index 577bd61ea..aff4e41ca 100644 --- a/src/openvic-simulation/types/IdentifierRegistry.hpp +++ b/src/openvic-simulation/core/container/IdentifierRegistry.hpp @@ -8,6 +8,7 @@ #include "openvic-simulation/core/template/Concepts.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/Logger.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" namespace OpenVic { /* Callbacks for trying to add duplicate keys via UniqueKeyRegistry::add_item */ @@ -174,7 +175,7 @@ namespace OpenVic { private: using StorageInfo = _StorageInfo; using internal_storage_index_type = typename StorageInfo::index_type; - using identifier_index_map_t = template_string_map_t; + using identifier_index_map_t = memory::template_string_map_t; public: using storage_type = typename StorageInfo::storage_type; diff --git a/src/openvic-simulation/types/IndexedFlatMap.hpp b/src/openvic-simulation/core/container/IndexedFlatMap.hpp similarity index 87% rename from src/openvic-simulation/types/IndexedFlatMap.hpp rename to src/openvic-simulation/core/container/IndexedFlatMap.hpp index fdaf41fd6..b380131fc 100644 --- a/src/openvic-simulation/types/IndexedFlatMap.hpp +++ b/src/openvic-simulation/core/container/IndexedFlatMap.hpp @@ -4,30 +4,18 @@ #include #include #include +#include #include #include #include -#include "openvic-simulation/types/FixedVector.hpp" +#include "openvic-simulation/core/container/FixedVector.hpp" #include "openvic-simulation/core/template/Concepts.hpp" -#include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/core/portable/ForwardableSpan.hpp" #include "openvic-simulation/utility/Logger.hpp" -#define OV_IFLATMAP_PROPERTY(KEYTYPE, VALUETYPE, NAME) OV_IFLATMAP_PROPERTY_ACCESS(KEYTYPE, VALUETYPE, NAME, private) -#define OV_IFLATMAP_PROPERTY_ACCESS(KEYTYPE, VALUETYPE, NAME, ACCESS) \ - IndexedFlatMap NAME; \ -\ -public: \ - [[nodiscard]] constexpr IndexedFlatMap const& get_##NAME() const { \ - return NAME; \ - } \ - [[nodiscard]] auto get_##NAME(KEYTYPE const& key) const \ - -> decltype(OpenVic::_get_property(std::declval>())); \ - ACCESS: - namespace OpenVic { /** * @brief A dictionary-like type that uses std::vector for contiguous storage, @@ -47,13 +35,13 @@ namespace OpenVic { * responsible for ensuring that the underlying data (the `std::vector` or array) * that the `std::span` refers to remains valid and outlives the `IndexedFlatMap` instance. */ - template + template > struct IndexedFlatMap { using keys_span_type = forwardable_span; using values_vector_type = std::conditional_t< std::is_move_constructible_v || std::is_copy_constructible_v, - memory::vector, - memory::FixedVector + std::vector, + FixedVector >; private: @@ -143,8 +131,8 @@ namespace OpenVic { //could be rewritten to return iterators for both this and other. //that would overcomplicate it with const & non-const - template - keys_span_type get_shared_keys(IndexedFlatMap const& other) const { + template + keys_span_type get_shared_keys(IndexedFlatMap const& other) const { if (other.get_min_index() >= min_index && other.get_max_index() <= max_index) { return other.get_keys(); } @@ -168,8 +156,8 @@ namespace OpenVic { * @param other The other IndexedFlatMap to compare with. * @return True if compatible as a subset, false otherwise. */ - template - bool check_subset_span_match(IndexedFlatMap const& other) const { + template + bool check_subset_span_match(IndexedFlatMap const& other) const { // Check if 'other's index range is contained within 'this's index range if (!(other.get_min_index() >= min_index && other.get_max_index() <= max_index)) { spdlog::error_s( @@ -195,11 +183,19 @@ namespace OpenVic { requires std::is_move_constructible_v || std::is_copy_constructible_v : values(), keys(), min_index(0), max_index(0) {} + explicit constexpr IndexedFlatMap(std::type_identity_t const& alloc) + requires std::is_move_constructible_v || std::is_copy_constructible_v + : values(alloc), keys(), min_index(0), max_index(0) {} + //FixedVector constexpr IndexedFlatMap() requires (!std::is_move_constructible_v) && (!std::is_copy_constructible_v) : values(0), keys(), min_index(0), max_index(0) {} + explicit constexpr IndexedFlatMap(std::type_identity_t const& alloc) + requires (!std::is_move_constructible_v) && (!std::is_copy_constructible_v) + : values(0, alloc), keys(), min_index(0), max_index(0) {} + public: static constexpr IndexedFlatMap create_empty() { return {}; @@ -245,6 +241,35 @@ namespace OpenVic { } } + template + requires (std::is_move_constructible_v || std::is_copy_constructible_v) + //value_generator(key) doesn't return std:tuple<...> + && (!specialization_of>, std::tuple>) + //ValueType(value_generator(key)) is valid constructor call + && std::constructible_from()(std::declval()))> + IndexedFlatMap( + keys_span_type new_keys, + GeneratorTemplateType value_generator, + std::type_identity_t const& alloc + ) : keys(new_keys), + min_index { new_keys.front().index }, + max_index { new_keys.back().index }, + values(alloc) { + static_assert(has_index); + if (!validate_new_keys(new_keys)) { + return; + } + + values.reserve(new_keys.size()); + for (ForwardedKeyType const& key : keys) { + values.emplace_back( + std::forward()(std::declval()))>( + value_generator(key) + ) + ); + } + } + /** FixedVector * @brief Constructs an IndexedFlatMap based on a provided span of ordered and continuous keys * and a key-based generator. @@ -634,13 +659,13 @@ namespace OpenVic { // --- Mathematical Operators (Valarray-like functionality) --- // Unary plus operator - IndexedFlatMap operator+() const { + IndexedFlatMap operator+() const { // Unary plus typically returns a copy of itself return *this; } // Unary minus operator - IndexedFlatMap operator-() const + IndexedFlatMap operator-() const requires unary_negatable { static_assert(has_index); return IndexedFlatMap(keys, [&](ForwardedKeyType const& key) { @@ -648,9 +673,12 @@ namespace OpenVic { }); } - template - IndexedFlatMap operator+(IndexedFlatMap const& other) const - requires addable { + template + IndexedFlatMap operator+( // + IndexedFlatMap const& other + ) const + requires addable + { static_assert(has_index); if (!check_subset_span_match(other)) { return IndexedFlatMap(); @@ -670,9 +698,12 @@ namespace OpenVic { }); } - template - IndexedFlatMap operator-(IndexedFlatMap const& other) const - requires subtractable { + template + IndexedFlatMap operator-( // + IndexedFlatMap const& other + ) const + requires subtractable + { static_assert(has_index); if (!check_subset_span_match(other)) { return IndexedFlatMap(); @@ -687,9 +718,12 @@ namespace OpenVic { }); } - template - IndexedFlatMap operator*(IndexedFlatMap const& other) const - requires multipliable { + template + IndexedFlatMap operator*( // + IndexedFlatMap const& other + ) const + requires multipliable + { static_assert(has_index); if (!check_subset_span_match(other)) { return IndexedFlatMap(); @@ -704,9 +738,12 @@ namespace OpenVic { }); } - template - IndexedFlatMap operator/(IndexedFlatMap const& other) const - requires divisible { + template + IndexedFlatMap operator/( // + IndexedFlatMap const& other + ) const + requires divisible + { static_assert(has_index); if (!check_subset_span_match(other)) { return IndexedFlatMap(); @@ -732,9 +769,9 @@ namespace OpenVic { }); } - template - IndexedFlatMap divide_handle_zero( - IndexedFlatMap const& other, + template + IndexedFlatMap divide_handle_zero( + IndexedFlatMap const& other, strict_regular_invocable_r auto&& handle_div_by_zero ) const requires divisible { static_assert(has_index); @@ -759,7 +796,7 @@ namespace OpenVic { // Binary addition operator (Map + Scalar) template - IndexedFlatMap operator+(ScalarType const& scalar) const + IndexedFlatMap operator+(ScalarType const& scalar) const requires addable { static_assert(has_index); return IndexedFlatMap(keys, [&](ForwardedKeyType const& key) { @@ -769,7 +806,7 @@ namespace OpenVic { // Binary subtraction operator (Map - Scalar) template - IndexedFlatMap operator-(ScalarType const& scalar) const + IndexedFlatMap operator-(ScalarType const& scalar) const requires subtractable { static_assert(has_index); return IndexedFlatMap(keys, [&](ForwardedKeyType const& key) { @@ -779,7 +816,7 @@ namespace OpenVic { // Binary multiplication operator (Map * Scalar) template - IndexedFlatMap operator*(ScalarType const& scalar) const + IndexedFlatMap operator*(ScalarType const& scalar) const requires multipliable { static_assert(has_index); return IndexedFlatMap(keys, [&](ForwardedKeyType const& key) { @@ -789,7 +826,7 @@ namespace OpenVic { // Binary division operator (Map / Scalar) template - IndexedFlatMap operator/(ScalarType const& scalar) const + IndexedFlatMap operator/(ScalarType const& scalar) const requires divisible { static_assert(has_index); if (scalar == static_cast(0)) { @@ -806,8 +843,8 @@ namespace OpenVic { }); } - template - IndexedFlatMap& operator+=(IndexedFlatMap const& other) + template + IndexedFlatMap& operator+=(IndexedFlatMap const& other) requires add_assignable { static_assert(has_index); if (!check_subset_span_match(other)) { @@ -821,8 +858,8 @@ namespace OpenVic { return *this; } - template - IndexedFlatMap& operator-=(IndexedFlatMap const& other) + template + IndexedFlatMap& operator-=(IndexedFlatMap const& other) requires subtract_assignable { static_assert(has_index); if (!check_subset_span_match(other)) { @@ -835,8 +872,8 @@ namespace OpenVic { return *this; } - template - IndexedFlatMap& operator*=(IndexedFlatMap const& other) + template + IndexedFlatMap& operator*=(IndexedFlatMap const& other) requires multiply_assignable { static_assert(has_index); if (!check_subset_span_match(other)) { @@ -849,8 +886,8 @@ namespace OpenVic { return *this; } - template - IndexedFlatMap& operator/=(IndexedFlatMap const& other) + template + IndexedFlatMap& operator/=(IndexedFlatMap const& other) requires divide_assignable && equalable { static_assert(has_index); if (!check_subset_span_match(other)) { @@ -1102,41 +1139,41 @@ namespace OpenVic { }; // Non-member binary operators for (Scalar op Map) - template - IndexedFlatMap operator+( + template + IndexedFlatMap operator+( ScalarType const& scalar, - IndexedFlatMap const& map + IndexedFlatMap const& map ) requires addable { return map + scalar; // Delegate to the member operator } - template - IndexedFlatMap operator-( + template + IndexedFlatMap operator-( ValueType const& scalar, - IndexedFlatMap const& map + IndexedFlatMap const& map ) requires subtractable { static_assert(has_index); // Scalar - Map is not simply map - scalar, so we implement it directly - return IndexedFlatMap(map.get_keys(), [&](KeyType const& key) { + return IndexedFlatMap(map.get_keys(), [&](KeyType const& key) { return scalar - map.at(key); }); } - template - IndexedFlatMap operator*( + template + IndexedFlatMap operator*( ScalarType const& scalar, - IndexedFlatMap const& map + IndexedFlatMap const& map ) requires multipliable { return map * scalar; // Delegate to the member operator } - template - IndexedFlatMap operator/( + template + IndexedFlatMap operator/( ScalarType const& scalar, - IndexedFlatMap const& map + IndexedFlatMap const& map ) requires divisible { static_assert(has_index); - return IndexedFlatMap(map.get_keys(), [&](KeyType const& key) { + return IndexedFlatMap(map.get_keys(), [&](KeyType const& key) { if (map.at(key) == static_cast(0)) { spdlog::error_s( "DEVELOPER: OpenVic::IndexedFlatMap<{},{}> scalar division by zero detected at key index {}.", diff --git a/src/openvic-simulation/utility/TslHelper.hpp b/src/openvic-simulation/core/container/MutableIterator.hpp similarity index 98% rename from src/openvic-simulation/utility/TslHelper.hpp rename to src/openvic-simulation/core/container/MutableIterator.hpp index 93dd18c84..28cfd00fa 100644 --- a/src/openvic-simulation/utility/TslHelper.hpp +++ b/src/openvic-simulation/core/container/MutableIterator.hpp @@ -3,7 +3,7 @@ #include #include -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/container/OrderedMap.hpp" namespace OpenVic { template diff --git a/src/openvic-simulation/core/container/OrderedMap.hpp b/src/openvic-simulation/core/container/OrderedMap.hpp new file mode 100644 index 000000000..bb3dfc73c --- /dev/null +++ b/src/openvic-simulation/core/container/OrderedMap.hpp @@ -0,0 +1,219 @@ +#pragma once + +#include +#include +#include + +#include + +#include "openvic-simulation/core/template/StringMapCasing.hpp" + +namespace OpenVic { + // Useful for contiguous memory + template< + class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class Allocator = std::allocator>, class IndexType = std::uint_least32_t> + using vector_ordered_map = + tsl::ordered_map, Allocator>, IndexType>; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template< + class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class Allocator = std::allocator>, class IndexType = std::uint_least32_t> + using deque_ordered_map = + tsl::ordered_map, Allocator>, IndexType>; + + template< + class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class Allocator = std::allocator>, class IndexType = std::uint_least32_t> + using ordered_map = vector_ordered_map; + + // Useful for contiguous memory + template>, class IndexType = std::uint_least32_t> + using case_insensitive_vector_ordered_map = + vector_ordered_map; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template>, class IndexType = std::uint_least32_t> + using case_insensitive_deque_ordered_map = + deque_ordered_map; + + template>, class IndexType = std::uint_least32_t> + using case_insensitive_ordered_map = case_insensitive_vector_ordered_map; + + template + constexpr static ValueType get_total(ordered_map const& map) + requires std::is_default_constructible_v + { + ValueType running_total {}; + for (auto const& [key, value] : map) { + running_total += value; + } + return running_total; + } + + template + constexpr static typename ordered_map::const_iterator get_largest_item( // + ordered_map const& map + ) + requires std::three_way_comparable_with + { + constexpr auto pred = [](typename ordered_map::value_type const& lhs, + typename ordered_map::value_type const& rhs) -> bool { + return lhs.second < rhs.second; + }; + + return std::max_element(map.begin(), map.end(), pred); + } + + /* This function includes a key comparator to choose between entries with equal values. */ + template + constexpr static typename ordered_map::const_iterator get_largest_item_tie_break( // + ordered_map const& map, const auto key_pred + ) + requires std::three_way_comparable_with + { + constexpr auto pred = [key_pred]( + typename ordered_map::value_type const& lhs, + typename ordered_map::value_type const& rhs + ) -> bool { + return lhs.second < rhs.second || (lhs.second == rhs.second && key_pred(lhs.first, rhs.first)); + }; + + return std::max_element(map.begin(), map.end(), pred); + } + + template + constexpr static std::pair< + typename ordered_map::const_iterator, + typename ordered_map::const_iterator> + get_largest_two_items( // + ordered_map const& map + ) + requires std::three_way_comparable_with + { + typename ordered_map::const_iterator largest = map.end(), second_largest = map.end(); + + for (typename ordered_map::const_iterator it = map.begin(); it != map.end(); ++it) { + if (largest == map.end() || it->second > largest->second) { + second_largest = largest; + largest = it; + } else if (second_largest == map.end() || it->second > second_largest->second) { + second_largest = it; + } + } + + return std::make_pair(std::move(largest), std::move(second_largest)); + } + + template + concept derived_ordered_map = derived_from_specialization_of; + + template + constexpr ordered_map + operator-(ordered_map const& rhs) { + ordered_map result {}; + auto view = // + rhs | ranges::views::transform([](KeyType const& key, ValueType const& value) { + return std::make_pair(key, -value); + }); + result.insert(view.begin(), view.end()); + return result; + } + + template + constexpr ordered_map& operator+=( // + ordered_map& lhs, ordered_map const& rhs + ) + requires add_assignable + { + for (auto const& [key, rhs_value] : rhs) { + lhs[key] += rhs_value; + } + return lhs; + } + + template + constexpr ordered_map& operator-=( // + ordered_map& lhs, ordered_map const& rhs + ) + requires subtract_assignable + { + for (auto const& [key, rhs_value] : rhs) { + lhs[key] -= rhs_value; + } + return lhs; + } + + template + constexpr ordered_map& operator*=( // + ordered_map& lhs, ordered_map const& rhs + ) + requires multiply_assignable + { + for (auto const& [key, rhs_value] : rhs) { + lhs[key] *= rhs_value; + } + return lhs; + } + + template + constexpr ordered_map& operator/=( // + ordered_map& lhs, ordered_map const& rhs + ) + requires divide_assignable + { + for (auto const& [key, rhs_value] : rhs) { + lhs[key] = rhs_value; + } + return lhs; + } + + template + constexpr ordered_map& operator+=( // + ordered_map& lhs, RhsValueType const& rhs + ) + requires add_assignable + { + for (typename decltype(lhs)::iterator it = lhs.begin(); it != lhs.end(); ++it) { + it.value() += rhs; + } + return lhs; + } + + template + constexpr ordered_map& operator-=( // + ordered_map& lhs, RhsValueType const& rhs + ) + requires subtract_assignable + { + for (typename decltype(lhs)::iterator it = lhs.begin(); it != lhs.end(); ++it) { + it.value() -= rhs; + } + return lhs; + } + + template + constexpr ordered_map& operator*=( // + ordered_map& lhs, RhsValueType const& rhs + ) + requires multiply_assignable + { + for (typename decltype(lhs)::iterator it = lhs.begin(); it != lhs.end(); ++it) { + it.value() *= rhs; + } + return lhs; + } + + template + constexpr ordered_map& operator/=( // + ordered_map& lhs, RhsValueType const& rhs + ) + requires divide_assignable + { + for (auto it = lhs.begin(); it != lhs.end(); ++it) { + it.value() /= rhs; + } + return lhs; + } +} diff --git a/src/openvic-simulation/core/container/OrderedSet.hpp b/src/openvic-simulation/core/container/OrderedSet.hpp new file mode 100644 index 000000000..0b62d577a --- /dev/null +++ b/src/openvic-simulation/core/container/OrderedSet.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#include + +#include "openvic-simulation/core/template/StringMapCasing.hpp" + +namespace OpenVic { + // Useful for contiguous memory + template< + class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator, + class IndexType = std::uint_least32_t> + using vector_ordered_set = tsl::ordered_set, IndexType>; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template< + class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator, + class IndexType = std::uint_least32_t> + using deque_ordered_set = + tsl::ordered_set, IndexType>; + + template< + class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator, + class IndexType = std::uint_least32_t> + using ordered_set = vector_ordered_set; + + // Useful for contiguous memory + template, class IndexType = std::uint_least32_t> + using case_insensitive_vector_ordered_set = + vector_ordered_set; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template, class IndexType = std::uint_least32_t> + using case_insensitive_deque_ordered_set = + deque_ordered_set; + + template, class IndexType = std::uint_least32_t> + using case_insensitive_ordered_set = case_insensitive_vector_ordered_set; +} diff --git a/src/openvic-simulation/types/RingBuffer.hpp b/src/openvic-simulation/core/container/RingBuffer.hpp similarity index 100% rename from src/openvic-simulation/types/RingBuffer.hpp rename to src/openvic-simulation/core/container/RingBuffer.hpp diff --git a/src/openvic-simulation/types/StackString.hpp b/src/openvic-simulation/core/container/StackString.hpp similarity index 100% rename from src/openvic-simulation/types/StackString.hpp rename to src/openvic-simulation/core/container/StackString.hpp diff --git a/src/openvic-simulation/types/TypedSpan.hpp b/src/openvic-simulation/core/container/TypedSpan.hpp similarity index 100% rename from src/openvic-simulation/types/TypedSpan.hpp rename to src/openvic-simulation/core/container/TypedSpan.hpp diff --git a/src/openvic-simulation/types/ValueHistory.hpp b/src/openvic-simulation/core/container/ValueHistory.hpp similarity index 96% rename from src/openvic-simulation/types/ValueHistory.hpp rename to src/openvic-simulation/core/container/ValueHistory.hpp index b931d4e94..14f6962ab 100644 --- a/src/openvic-simulation/types/ValueHistory.hpp +++ b/src/openvic-simulation/core/container/ValueHistory.hpp @@ -2,7 +2,7 @@ #include -#include "openvic-simulation/types/RingBuffer.hpp" +#include "openvic-simulation/core/container/RingBuffer.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/core/io/BMP.cpp b/src/openvic-simulation/core/io/BMP.cpp index 5e58f7329..04b1d0912 100644 --- a/src/openvic-simulation/core/io/BMP.cpp +++ b/src/openvic-simulation/core/io/BMP.cpp @@ -5,7 +5,7 @@ #include -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/Logger.hpp" @@ -94,7 +94,7 @@ bool BMP::read_header() { // Validate colours #define VALID_BITS_PER_PIXEL 1, 2, 4, 8, 16, 24, 32 #define STR(x) #x - static const ordered_set BITS_PER_PIXEL { VALID_BITS_PER_PIXEL }; + static const memory::ordered_set BITS_PER_PIXEL { VALID_BITS_PER_PIXEL }; if (!BITS_PER_PIXEL.contains(header.bits_per_pixel)) { spdlog::error_s("Invalid BMP bits per pixel: {} (must be one of " STR(VALID_BITS_PER_PIXEL) ")", header.bits_per_pixel); header_validated = false; diff --git a/src/openvic-simulation/core/memory/CowPtr.hpp b/src/openvic-simulation/core/memory/CowPtr.hpp new file mode 100644 index 000000000..7d0564dce --- /dev/null +++ b/src/openvic-simulation/core/memory/CowPtr.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include "openvic-simulation/core/container/CowPtr.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + template< + typename T, typename RawAllocator = foonathan::memory::default_allocator, + typename Allocator = foonathan::memory::std_allocator>> + using cow_ptr = cow_ptr; +} diff --git a/src/openvic-simulation/core/memory/CowVector.hpp b/src/openvic-simulation/core/memory/CowVector.hpp new file mode 100644 index 000000000..929fe3a34 --- /dev/null +++ b/src/openvic-simulation/core/memory/CowVector.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include "openvic-simulation/core/container/CowVector.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + template< + typename T, typename RawAllocator = foonathan::memory::default_allocator, + typename Allocator = foonathan::memory::std_allocator>> + using cow_vector = cow_vector; +} diff --git a/src/openvic-simulation/core/memory/FixedVector.hpp b/src/openvic-simulation/core/memory/FixedVector.hpp new file mode 100644 index 000000000..8ad9c2d73 --- /dev/null +++ b/src/openvic-simulation/core/memory/FixedVector.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include "openvic-simulation/core/container/FixedVector.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + template< + typename T, typename RawAllocator = foonathan::memory::default_allocator, + typename Allocator = foonathan::memory::std_allocator>> + using FixedVector = FixedVector; +} diff --git a/src/openvic-simulation/types/FlagStrings.cpp b/src/openvic-simulation/core/memory/FlagStrings.cpp similarity index 85% rename from src/openvic-simulation/types/FlagStrings.cpp rename to src/openvic-simulation/core/memory/FlagStrings.cpp index 72d3b7b0a..dc03027ff 100644 --- a/src/openvic-simulation/types/FlagStrings.cpp +++ b/src/openvic-simulation/core/memory/FlagStrings.cpp @@ -1,8 +1,10 @@ #include "FlagStrings.hpp" #include "openvic-simulation/utility/Logger.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" using namespace OpenVic; +using namespace OpenVic::memory; FlagStrings::FlagStrings(std::string_view new_name) : name { new_name } {} @@ -42,7 +44,7 @@ bool FlagStrings::has_flag(std::string_view flag) const { return flags.contains(flag); } -bool FlagStrings::apply_flag_map(string_map_t const& flag_map, bool warn) { +bool FlagStrings::apply_flag_map(memory::string_map_t const& flag_map, bool warn) { bool ret = true; for (auto const& [flag, set] : flag_map) { diff --git a/src/openvic-simulation/types/FlagStrings.hpp b/src/openvic-simulation/core/memory/FlagStrings.hpp similarity index 67% rename from src/openvic-simulation/types/FlagStrings.hpp rename to src/openvic-simulation/core/memory/FlagStrings.hpp index da9f256f1..6c165b3b9 100644 --- a/src/openvic-simulation/types/FlagStrings.hpp +++ b/src/openvic-simulation/core/memory/FlagStrings.hpp @@ -2,14 +2,15 @@ #include -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/utility/Getters.hpp" -namespace OpenVic { +namespace OpenVic::memory { struct FlagStrings { private: - string_set_t PROPERTY(flags); + memory::string_set_t PROPERTY(flags); memory::string name; public: @@ -22,6 +23,6 @@ namespace OpenVic { // Go through the map of flags setting or clearing each based on whether // its value is true or false (used for applying history entries). - bool apply_flag_map(string_map_t const& flag_map, bool warn); + bool apply_flag_map(memory::string_map_t const& flag_map, bool warn); }; } diff --git a/src/openvic-simulation/core/memory/IndexedFlatMap.hpp b/src/openvic-simulation/core/memory/IndexedFlatMap.hpp new file mode 100644 index 000000000..979152d5b --- /dev/null +++ b/src/openvic-simulation/core/memory/IndexedFlatMap.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include "openvic-simulation/core/container/IndexedFlatMap.hpp" +#include "openvic-simulation/utility/Getters.hpp" // IWYU pragma: keep +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + template< + typename ForwardedKeyType, typename ValueType, typename RawAllocator = foonathan::memory::default_allocator, + typename Allocator = foonathan::memory::std_allocator>> + using IndexedFlatMap = IndexedFlatMap; +} + +#define OV_IFLATMAP_PROPERTY(KEYTYPE, VALUETYPE, NAME) OV_IFLATMAP_PROPERTY_ACCESS(KEYTYPE, VALUETYPE, NAME, private) +#define OV_IFLATMAP_PROPERTY_ACCESS(KEYTYPE, VALUETYPE, NAME, ACCESS) \ + ::OpenVic::memory::IndexedFlatMap NAME; \ +\ +public: \ + [[nodiscard]] constexpr ::OpenVic::memory::IndexedFlatMap const& get_##NAME() const { \ + return NAME; \ + } \ + [[nodiscard]] auto get_##NAME(KEYTYPE const& key) const \ + -> decltype(OpenVic::_get_property(std::declval>())); \ + ACCESS: diff --git a/src/openvic-simulation/core/memory/OrderedMap.hpp b/src/openvic-simulation/core/memory/OrderedMap.hpp new file mode 100644 index 000000000..393f34eac --- /dev/null +++ b/src/openvic-simulation/core/memory/OrderedMap.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include "openvic-simulation/core/container/OrderedMap.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + // Useful for contiguous memory + template< + class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator, tracker>> + using vector_ordered_map = vector_ordered_map; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template< + class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator, tracker>> + using deque_ordered_map = deque_ordered_map; + + template< + class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator, tracker>> + using ordered_map = ordered_map; + + // Useful for contiguous memory + template< + class Key, class T, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator, memory::tracker>> + using case_insensitive_vector_ordered_map = case_insensitive_vector_ordered_map; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template< + class Key, class T, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator, memory::tracker>> + using case_insensitive_deque_ordered_map = case_insensitive_deque_ordered_map; + + template< + class Key, class T, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator, memory::tracker>> + using case_insensitive_ordered_map = case_insensitive_ordered_map; +} diff --git a/src/openvic-simulation/core/memory/OrderedSet.hpp b/src/openvic-simulation/core/memory/OrderedSet.hpp new file mode 100644 index 000000000..2cd96304f --- /dev/null +++ b/src/openvic-simulation/core/memory/OrderedSet.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include "openvic-simulation/core/container/OrderedSet.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + // Useful for contiguous memory + template< + class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator>> + using vector_ordered_set = vector_ordered_set; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template< + class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator>> + using deque_ordered_set = deque_ordered_set; + + template< + class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, + class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator>> + using ordered_set = ordered_set; + + // Useful for contiguous memory + template< + class Key, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator>> + using case_insensitive_vector_ordered_set = case_insensitive_vector_ordered_set; + + // Useful for stable memory addresses (so long as you don't remove or insert values) + template< + class Key, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator>> + using case_insensitive_deque_ordered_set = case_insensitive_deque_ordered_set; + + template< + class Key, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, + class Allocator = foonathan::memory::std_allocator>> + using case_insensitive_ordered_set = case_insensitive_ordered_set; +} diff --git a/src/openvic-simulation/core/memory/RingBuffer.hpp b/src/openvic-simulation/core/memory/RingBuffer.hpp new file mode 100644 index 000000000..4cbf8a4be --- /dev/null +++ b/src/openvic-simulation/core/memory/RingBuffer.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include "openvic-simulation/core/container/RingBuffer.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + template< + typename T, typename RawAllocator = foonathan::memory::default_allocator, + typename Allocator = foonathan::memory::std_allocator>> + using RingBuffer = RingBuffer; +} diff --git a/src/openvic-simulation/core/memory/StringMap.hpp b/src/openvic-simulation/core/memory/StringMap.hpp new file mode 100644 index 000000000..39c80e9cc --- /dev/null +++ b/src/openvic-simulation/core/memory/StringMap.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include "openvic-simulation/core/container/CaseContainer.hpp" +#include "openvic-simulation/core/container/OrderedMap.hpp" +#include "openvic-simulation/core/template/Concepts.hpp" +#include "openvic-simulation/core/template/StringMapCasing.hpp" + +namespace OpenVic::memory { + /* Template for map with string keys, supporting search by string_view without creating an intermediate string. */ + template + using template_string_map_t = template_case_container_t; + + template + using string_map_t = template_string_map_t; + template + using case_insensitive_string_map_t = template_string_map_t; +} diff --git a/src/openvic-simulation/core/memory/StringSet.hpp b/src/openvic-simulation/core/memory/StringSet.hpp new file mode 100644 index 000000000..32dc70a07 --- /dev/null +++ b/src/openvic-simulation/core/memory/StringSet.hpp @@ -0,0 +1,16 @@ + +#pragma once + +#include "openvic-simulation/core/container/CaseContainer.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" +#include "openvic-simulation/core/template/Concepts.hpp" +#include "openvic-simulation/core/template/StringMapCasing.hpp" + +namespace OpenVic::memory { + /* Template for set with string elements, supporting search by string_view without creating an intermediate string. */ + template + using template_string_set_t = template_case_container_t; + + using string_set_t = template_string_set_t; + using case_insensitive_string_set_t = template_string_set_t; +} diff --git a/src/openvic-simulation/core/memory/ValueHistory.hpp b/src/openvic-simulation/core/memory/ValueHistory.hpp new file mode 100644 index 000000000..903e81c04 --- /dev/null +++ b/src/openvic-simulation/core/memory/ValueHistory.hpp @@ -0,0 +1,14 @@ +#pragma once + +#include "openvic-simulation/core/container/ValueHistory.hpp" +#include "openvic-simulation/utility/MemoryTracker.hpp" + +#include +#include + +namespace OpenVic::memory { + template< + typename T, typename RawAllocator = foonathan::memory::default_allocator, + typename Allocator = foonathan::memory::std_allocator>> + using ValueHistory = ValueHistory; +} diff --git a/src/openvic-simulation/core/portable/ForwardableSpan.hpp b/src/openvic-simulation/core/portable/ForwardableSpan.hpp index fe117bc0f..d326bd9c4 100644 --- a/src/openvic-simulation/core/portable/ForwardableSpan.hpp +++ b/src/openvic-simulation/core/portable/ForwardableSpan.hpp @@ -10,7 +10,7 @@ #include #include "openvic-simulation/core/Typedefs.hpp" -#include "openvic-simulation/types/BasicIterator.hpp" +#include "openvic-simulation/core/container/BasicIterator.hpp" namespace OpenVic::_detail::forwardable_span { static constexpr std::size_t dynamic_extent = std::numeric_limits::max(); diff --git a/src/openvic-simulation/core/template/StringMapCasing.hpp b/src/openvic-simulation/core/template/StringMapCasing.hpp new file mode 100644 index 000000000..f32de3dc0 --- /dev/null +++ b/src/openvic-simulation/core/template/StringMapCasing.hpp @@ -0,0 +1,90 @@ +#pragma once + +#include +#include +#include +#include + +#include "openvic-simulation/core/string/Utility.hpp" +#include "openvic-simulation/utility/Containers.hpp" + +namespace OpenVic { + struct ordered_container_string_hash { + using is_transparent = void; + [[nodiscard]] size_t operator()(char const* txt) const { + return std::hash {}(txt); + } + [[nodiscard]] size_t operator()(std::string_view txt) const { + return std::hash {}(txt); + } + [[nodiscard]] size_t operator()(std::string const& txt) const { + return std::hash {}(txt); + } + [[nodiscard]] size_t operator()(memory::string const& txt) const { + return std::hash {}(txt); + } + }; + + template + struct container_hash : std::hash {}; + + template<> + struct container_hash : ordered_container_string_hash {}; + template<> + struct container_hash : ordered_container_string_hash {}; + template<> + struct container_hash : ordered_container_string_hash {}; + template<> + struct container_hash : ordered_container_string_hash {}; + template + struct container_hash : std::hash {}; + + /* Case-Insensitive Containers */ + struct case_insensitive_string_hash { + using is_transparent = void; + + private: + /* Based on the byte array hashing functions in MSVC's . */ + [[nodiscard]] static constexpr size_t _hash_bytes_case_insensitive(char const* first, size_t count) { + constexpr size_t _offset_basis = 14695981039346656037ULL; + constexpr size_t _prime = 1099511628211ULL; + size_t hash = _offset_basis; + for (size_t i = 0; i < count; ++i) { + hash ^= static_cast(std::tolower(static_cast(first[i]))); + hash *= _prime; + } + return hash; + } + + public: + [[nodiscard]] constexpr size_t operator()(char const* txt) const { + return operator()(std::string_view { txt }); + } + [[nodiscard]] constexpr size_t operator()(std::string_view txt) const { + return _hash_bytes_case_insensitive(txt.data(), txt.length()); + } + [[nodiscard]] constexpr size_t operator()(std::string const& txt) const { + return _hash_bytes_case_insensitive(txt.data(), txt.length()); + } + [[nodiscard]] constexpr size_t operator()(memory::string const& txt) const { + return _hash_bytes_case_insensitive(txt.data(), txt.length()); + } + }; + + struct case_insensitive_string_equal { + using is_transparent = void; + + [[nodiscard]] constexpr bool operator()(std::string_view const& lhs, std::string_view const& rhs) const { + return ascii_equal_case_insensitive(lhs, rhs); + } + }; + + struct StringMapCaseSensitive { + using hash = container_hash; + using equal = std::equal_to<>; + }; + struct StringMapCaseInsensitive { + using hash = case_insensitive_string_hash; + using equal = case_insensitive_string_equal; + }; +} diff --git a/src/openvic-simulation/country/CountryDefinition.cpp b/src/openvic-simulation/country/CountryDefinition.cpp index 3a8a2f63b..be83f707d 100644 --- a/src/openvic-simulation/country/CountryDefinition.cpp +++ b/src/openvic-simulation/country/CountryDefinition.cpp @@ -12,7 +12,7 @@ #include "openvic-simulation/politics/PartyPolicy.hpp" #include "openvic-simulation/population/Culture.hpp" #include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Logger.hpp" using namespace OpenVic; @@ -141,7 +141,7 @@ node_callback_t CountryDefinitionManager::load_country_party( std::string_view party_name; Date start_date, end_date; Ideology const* ideology = nullptr; - IndexedFlatMap policies { politics_manager.get_issue_manager().get_party_policy_groups() }; + memory::IndexedFlatMap policies { politics_manager.get_issue_manager().get_party_policy_groups() }; bool ret = expect_dictionary_keys_and_default( [&politics_manager, &policies, &party_name](std::string_view key, ast::NodeCPtr value) -> bool { diff --git a/src/openvic-simulation/country/CountryDefinition.hpp b/src/openvic-simulation/country/CountryDefinition.hpp index 9d745dc08..e00581ff8 100644 --- a/src/openvic-simulation/country/CountryDefinition.hpp +++ b/src/openvic-simulation/country/CountryDefinition.hpp @@ -4,11 +4,11 @@ #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/country/CountryParty.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { @@ -24,8 +24,8 @@ namespace OpenVic { struct CountryDefinition : HasIdentifierAndColour, HasIndex { friend struct CountryDefinitionManager; - using unit_names_map_t = ordered_map; - using government_colour_map_t = ordered_map; + using unit_names_map_t = memory::ordered_map; + using government_colour_map_t = memory::ordered_map; private: /* Not const to allow elements to be moved, otherwise a copy is forced diff --git a/src/openvic-simulation/country/CountryInstance.cpp b/src/openvic-simulation/country/CountryInstance.cpp index 23cbb7a19..d4e9cf4e3 100644 --- a/src/openvic-simulation/country/CountryInstance.cpp +++ b/src/openvic-simulation/country/CountryInstance.cpp @@ -9,8 +9,11 @@ #include +#include "openvic-simulation/core/container/ClampedValue.hpp" #include "openvic-simulation/core/error/ErrorMacros.hpp" #include "openvic-simulation/country/SharedCountryValues.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/defines/CountryDefines.hpp" #include "openvic-simulation/defines/DiplomacyDefines.hpp" @@ -39,10 +42,8 @@ #include "openvic-simulation/population/PopType.hpp" #include "openvic-simulation/research/Invention.hpp" #include "openvic-simulation/research/Technology.hpp" -#include "openvic-simulation/types/ClampedValue.hpp" #include "openvic-simulation/types/Date.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" #include "openvic-simulation/population/PopSize.hpp" #include "openvic-simulation/population/PopSum.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" @@ -777,7 +778,7 @@ bool CountryInstance::has_leader_with_name(std::string_view name) const { template bool CountryInstance::modify_unit_type_unlock(UnitTypeBranched const& unit_type, technology_unlock_level_t unlock_level_change) { - IndexedFlatMap, technology_unlock_level_t>& unlocked_unit_types = get_unit_type_unlock_levels(); + memory::IndexedFlatMap, technology_unlock_level_t>& unlocked_unit_types = get_unit_type_unlock_levels(); technology_unlock_level_t& unlock_level = unlocked_unit_types.at(unit_type); // This catches subtracting below 0 or adding above the int types maximum value @@ -1184,7 +1185,7 @@ void CountryInstance::apply_foreign_investments( bool CountryInstance::apply_history_to_country( CountryHistoryEntry const& entry, CountryInstanceManager const& country_instance_manager, - FlagStrings& global_flags, + memory::FlagStrings& global_flags, MapInstance& map_instance ) { constexpr auto set_optional = [](T& target, std::optional const& source) { @@ -1229,7 +1230,7 @@ bool CountryInstance::apply_history_to_country( } set_optional_state(tech_school, entry.get_tech_school()); constexpr auto set_bool_map_to_indexed_map = - [](IndexedFlatMap& target, ordered_map source) { + [](memory::IndexedFlatMap& target, memory::ordered_map source) { for (auto const& [key, value] : source) { target[*key] = value; } @@ -1354,7 +1355,7 @@ void CountryInstance::_update_budget() { continue; } - IndexedFlatMap const& state_population_by_type = state.get_population_by_type(); + memory::IndexedFlatMap 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) { @@ -1955,7 +1956,7 @@ void CountryInstance::after_sell(void* actor, SellResult const& sell_result, mem } void CountryInstance::country_tick_before_map( - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_COUNTRY_TICK @@ -2079,7 +2080,7 @@ void CountryInstance::calculate_government_good_needs() { } void CountryInstance::manage_national_stockpile( - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_COUNTRY_TICK @@ -2087,7 +2088,7 @@ void CountryInstance::manage_national_stockpile( memory::vector& reusable_good_index_vector, fixed_point_t& available_funds ) { - IndexedFlatMap& wants_more_mask = reusable_goods_mask; + memory::IndexedFlatMap& wants_more_mask = reusable_goods_mask; const size_t mask_size = wants_more_mask.get_keys().size(); reusable_vectors[0].resize(mask_size, 0); diff --git a/src/openvic-simulation/country/CountryInstance.hpp b/src/openvic-simulation/country/CountryInstance.hpp index 5f5e60950..adf925fed 100644 --- a/src/openvic-simulation/country/CountryInstance.hpp +++ b/src/openvic-simulation/country/CountryInstance.hpp @@ -4,25 +4,27 @@ #include +#include "openvic-simulation/core/container/ClampedValue.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/memory/FlagStrings.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" +#include "openvic-simulation/core/memory/ValueHistory.hpp" #include "openvic-simulation/diplomacy/CountryRelation.hpp" #include "openvic-simulation/military/CombatWidth.hpp" #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp" #include "openvic-simulation/modifier/ModifierSum.hpp" #include "openvic-simulation/politics/Rule.hpp" #include "openvic-simulation/population/PopsAggregate.hpp" -#include "openvic-simulation/types/ClampedValue.hpp" #include "openvic-simulation/types/Date.hpp" #include "openvic-simulation/types/fixed_point/Atomic.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" -#include "openvic-simulation/types/FlagStrings.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/research/TechnologyUnlockLevel.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" #include "openvic-simulation/types/UnitVariant.hpp" -#include "openvic-simulation/types/ValueHistory.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/reactive/DerivedState.hpp" @@ -80,7 +82,7 @@ namespace OpenVic { /* Representation of a country's mutable attributes, with a CountryDefinition that is unique at any single time * but can be swapped with other CountryInstance's CountryDefinition when switching tags. */ - struct CountryInstance : FlagStrings, HasIndex, PopsAggregate { + struct CountryInstance : memory::FlagStrings, HasIndex, PopsAggregate { friend struct CountryInstanceManager; /* @@ -136,14 +138,14 @@ namespace OpenVic { Date PROPERTY(lose_great_power_date); size_t PROPERTY(total_rank, 0); - ordered_set PROPERTY(owned_provinces); - ordered_set PROPERTY(controlled_provinces); - ordered_set PROPERTY(core_provinces); - ordered_set PROPERTY(states); + memory::ordered_set PROPERTY(owned_provinces); + memory::ordered_set PROPERTY(controlled_provinces); + memory::ordered_set PROPERTY(core_provinces); + memory::ordered_set PROPERTY(states); - ordered_set PROPERTY(neighbouring_countries); + memory::ordered_set PROPERTY(neighbouring_countries); - string_map_t PROPERTY(script_variables); + memory::string_map_t PROPERTY(script_variables); // The total/resultant modifier affecting this country, including owned province contributions. ModifierSum PROPERTY(modifier_sum); @@ -160,19 +162,19 @@ namespace OpenVic { /* Budget */ fixed_point_t cash_stockpile_start_of_tick; - ValueHistory PROPERTY(balance_history); + memory::ValueHistory PROPERTY(balance_history); OV_STATE_PROPERTY(fixed_point_t, gold_income); atomic_fixed_point_t PROPERTY(cash_stockpile); std::mutex taxable_income_mutex; OV_IFLATMAP_PROPERTY(PopType, fixed_point_t, taxable_income_by_pop_type); OV_STATE_PROPERTY(fixed_point_t, tax_efficiency); - IndexedFlatMap> PROPERTY(effective_tax_rate_by_strata); + memory::IndexedFlatMap> PROPERTY(effective_tax_rate_by_strata); public: DerivedState& get_effective_tax_rate_by_strata(Strata const& strata); private: - IndexedFlatMap tax_rate_slider_value_by_strata; + memory::IndexedFlatMap tax_rate_slider_value_by_strata; public: - [[nodiscard]] constexpr IndexedFlatMap const& get_tax_rate_slider_value_by_strata() const { + [[nodiscard]] constexpr memory::IndexedFlatMap const& get_tax_rate_slider_value_by_strata() const { return tax_rate_slider_value_by_strata; } [[nodiscard]] ReadOnlyClampedValue& get_tax_rate_slider_value_by_strata(Strata const& strata); @@ -217,10 +219,10 @@ namespace OpenVic { atomic_fixed_point_t PROPERTY(actual_unemployment_subsidies_spending); //base here means not scaled by slider or pop size - IndexedFlatMap> administration_salary_base_by_pop_type; - IndexedFlatMap> education_salary_base_by_pop_type; - IndexedFlatMap> military_salary_base_by_pop_type; - IndexedFlatMap> social_income_variant_base_by_pop_type; + memory::IndexedFlatMap> administration_salary_base_by_pop_type; + memory::IndexedFlatMap> education_salary_base_by_pop_type; + memory::IndexedFlatMap> military_salary_base_by_pop_type; + memory::IndexedFlatMap> social_income_variant_base_by_pop_type; OV_CLAMPED_PROPERTY(tariff_rate_slider_value); fixed_point_t actual_import_subsidies_budget; @@ -269,7 +271,7 @@ namespace OpenVic { /* Population */ size_t PROPERTY(national_focus_capacity, 0); Culture const* PROPERTY(primary_culture, nullptr); - ordered_set PROPERTY(accepted_cultures); + memory::ordered_set PROPERTY(accepted_cultures); Religion const* PROPERTY(religion, nullptr); // TODO - population change over last 30 days @@ -320,9 +322,9 @@ namespace OpenVic { fixed_point_t pop_demand; fixed_point_t available_amount; - ordered_map need_consumption_per_pop_type; - ordered_map input_consumption_per_production_type; - ordered_map production_per_production_type; + memory::ordered_map need_consumption_per_pop_type; + memory::ordered_map input_consumption_per_production_type; + memory::ordered_map production_per_production_type; good_data_t(); good_data_t(good_data_t&&) = default; @@ -342,7 +344,7 @@ namespace OpenVic { // The last time this country lost a war, i.e. accepted a peace offer sent from their offer tab or the enemy's demand // tab, even white peace. Used for the "has_recently_lost_war" condition (true if the date is less than 5 years ago). Date PROPERTY(last_war_loss_date); - vector_ordered_set PROPERTY(war_enemies); + memory::vector_ordered_set PROPERTY(war_enemies); OV_STATE_PROPERTY(CountryInstance const*, sphere_owner, nullptr); // TODO - colonial power, current wars @@ -611,7 +613,7 @@ namespace OpenVic { bool apply_history_to_country( CountryHistoryEntry const& entry, CountryInstanceManager const& country_instance_manager, - FlagStrings& global_flags, + memory::FlagStrings& global_flags, MapInstance& map_instance ); @@ -623,7 +625,7 @@ namespace OpenVic { void calculate_government_good_needs(); void manage_national_stockpile( - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_COUNTRY_TICK @@ -661,7 +663,7 @@ namespace OpenVic { void update_gamestate(const Date today, MapInstance& map_instance); void country_tick_before_map( - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_COUNTRY_TICK diff --git a/src/openvic-simulation/country/CountryInstanceManager.cpp b/src/openvic-simulation/country/CountryInstanceManager.cpp index 978bd4c8b..3e7ad349c 100644 --- a/src/openvic-simulation/country/CountryInstanceManager.cpp +++ b/src/openvic-simulation/country/CountryInstanceManager.cpp @@ -212,7 +212,7 @@ bool CountryInstanceManager::apply_history_to_countries(InstanceManager& instanc MapInstance& map_instance = instance_manager.get_map_instance(); const Date starting_last_war_loss_date = today - RECENT_WAR_LOSS_TIME_LIMIT; - FlagStrings& global_flags = instance_manager.get_global_flags(); + memory::FlagStrings& global_flags = instance_manager.get_global_flags(); for (CountryInstance& country_instance : get_country_instances()) { country_instance.last_war_loss_date = starting_last_war_loss_date; diff --git a/src/openvic-simulation/country/CountryInstanceManager.hpp b/src/openvic-simulation/country/CountryInstanceManager.hpp index 665c260ba..5b93557bc 100644 --- a/src/openvic-simulation/country/CountryInstanceManager.hpp +++ b/src/openvic-simulation/country/CountryInstanceManager.hpp @@ -2,10 +2,10 @@ #include +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/country/SharedCountryValues.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/Getters.hpp" diff --git a/src/openvic-simulation/country/CountryParty.hpp b/src/openvic-simulation/country/CountryParty.hpp index 1ce804852..b50867d59 100644 --- a/src/openvic-simulation/country/CountryParty.hpp +++ b/src/openvic-simulation/country/CountryParty.hpp @@ -1,8 +1,8 @@ #pragma once +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" #include "openvic-simulation/utility/Getters.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/country/SharedCountryValues.cpp b/src/openvic-simulation/country/SharedCountryValues.cpp index 045c75772..891756048 100644 --- a/src/openvic-simulation/country/SharedCountryValues.cpp +++ b/src/openvic-simulation/country/SharedCountryValues.cpp @@ -4,7 +4,6 @@ #include "openvic-simulation/economy/GoodInstance.hpp" #include "openvic-simulation/population/PopNeedsMacro.hpp" #include "openvic-simulation/population/PopType.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" using namespace OpenVic; diff --git a/src/openvic-simulation/country/SharedCountryValues.hpp b/src/openvic-simulation/country/SharedCountryValues.hpp index c163b3b8e..89bc89918 100644 --- a/src/openvic-simulation/country/SharedCountryValues.hpp +++ b/src/openvic-simulation/country/SharedCountryValues.hpp @@ -1,7 +1,7 @@ #pragma once #include "openvic-simulation/population/PopNeedsMacro.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/utility/reactive/MutableState.hpp" diff --git a/src/openvic-simulation/dataloader/Dataloader.cpp b/src/openvic-simulation/dataloader/Dataloader.cpp index 887fabdf0..85dae550b 100644 --- a/src/openvic-simulation/dataloader/Dataloader.cpp +++ b/src/openvic-simulation/dataloader/Dataloader.cpp @@ -13,6 +13,8 @@ #include #include "openvic-simulation/DefinitionManager.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/interface/UI.hpp" #include "openvic-simulation/misc/GameRulesManager.hpp" #include "openvic-simulation/misc/SoundEffect.hpp" @@ -156,7 +158,7 @@ Dataloader::path_vector_t Dataloader::_lookup_files_in_dir( fs::path file; fs::path const* root = nullptr; }; - string_map_t found_files; + memory::string_map_t found_files; for (fs::path const& root : roots) { const size_t root_len = root.string().size(); std::error_code ec; @@ -226,9 +228,9 @@ bool Dataloader::apply_to_files(path_span_t files, apply_files_callback_t callba return ret; } -string_set_t Dataloader::lookup_dirs_in_dir(std::string_view path) const { +memory::string_set_t Dataloader::lookup_dirs_in_dir(std::string_view path) const { const fs::path dirpath { ensure_forward_slash_path(path) }; - string_set_t ret; + memory::string_set_t ret; for (fs::path const& root : roots) { std::error_code ec; for (fs::directory_entry const& entry : fs::directory_iterator { root / dirpath, ec }) { @@ -652,7 +654,7 @@ bool Dataloader::_load_history(DefinitionManager& definition_manager, bool unuse /* Pop History */ static constexpr std::string_view pop_history_directory = "history/pops/"; - const string_set_t pop_history_dirs = lookup_dirs_in_dir(pop_history_directory); + const memory::string_set_t pop_history_dirs = lookup_dirs_in_dir(pop_history_directory); const Date last_bookmark_date = definition_manager.get_history_manager().get_bookmark_manager().get_last_bookmark_date(); diff --git a/src/openvic-simulation/dataloader/Dataloader.hpp b/src/openvic-simulation/dataloader/Dataloader.hpp index ef268f275..7f81025b7 100644 --- a/src/openvic-simulation/dataloader/Dataloader.hpp +++ b/src/openvic-simulation/dataloader/Dataloader.hpp @@ -6,6 +6,7 @@ #include #include +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/dataloader/ModManager.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -121,7 +122,7 @@ namespace OpenVic { using apply_files_callback_t = fu2::function_base, false, false, bool(fs::path const&)>; bool apply_to_files(path_span_t files, apply_files_callback_t callback) const; - string_set_t lookup_dirs_in_dir(std::string_view path) const; + memory::string_set_t lookup_dirs_in_dir(std::string_view path) const; /* Load all mod descriptors present in the mod/ directory. Importantly, loads dependencies and replace_paths for us to check. */ bool load_mod_descriptors(ModManager& mod_manager) const; diff --git a/src/openvic-simulation/dataloader/ModManager.cpp b/src/openvic-simulation/dataloader/ModManager.cpp index 79d013eac..c8933af22 100644 --- a/src/openvic-simulation/dataloader/ModManager.cpp +++ b/src/openvic-simulation/dataloader/ModManager.cpp @@ -4,9 +4,9 @@ #include "openvic-simulation/core/error/ErrorMacros.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/core/FormatValidate.hpp" using namespace OpenVic; @@ -27,13 +27,13 @@ Mod::Mod( replace_paths { new_replace_paths }, dependencies { new_dependencies } {} -vector_ordered_set Mod::generate_dependency_list(bool* success) const { +memory::vector_ordered_set Mod::generate_dependency_list(bool* success) const { static constexpr size_t MAX_RECURSE = 16; size_t current_recurse = 0; - vector_ordered_set result; + memory::vector_ordered_set result; - auto dep_cycle = [this, ¤t_recurse](auto self, Mod const* mod, vector_ordered_set& dep_list) -> bool { + auto dep_cycle = [this, ¤t_recurse](auto self, Mod const* mod, memory::vector_ordered_set& dep_list) -> bool { bool ret = true; for (std::string_view dep_identifier : mod->get_dependencies()) { if (!mod_manager.has_mod_identifier(dep_identifier)) { diff --git a/src/openvic-simulation/dataloader/ModManager.hpp b/src/openvic-simulation/dataloader/ModManager.hpp index b0969458e..a56aac763 100644 --- a/src/openvic-simulation/dataloader/ModManager.hpp +++ b/src/openvic-simulation/dataloader/ModManager.hpp @@ -3,8 +3,9 @@ #include #include -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" namespace OpenVic { @@ -29,7 +30,7 @@ namespace OpenVic { ); Mod(Mod&&) = default; - vector_ordered_set generate_dependency_list(bool* success = nullptr) const; + memory::vector_ordered_set generate_dependency_list(bool* success = nullptr) const; }; struct ModManager { diff --git a/src/openvic-simulation/dataloader/NodeTools.cpp b/src/openvic-simulation/dataloader/NodeTools.cpp index 0ccb2e631..e34add525 100644 --- a/src/openvic-simulation/dataloader/NodeTools.cpp +++ b/src/openvic-simulation/dataloader/NodeTools.cpp @@ -19,6 +19,7 @@ #include "openvic-simulation/core/ui/TextFormat.hpp" #include "openvic-simulation/types/Vector.hpp" #include "openvic-simulation/utility/Getters.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" using namespace OpenVic; using namespace OpenVic::NodeTools; @@ -135,7 +136,7 @@ node_callback_t NodeTools::expect_identifier_or_string(callback_t callback) { - static const case_insensitive_string_map_t bool_map { { "yes", true }, { "no", false } }; + static const memory::case_insensitive_string_map_t bool_map { { "yes", true }, { "no", false } }; return expect_identifier(expect_mapped_string(bool_map, callback)); } @@ -284,7 +285,7 @@ NodeCallback auto _expect_vec2(Callback> auto&& callback) { node_callback_t NodeTools::expect_text_format(callback_t callback) { using enum text_format_t; - static const string_map_t format_map = { + static const memory::string_map_t format_map = { { "left", left }, { "right", right }, { "centre", centre }, diff --git a/src/openvic-simulation/dataloader/NodeTools.hpp b/src/openvic-simulation/dataloader/NodeTools.hpp index 1ab1a890f..697c5e9bb 100644 --- a/src/openvic-simulation/dataloader/NodeTools.hpp +++ b/src/openvic-simulation/dataloader/NodeTools.hpp @@ -16,15 +16,15 @@ #include +#include "openvic-simulation/core/container/MutableIterator.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/types/Colour.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/core/ui/TextFormat.hpp" #include "openvic-simulation/types/Vector.hpp" #include "openvic-simulation/core/FormatValidate.hpp" #include "openvic-simulation/utility/Getters.hpp" -#include "openvic-simulation/utility/TslHelper.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/core/template/Concepts.hpp" #include "openvic-simulation/core/string/Utility.hpp" @@ -319,7 +319,7 @@ using namespace std::string_view_literals; using enum dictionary_entry_t::expected_count_t; template - using template_key_map_t = template_string_map_t; + using template_key_map_t = memory::template_string_map_t; using key_map_t = template_key_map_t; using case_insensitive_key_map_t = template_key_map_t; @@ -573,10 +573,10 @@ using namespace std::string_view_literals; template Callback auto expect_mapped_string( - template_string_map_t const& map, Callback auto&& callback, bool warn = false + memory::template_string_map_t const& map, Callback auto&& callback, bool warn = false ) { return [&map, callback = FWD(callback), warn](std::string_view string) mutable -> bool { - const typename template_string_map_t::const_iterator it = map.find(string); + const typename memory::template_string_map_t::const_iterator it = map.find(string); if (it != map.end()) { return callback(it->second); } @@ -764,7 +764,7 @@ using namespace std::string_view_literals; template Callback auto map_callback( - IndexedFlatMap& map, Key const* key, bool warn = false + memory::IndexedFlatMap& map, Key const* key, bool warn = false ) { return [&map, key, warn](Value value) -> bool { if (key == nullptr) { diff --git a/src/openvic-simulation/dataloader/Vic2PathSearch.cpp b/src/openvic-simulation/dataloader/Vic2PathSearch.cpp index 11c079dc7..f7a320693 100644 --- a/src/openvic-simulation/dataloader/Vic2PathSearch.cpp +++ b/src/openvic-simulation/dataloader/Vic2PathSearch.cpp @@ -9,7 +9,7 @@ #include -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/utility/ConstexprIntToStr.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/Logger.hpp" @@ -377,7 +377,7 @@ fs::path Dataloader::search_for_game_path(fs::path hint_path) { }; using hint_path_t = fs::path; using game_path_t = fs::path; - static ordered_map _cached_paths; + static memory::ordered_map _cached_paths; auto it = _cached_paths.find(hint_path); if (it != _cached_paths.end()) { diff --git a/src/openvic-simulation/diplomacy/CountryRelation.hpp b/src/openvic-simulation/diplomacy/CountryRelation.hpp index 915e89763..78410db55 100644 --- a/src/openvic-simulation/diplomacy/CountryRelation.hpp +++ b/src/openvic-simulation/diplomacy/CountryRelation.hpp @@ -10,7 +10,8 @@ #include #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" +#include "openvic-simulation/core/Compare.hpp" #include "openvic-simulation/core/Hash.hpp" namespace OpenVic { @@ -244,7 +245,7 @@ namespace OpenVic { private: #define RELATION_PAIR_MAP(PAIR_TYPE, VALUE_TYPE, NAME, FUNC_NAME, RECIPIENT_CONST) \ - vector_ordered_map NAME; \ + memory::vector_ordered_map NAME; \ \ public: \ VALUE_TYPE get_##FUNC_NAME(CountryInstance const* country, CountryInstance const* recipient) const; \ @@ -268,8 +269,8 @@ public: \ RELATION_PAIR_MAP(CountryInstancePair, influence_value_type, influence, influence_with, const); RELATION_PAIR_MAP(CountryInstancePair, influence_priority_value_type, influence_priority, influence_priority_with, const); - vector_ordered_map discredits; - vector_ordered_map embassy_bans; + memory::vector_ordered_map discredits; + memory::vector_ordered_map embassy_bans; public: std::optional get_discredited_date(CountryInstance const* country, CountryInstance const* recipient) const; diff --git a/src/openvic-simulation/diplomacy/DiplomaticAction.cpp b/src/openvic-simulation/diplomacy/DiplomaticAction.cpp index 92f7ea98c..51bea2658 100644 --- a/src/openvic-simulation/diplomacy/DiplomaticAction.cpp +++ b/src/openvic-simulation/diplomacy/DiplomaticAction.cpp @@ -7,7 +7,7 @@ #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/diplomacy/CountryRelation.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Logger.hpp" using namespace OpenVic; diff --git a/src/openvic-simulation/diplomacy/DiplomaticAction.hpp b/src/openvic-simulation/diplomacy/DiplomaticAction.hpp index 7b2eef30f..96cfd3cc6 100644 --- a/src/openvic-simulation/diplomacy/DiplomaticAction.hpp +++ b/src/openvic-simulation/diplomacy/DiplomaticAction.hpp @@ -9,7 +9,7 @@ #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/diplomacy/CountryRelation.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include diff --git a/src/openvic-simulation/economy/BuildingInstance.hpp b/src/openvic-simulation/economy/BuildingInstance.hpp index 1351f1ce4..c3bb49ac8 100644 --- a/src/openvic-simulation/economy/BuildingInstance.hpp +++ b/src/openvic-simulation/economy/BuildingInstance.hpp @@ -3,7 +3,7 @@ #include "openvic-simulation/economy/BuildingLevel.hpp" #include "openvic-simulation/types/Date.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" namespace OpenVic { struct BuildingType; diff --git a/src/openvic-simulation/economy/BuildingType.hpp b/src/openvic-simulation/economy/BuildingType.hpp index e55ad4799..38f27ebaa 100644 --- a/src/openvic-simulation/economy/BuildingType.hpp +++ b/src/openvic-simulation/economy/BuildingType.hpp @@ -1,10 +1,11 @@ #pragma once #include "openvic-simulation/modifier/Modifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/economy/BuildingLevel.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -81,7 +82,7 @@ namespace OpenVic { struct BuildingTypeManager { private: IdentifierRegistry IDENTIFIER_REGISTRY(building_type); - string_set_t PROPERTY(building_type_types); + memory::string_set_t PROPERTY(building_type_types); memory::vector SPAN_PROPERTY(province_building_types); BuildingType const* PROPERTY(port_building_type); diff --git a/src/openvic-simulation/economy/GoodDefinition.cpp b/src/openvic-simulation/economy/GoodDefinition.cpp index dc63c6e61..1e59c3a89 100644 --- a/src/openvic-simulation/economy/GoodDefinition.cpp +++ b/src/openvic-simulation/economy/GoodDefinition.cpp @@ -136,7 +136,7 @@ bool GoodDefinitionManager::generate_modifiers(ModifierManager& modifier_manager using enum ModifierEffect::format_t; using enum ModifierEffect::target_t; - IndexedFlatMap& good_effects = + memory::IndexedFlatMap& good_effects = modifier_manager.modifier_effect_cache.good_effects; good_effects = std::move(decltype(ModifierEffectCache::good_effects){get_good_definitions()}); diff --git a/src/openvic-simulation/economy/GoodDefinition.hpp b/src/openvic-simulation/economy/GoodDefinition.hpp index b298c8f22..2a4a7d667 100644 --- a/src/openvic-simulation/economy/GoodDefinition.hpp +++ b/src/openvic-simulation/economy/GoodDefinition.hpp @@ -1,8 +1,8 @@ #pragma once -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/utility/Containers.hpp" diff --git a/src/openvic-simulation/economy/GoodInstance.hpp b/src/openvic-simulation/economy/GoodInstance.hpp index b51194321..ec3390b68 100644 --- a/src/openvic-simulation/economy/GoodInstance.hpp +++ b/src/openvic-simulation/economy/GoodInstance.hpp @@ -1,9 +1,9 @@ #pragma once #include "openvic-simulation/economy/trading/GoodMarket.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/economy/production/ArtisanalProducer.cpp b/src/openvic-simulation/economy/production/ArtisanalProducer.cpp index 7cf8d1a87..db299e698 100644 --- a/src/openvic-simulation/economy/production/ArtisanalProducer.cpp +++ b/src/openvic-simulation/economy/production/ArtisanalProducer.cpp @@ -26,7 +26,7 @@ using namespace OpenVic; ArtisanalProducer::ArtisanalProducer(ArtisanalProducerDeps const& artisanal_producer_deps) : ArtisanalProducer( artisanal_producer_deps, - IndexedFlatMap { artisanal_producer_deps.good_keys }, + memory::IndexedFlatMap { artisanal_producer_deps.good_keys }, nullptr, nullptr, fixed_point_t::_0 @@ -34,7 +34,7 @@ ArtisanalProducer::ArtisanalProducer(ArtisanalProducerDeps const& artisanal_prod ArtisanalProducer::ArtisanalProducer( ArtisanalProducerDeps const& artisanal_producer_deps, - IndexedFlatMap&& new_stockpile, + memory::IndexedFlatMap&& new_stockpile, ProductionType const* const new_production_type, GoodDefinition const* const new_last_produced_good, fixed_point_t new_current_production @@ -64,7 +64,7 @@ void ArtisanalProducer::set_production_type(ProductionType const* const new_prod } void ArtisanalProducer::artisan_tick_handler::calculate_inputs( - IndexedFlatMap const& stockpile, + memory::IndexedFlatMap const& stockpile, const bool should_report_input_demand ) { fixed_point_map_t const& input_goods = production_type.get_input_goods(); @@ -118,7 +118,7 @@ void ArtisanalProducer::artisan_tick_handler::calculate_inputs( void ArtisanalProducer::artisan_tick_handler::produce( fixed_point_t& costs_of_production, fixed_point_t& current_production, - IndexedFlatMap& stockpile + memory::IndexedFlatMap& stockpile ) { fixed_point_t produce_left_to_sell = current_production = production_type.base_output_quantity * inputs_bought_fraction; @@ -178,7 +178,7 @@ void ArtisanalProducer::artisan_tick_handler::allocate_money_for_inputs( fixed_point_map_t& max_quantity_to_buy_per_good, memory::vector& pop_max_quantity_to_buy_per_good, memory::vector& pop_money_to_spend_per_good, - IndexedFlatMap const& stockpile, + memory::IndexedFlatMap const& stockpile, PopValuesFromProvince const& values_from_province ) { //executed once per pop while nothing else uses it. @@ -287,7 +287,7 @@ void ArtisanalProducer::artisan_tick( Pop& pop, PopValuesFromProvince const& values_from_province, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, memory::vector& pop_max_quantity_to_buy_per_good, memory::vector& pop_money_to_spend_per_good, memory::vector& reusable_map_0, @@ -296,7 +296,7 @@ void ArtisanalProducer::artisan_tick( ) { CountryInstance* const country_to_report_economy_nullable = pop.get_location()->get_country_to_report_economy(); max_quantity_to_buy_per_good.clear(); - IndexedFlatMap& wants_more_mask = reusable_goods_mask; + memory::IndexedFlatMap& wants_more_mask = reusable_goods_mask; memory::vector& max_price_per_input = reusable_map_0; memory::vector& demand_per_input = reusable_map_1; diff --git a/src/openvic-simulation/economy/production/ArtisanalProducer.hpp b/src/openvic-simulation/economy/production/ArtisanalProducer.hpp index fa06298f8..6ce79a93e 100644 --- a/src/openvic-simulation/economy/production/ArtisanalProducer.hpp +++ b/src/openvic-simulation/economy/production/ArtisanalProducer.hpp @@ -3,7 +3,7 @@ #include #include -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" #include "openvic-simulation/types/fixed_point/Fraction.hpp" @@ -28,7 +28,7 @@ namespace OpenVic { private: EconomyDefines const& economy_defines; ModifierEffectCache const& modifier_effect_cache; - IndexedFlatMap stockpile; + memory::IndexedFlatMap stockpile; //only used during day tick (from artisan_tick() until MarketInstance.execute_orders()) fixed_point_map_t max_quantity_to_buy_per_good; @@ -55,7 +55,7 @@ namespace OpenVic { ArtisanalProducer(ArtisanalProducerDeps const& artisanal_producer_deps); ArtisanalProducer( ArtisanalProducerDeps const& artisanal_producer_deps, - IndexedFlatMap&& new_stockpile, + memory::IndexedFlatMap&& new_stockpile, ProductionType const* const new_production_type, GoodDefinition const* const new_last_produced_good, const fixed_point_t new_current_production @@ -66,7 +66,7 @@ namespace OpenVic { Pop& pop, PopValuesFromProvince const& values_from_province, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, memory::vector& pop_max_quantity_to_buy_per_good, memory::vector& pop_money_to_spend_per_good, memory::vector& reusable_map_0, @@ -98,7 +98,7 @@ namespace OpenVic { memory::vector& max_price_per_input; Pop& pop; ProductionType const& production_type; - IndexedFlatMap& wants_more_mask; + memory::IndexedFlatMap& wants_more_mask; public: artisan_tick_handler( @@ -108,7 +108,7 @@ namespace OpenVic { memory::vector& new_max_price_per_input, Pop& new_pop, ProductionType const& new_production_type, - IndexedFlatMap& new_wants_more_mask + memory::IndexedFlatMap& new_wants_more_mask ) : country_to_report_economy_nullable { new_country_to_report_economy_nullable }, demand_per_input { new_demand_per_input }, market_instance { new_market_instance }, @@ -118,19 +118,19 @@ namespace OpenVic { wants_more_mask { new_wants_more_mask } {} void calculate_inputs( - IndexedFlatMap const& stockpile, + memory::IndexedFlatMap const& stockpile, const bool should_report_input_demand ); void produce( fixed_point_t& costs_of_production, fixed_point_t& current_production, - IndexedFlatMap& stockpile + memory::IndexedFlatMap& stockpile ); void allocate_money_for_inputs( fixed_point_map_t& max_quantity_to_buy_per_good, memory::vector& pop_max_quantity_to_buy_per_good, memory::vector& pop_money_to_spend_per_good, - IndexedFlatMap const& stockpile, + memory::IndexedFlatMap const& stockpile, PopValuesFromProvince const& values_from_province ); }; diff --git a/src/openvic-simulation/economy/production/FactoryProducer.cpp b/src/openvic-simulation/economy/production/FactoryProducer.cpp index 333f67a9e..08d19d77a 100644 --- a/src/openvic-simulation/economy/production/FactoryProducer.cpp +++ b/src/openvic-simulation/economy/production/FactoryProducer.cpp @@ -1,5 +1,7 @@ #include "FactoryProducer.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" + using namespace OpenVic; FactoryProducer::FactoryProducer( @@ -8,7 +10,7 @@ FactoryProducer::FactoryProducer( fixed_point_t new_revenue_yesterday, fixed_point_t new_output_quantity_yesterday, fixed_point_t new_unsold_quantity_yesterday, - ordered_map&& new_employees, + memory::ordered_map&& new_employees, fixed_point_map_t&& new_stockpile, fixed_point_t new_budget, fixed_point_t new_balance_yesterday, diff --git a/src/openvic-simulation/economy/production/FactoryProducer.hpp b/src/openvic-simulation/economy/production/FactoryProducer.hpp index 380419e9a..51d18e6b9 100644 --- a/src/openvic-simulation/economy/production/FactoryProducer.hpp +++ b/src/openvic-simulation/economy/production/FactoryProducer.hpp @@ -2,9 +2,9 @@ #include +#include "openvic-simulation/core/memory/OrderedMap.hpp" #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/population/PopSize.hpp" #include "openvic-simulation/utility/Getters.hpp" @@ -24,7 +24,7 @@ namespace OpenVic { fixed_point_t PROPERTY(output_quantity_yesterday); fixed_point_t PROPERTY(unsold_quantity_yesterday); fixed_point_t PROPERTY(size_multiplier); - ordered_map PROPERTY(employees); + memory::ordered_map PROPERTY(employees); fixed_point_map_t PROPERTY(stockpile); fixed_point_t PROPERTY(budget); fixed_point_t PROPERTY(balance_yesterday); @@ -42,7 +42,7 @@ namespace OpenVic { FactoryProducer( ProductionType const& new_production_type, fixed_point_t new_size_multiplier, fixed_point_t new_revenue_yesterday, fixed_point_t new_output_quantity_yesterday, fixed_point_t new_unsold_quantity_yesterday, - ordered_map&& new_employees, fixed_point_map_t&& new_stockpile, + memory::ordered_map&& new_employees, fixed_point_map_t&& new_stockpile, fixed_point_t new_budget, fixed_point_t new_balance_yesterday, fixed_point_t new_received_investments_yesterday, fixed_point_t new_market_spendings_yesterday, fixed_point_t new_paychecks_yesterday, uint32_t new_unprofitable_days, uint32_t new_subsidised_days, uint32_t new_days_without_input, uint8_t new_hiring_priority, diff --git a/src/openvic-simulation/economy/production/ProductionType.cpp b/src/openvic-simulation/economy/production/ProductionType.cpp index c2a00c64a..593390768 100644 --- a/src/openvic-simulation/economy/production/ProductionType.cpp +++ b/src/openvic-simulation/economy/production/ProductionType.cpp @@ -3,6 +3,9 @@ #include #include "openvic-simulation/core/error/ErrorMacros.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/economy/GoodDefinition.hpp" #include "openvic-simulation/misc/GameRulesManager.hpp" @@ -106,7 +109,7 @@ node_callback_t ProductionTypeManager::_expect_job( Job::effect_t effect_type { THROUGHPUT }; fixed_point_t effect_multiplier = 1, desired_workforce_share = 1; - static const string_map_t effect_map = { + static const memory::string_map_t effect_map = { { "input", INPUT }, { "output", OUTPUT }, { "throughput", THROUGHPUT } }; @@ -259,8 +262,8 @@ bool ProductionTypeManager::load_production_types_file( size_t expected_types = 0; /* Pass #1: find and store template identifiers */ - ordered_set templates; - ordered_map template_target_map; + memory::ordered_set templates; + memory::ordered_map template_target_map; bool ret = expect_dictionary( [this, &expected_types, &templates, &template_target_map, &template_symbol, &output_goods_symbol] (std::string_view key, ast::NodeCPtr value) -> bool { @@ -300,7 +303,7 @@ bool ProductionTypeManager::load_production_types_file( )(parser.get_file_node()); /* Pass #2: create and populate the template map */ - ordered_map template_node_map; + memory::ordered_map template_node_map; ret &= expect_dictionary( [this, &expected_types, &templates, &template_node_map](std::string_view key, ast::NodeCPtr value) -> bool { if (templates.contains(key)) { @@ -336,7 +339,7 @@ bool ProductionTypeManager::load_production_types_file( bool ret = true; - static const string_map_t template_type_map = { + static const memory::string_map_t template_type_map = { { "factory", FACTORY }, { "rgo", RGO }, { "artisan", ARTISAN } }; diff --git a/src/openvic-simulation/economy/production/ProductionType.hpp b/src/openvic-simulation/economy/production/ProductionType.hpp index 67bffaa2b..2b519a2ae 100644 --- a/src/openvic-simulation/economy/production/ProductionType.hpp +++ b/src/openvic-simulation/economy/production/ProductionType.hpp @@ -3,8 +3,8 @@ #include #include "openvic-simulation/scripts/ConditionScript.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/population/PopSize.hpp" #include "openvic-simulation/types/PopSprite.hpp" diff --git a/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp b/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp index 9cbf97b82..c2d0c8ef6 100644 --- a/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp +++ b/src/openvic-simulation/economy/production/ResourceGatheringOperation.hpp @@ -1,8 +1,8 @@ #pragma once +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/economy/production/Employee.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" #include "openvic-simulation/population/PopSize.hpp" #include "openvic-simulation/population/PopSum.hpp" #include "openvic-simulation/utility/Getters.hpp" diff --git a/src/openvic-simulation/economy/trading/GoodMarket.hpp b/src/openvic-simulation/economy/trading/GoodMarket.hpp index 37d420b9f..355d0a717 100644 --- a/src/openvic-simulation/economy/trading/GoodMarket.hpp +++ b/src/openvic-simulation/economy/trading/GoodMarket.hpp @@ -7,8 +7,8 @@ #include "openvic-simulation/economy/trading/MarketSellOrder.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/TypedIndices.hpp" -#include "openvic-simulation/types/TypedSpan.hpp" -#include "openvic-simulation/types/ValueHistory.hpp" +#include "openvic-simulation/core/container/TypedSpan.hpp" +#include "openvic-simulation/core/memory/ValueHistory.hpp" #include "openvic-simulation/utility/Containers.hpp" namespace OpenVic { @@ -47,7 +47,7 @@ namespace OpenVic { fixed_point_t PROPERTY(total_demand_yesterday); fixed_point_t PROPERTY(total_supply_yesterday); fixed_point_t PROPERTY(quantity_traded_yesterday); - ValueHistory PROPERTY(price_history); + memory::ValueHistory PROPERTY(price_history); void update_next_price_limits(); public: diff --git a/src/openvic-simulation/history/Bookmark.cpp b/src/openvic-simulation/history/Bookmark.cpp index d2fb7c6bc..264d5a14d 100644 --- a/src/openvic-simulation/history/Bookmark.cpp +++ b/src/openvic-simulation/history/Bookmark.cpp @@ -6,7 +6,7 @@ #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Logger.hpp" using namespace OpenVic; diff --git a/src/openvic-simulation/history/Bookmark.hpp b/src/openvic-simulation/history/Bookmark.hpp index 4584d628e..19cb83643 100644 --- a/src/openvic-simulation/history/Bookmark.hpp +++ b/src/openvic-simulation/history/Bookmark.hpp @@ -4,9 +4,9 @@ #include -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/history/CountryHistory.cpp b/src/openvic-simulation/history/CountryHistory.cpp index 93845197e..656dae0e7 100644 --- a/src/openvic-simulation/history/CountryHistory.cpp +++ b/src/openvic-simulation/history/CountryHistory.cpp @@ -6,6 +6,7 @@ #include "openvic-simulation/politics/Government.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/core/FormatValidate.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" using namespace OpenVic; using namespace OpenVic::NodeTools; @@ -33,7 +34,7 @@ memory::unique_ptr CountryHistoryMap::_make_entry(Date date return memory::make_unique(country, date, ideology_keys, government_type_keys); } -static constexpr auto _flag_callback(string_map_t& flags, bool value) { +static constexpr auto _flag_callback(memory::string_map_t& flags, bool value) { return [&flags, value](std::string_view flag) -> bool { auto [it, successful] = flags.emplace(flag, value); if (!successful) { diff --git a/src/openvic-simulation/history/CountryHistory.hpp b/src/openvic-simulation/history/CountryHistory.hpp index 9e4129681..99b924921 100644 --- a/src/openvic-simulation/history/CountryHistory.hpp +++ b/src/openvic-simulation/history/CountryHistory.hpp @@ -2,10 +2,12 @@ #include +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/history/HistoryMap.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" #include "openvic-simulation/research/TechnologyUnlockLevel.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -31,7 +33,7 @@ namespace OpenVic { friend struct CountryHistoryMap; private: std::optional PROPERTY(primary_culture); - ordered_map PROPERTY(accepted_cultures); + memory::ordered_map PROPERTY(accepted_cultures); std::optional PROPERTY(religion); std::optional PROPERTY(ruling_party); std::optional PROPERTY(last_election); @@ -42,11 +44,11 @@ namespace OpenVic { std::optional PROPERTY(national_value); std::optional PROPERTY_CUSTOM_PREFIX(civilised, is); std::optional PROPERTY(prestige); - ordered_set PROPERTY(reforms); + memory::ordered_set PROPERTY(reforms); std::optional PROPERTY(initial_oob); std::optional PROPERTY(tech_school); - ordered_map PROPERTY(technologies); - ordered_map PROPERTY(inventions); + memory::ordered_map PROPERTY(technologies); + memory::ordered_map PROPERTY(inventions); fixed_point_map_t PROPERTY(foreign_investment); std::optional PROPERTY(consciousness); std::optional PROPERTY(nonstate_consciousness); @@ -55,10 +57,10 @@ namespace OpenVic { std::optional PROPERTY_CUSTOM_PREFIX(releasable_vassal, is); std::optional PROPERTY(colonial_points); // True for set, false for clear - string_map_t PROPERTY(country_flags); - string_map_t PROPERTY(global_flags); + memory::string_map_t PROPERTY(country_flags); + memory::string_map_t PROPERTY(global_flags); OV_IFLATMAP_PROPERTY(GovernmentType, GovernmentType const*, flag_overrides_by_government_type); - ordered_set PROPERTY(decisions); + memory::ordered_set PROPERTY(decisions); public: CountryDefinition const& country; @@ -96,7 +98,7 @@ namespace OpenVic { struct CountryHistoryManager { private: - ordered_map country_histories; + memory::ordered_map country_histories; bool locked = false; public: diff --git a/src/openvic-simulation/history/HistoryMap.hpp b/src/openvic-simulation/history/HistoryMap.hpp index 023dea891..2498973e7 100644 --- a/src/openvic-simulation/history/HistoryMap.hpp +++ b/src/openvic-simulation/history/HistoryMap.hpp @@ -3,9 +3,9 @@ #include #include +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/utility/Containers.hpp" namespace OpenVic { @@ -31,7 +31,7 @@ namespace OpenVic { using entry_type = _Entry; private: - ordered_map> PROPERTY(entries); + memory::ordered_map> PROPERTY(entries); bool _try_load_history_entry( DefinitionManager const& definition_manager, Args... args, Date date, ast::NodeCPtr root @@ -117,7 +117,7 @@ namespace OpenVic { keys.push_back(entry.first); } std::stable_sort(keys.begin(), keys.end()); - ordered_map> new_entries; + memory::ordered_map> new_entries; for (Date const& key : keys) { new_entries.emplace(key, std::move(entries[key])); } diff --git a/src/openvic-simulation/history/ProvinceHistory.cpp b/src/openvic-simulation/history/ProvinceHistory.cpp index 2ae17480d..b9a623f1b 100644 --- a/src/openvic-simulation/history/ProvinceHistory.cpp +++ b/src/openvic-simulation/history/ProvinceHistory.cpp @@ -4,6 +4,7 @@ #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/DefinitionManager.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/economy/GoodDefinition.hpp" #include "openvic-simulation/map/ProvinceDefinition.hpp" #include "openvic-simulation/utility/Logger.hpp" @@ -32,7 +33,7 @@ bool ProvinceHistoryMap::_load_history_entry( TerrainTypeManager const& terrain_type_manager = definition_manager.get_map_definition().get_terrain_type_manager(); using enum colony_status_t; - static const string_map_t colony_status_map { + static const memory::string_map_t colony_status_map { { "0", STATE }, { "1", PROTECTORATE }, { "2", COLONY } }; diff --git a/src/openvic-simulation/history/ProvinceHistory.hpp b/src/openvic-simulation/history/ProvinceHistory.hpp index 8fc423fdd..2e84ed23f 100644 --- a/src/openvic-simulation/history/ProvinceHistory.hpp +++ b/src/openvic-simulation/history/ProvinceHistory.hpp @@ -2,13 +2,13 @@ #include +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/economy/BuildingType.hpp" #include "openvic-simulation/history/HistoryMap.hpp" #include "openvic-simulation/population/Pop.hpp" #include "openvic-simulation/economy/BuildingLevel.hpp" #include "openvic-simulation/types/ColonyStatus.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" #include "openvic-simulation/map/LifeRating.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -32,12 +32,12 @@ namespace OpenVic { std::optional PROPERTY(controller); std::optional PROPERTY(colonial); std::optional PROPERTY(slave); - ordered_map PROPERTY(cores); + memory::ordered_map PROPERTY(cores); std::optional PROPERTY(rgo_production_type_nullable); std::optional PROPERTY(life_rating); std::optional PROPERTY(terrain_type); - ordered_map PROPERTY(province_buildings); - ordered_map PROPERTY(state_buildings); + memory::ordered_map PROPERTY(province_buildings); + memory::ordered_map PROPERTY(state_buildings); fixed_point_map_t PROPERTY(party_loyalties); memory::vector SPAN_PROPERTY(pops); @@ -73,7 +73,7 @@ namespace OpenVic { struct ProvinceHistoryManager { private: - ordered_map province_histories; + memory::ordered_map province_histories; bool locked = false; ProvinceHistoryMap* _get_or_make_province_history(ProvinceDefinition const& province); diff --git a/src/openvic-simulation/interface/GFXSprite.hpp b/src/openvic-simulation/interface/GFXSprite.hpp index 58e0c5726..aeb6a5254 100644 --- a/src/openvic-simulation/interface/GFXSprite.hpp +++ b/src/openvic-simulation/interface/GFXSprite.hpp @@ -1,12 +1,13 @@ #pragma once +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/interface/LoadBase.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" namespace OpenVic::GFX { struct Font : HasIdentifierAndAlphaColour { - using colour_codes_t = ordered_map; + using colour_codes_t = memory::ordered_map; private: memory::string PROPERTY(fontname); diff --git a/src/openvic-simulation/interface/GUI.cpp b/src/openvic-simulation/interface/GUI.cpp index 1e9dffbdf..b414c2438 100644 --- a/src/openvic-simulation/interface/GUI.cpp +++ b/src/openvic-simulation/interface/GUI.cpp @@ -4,7 +4,8 @@ #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/interface/UI.hpp" #include "openvic-simulation/misc/SoundEffect.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" using namespace OpenVic; using namespace OpenVic::GUI; @@ -25,7 +26,7 @@ Element::Element() {} bool Element::_fill_key_map(NodeTools::case_insensitive_key_map_t& key_map, UIManager const& ui_manager) { bool ret = Named::_fill_key_map(key_map, ui_manager); using enum orientation_t; - static const string_map_t orientation_map = { + static const memory::string_map_t orientation_map = { { "UPPER_LEFT", UPPER_LEFT }, { "LOWER_LEFT", LOWER_LEFT }, { "LOWER_RIGHT", LOWER_RIGHT }, { "UPPER_RIGHT", UPPER_RIGHT }, { "CENTER", CENTER }, { "CENTER_UP", CENTER_UP }, { "CENTER_DOWN", CENTER_DOWN } diff --git a/src/openvic-simulation/interface/LoadBase.hpp b/src/openvic-simulation/interface/LoadBase.hpp index e787ef501..5a5bd6e0f 100644 --- a/src/openvic-simulation/interface/LoadBase.hpp +++ b/src/openvic-simulation/interface/LoadBase.hpp @@ -1,6 +1,6 @@ #pragma once -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Getters.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/interface/UI.cpp b/src/openvic-simulation/interface/UI.cpp index de6a29427..3047aac8c 100644 --- a/src/openvic-simulation/interface/UI.cpp +++ b/src/openvic-simulation/interface/UI.cpp @@ -3,7 +3,7 @@ #include "openvic-simulation/DefinitionManager.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" using namespace OpenVic; using namespace OpenVic::NodeTools; diff --git a/src/openvic-simulation/map/Crime.hpp b/src/openvic-simulation/map/Crime.hpp index 3a4a4548c..116ba379b 100644 --- a/src/openvic-simulation/map/Crime.hpp +++ b/src/openvic-simulation/map/Crime.hpp @@ -1,7 +1,7 @@ #pragma once #include "openvic-simulation/modifier/Modifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/map/MapDefinition.cpp b/src/openvic-simulation/map/MapDefinition.cpp index cf13e30da..d26cb554d 100644 --- a/src/openvic-simulation/map/MapDefinition.cpp +++ b/src/openvic-simulation/map/MapDefinition.cpp @@ -17,13 +17,15 @@ #include +#include "openvic-simulation/core/container/TypedSpan.hpp" #include "openvic-simulation/core/io/BMP.hpp" +#include "openvic-simulation/core/memory/FixedVector.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/map/ProvinceDefinition.hpp" #include "openvic-simulation/modifier/ModifierManager.hpp" #include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/OrderedContainersMath.hpp" -#include "openvic-simulation/types/TypedSpan.hpp" #include "openvic-simulation/types/Vector.hpp" #include "openvic-simulation/core/FormatValidate.hpp" #include "openvic-simulation/utility/Logger.hpp" @@ -867,7 +869,7 @@ bool MapDefinition::load_map_images(fs::path const& province_path, fs::path cons TypedSpan> terrain_type_pixels_list { _terrain_type_pixels_list }; bool ret = true; - ordered_set unrecognised_province_colours; + memory::ordered_set unrecognised_province_colours; memory::FixedVector _pixels_per_province( province_definitions.size(), @@ -1062,11 +1064,11 @@ bool MapDefinition::generate_and_load_province_adjacencies(std::span type_map { + static const memory::string_map_t type_map { { "land", LAND }, { "sea", STRAIT }, { "impassable", IMPASSABLE }, { "canal", CANAL } }; const std::string_view type_str = adjacency.get_value_for(2); - const string_map_t::const_iterator it = type_map.find(type_str); + const memory::string_map_t::const_iterator it = type_map.find(type_str); if (it == type_map.end()) { spdlog::error_s("Invalid adjacency type: \"{}\"", type_str); ret = false; diff --git a/src/openvic-simulation/map/MapDefinition.hpp b/src/openvic-simulation/map/MapDefinition.hpp index ed4c02dd7..32bea8490 100644 --- a/src/openvic-simulation/map/MapDefinition.hpp +++ b/src/openvic-simulation/map/MapDefinition.hpp @@ -6,14 +6,14 @@ #include +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/core/io/BMP.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/map/ProvinceDefinition.hpp" #include "openvic-simulation/map/Region.hpp" #include "openvic-simulation/map/TerrainType.hpp" #include "openvic-simulation/pathfinding/PointMap.hpp" #include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/Vector.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -47,7 +47,7 @@ namespace OpenVic { #pragma pack(pop) private: - using colour_index_map_t = ordered_map; + using colour_index_map_t = memory::ordered_map; using river_t = memory::vector; IdentifierRegistry IDENTIFIER_REGISTRY(province_definition); diff --git a/src/openvic-simulation/map/MapInstance.hpp b/src/openvic-simulation/map/MapInstance.hpp index 32cff79a1..ee64ee9d8 100644 --- a/src/openvic-simulation/map/MapInstance.hpp +++ b/src/openvic-simulation/map/MapInstance.hpp @@ -1,5 +1,6 @@ #pragma once +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/map/ProvinceDefinition.hpp" #include "openvic-simulation/map/ProvinceInstance.hpp" #include "openvic-simulation/map/State.hpp" @@ -35,7 +36,7 @@ namespace OpenVic { StateManager PROPERTY_REF(state_manager); // TODO - should this be a vector of bools which we resize to the largest enabled canal index? - ordered_set PROPERTY(enabled_canals); + memory::ordered_set PROPERTY(enabled_canals); ArmyAStarPathing PROPERTY_REF(land_pathing); NavyAStarPathing PROPERTY_REF(sea_pathing); diff --git a/src/openvic-simulation/map/Mapmode.cpp b/src/openvic-simulation/map/Mapmode.cpp index 1b2a75ef4..a69afc552 100644 --- a/src/openvic-simulation/map/Mapmode.cpp +++ b/src/openvic-simulation/map/Mapmode.cpp @@ -4,6 +4,7 @@ #include +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/economy/BuildingType.hpp" #include "openvic-simulation/economy/GoodDefinition.hpp" // IWYU pragma: keep @@ -14,7 +15,6 @@ #include "openvic-simulation/population/Culture.hpp" #include "openvic-simulation/population/PopSum.hpp" #include "openvic-simulation/population/Religion.hpp" -#include "openvic-simulation/types/OrderedContainersMath.hpp" using namespace OpenVic; using namespace OpenVic::colour_literals; @@ -170,7 +170,7 @@ static constexpr auto get_colour_mapmode( template static constexpr Mapmode::base_stripe_t shaded_mapmode( - ordered_map const& map + memory::ordered_map const& map ) { const auto largest = get_largest_two_items(map); if (largest.first != map.end()) { @@ -188,7 +188,7 @@ static constexpr Mapmode::base_stripe_t shaded_mapmode( } template -static constexpr auto shaded_mapmode(ordered_map const&(ProvinceInstance::*get_map)() const) { +static constexpr auto shaded_mapmode(memory::ordered_map const&(ProvinceInstance::*get_map)() const) { return [get_map]( MapInstance const& map_instance, ProvinceInstance const& province, CountryInstance const* player_country, ProvinceInstance const* selected_province diff --git a/src/openvic-simulation/map/Mapmode.hpp b/src/openvic-simulation/map/Mapmode.hpp index 94baa67bf..f6d82ac2a 100644 --- a/src/openvic-simulation/map/Mapmode.hpp +++ b/src/openvic-simulation/map/Mapmode.hpp @@ -1,9 +1,9 @@ #pragma once #include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include diff --git a/src/openvic-simulation/map/ProvinceDefinition.hpp b/src/openvic-simulation/map/ProvinceDefinition.hpp index 4aacf978e..5281a46ab 100644 --- a/src/openvic-simulation/map/ProvinceDefinition.hpp +++ b/src/openvic-simulation/map/ProvinceDefinition.hpp @@ -3,15 +3,16 @@ #include #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/types/Vector.hpp" #include "openvic-simulation/utility/Containers.hpp" + #include "type_safe/strong_typedef.hpp" namespace OpenVic { @@ -81,7 +82,7 @@ namespace OpenVic { std::optional factory; std::optional building_construction; std::optional military_construction; - ordered_map building_position; + memory::ordered_map building_position; fixed_point_map_t building_rotation; }; diff --git a/src/openvic-simulation/map/ProvinceInstance.cpp b/src/openvic-simulation/map/ProvinceInstance.cpp index e45e3fb89..6a725c3f8 100644 --- a/src/openvic-simulation/map/ProvinceInstance.cpp +++ b/src/openvic-simulation/map/ProvinceInstance.cpp @@ -390,7 +390,7 @@ void ProvinceInstance::province_tick( const Date today, PopValuesFromProvince& reusable_pop_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_PROVINCE_TICK @@ -520,7 +520,7 @@ void ProvinceInstance::initialise_for_new_game( const Date today, PopValuesFromProvince& reusable_pop_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_PROVINCE_TICK diff --git a/src/openvic-simulation/map/ProvinceInstance.hpp b/src/openvic-simulation/map/ProvinceInstance.hpp index 27a4e1262..5ec7d2ab3 100644 --- a/src/openvic-simulation/map/ProvinceInstance.hpp +++ b/src/openvic-simulation/map/ProvinceInstance.hpp @@ -2,6 +2,11 @@ #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/memory/FlagStrings.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/economy/BuildingInstance.hpp" #include "openvic-simulation/economy/production/ResourceGatheringOperation.hpp" #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp" @@ -9,10 +14,6 @@ #include "openvic-simulation/population/Pop.hpp" #include "openvic-simulation/population/PopsAggregate.hpp" #include "openvic-simulation/types/ColonyStatus.hpp" -#include "openvic-simulation/types/FlagStrings.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/map/LifeRating.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" @@ -50,7 +51,7 @@ namespace OpenVic { struct ProvinceInstance : HasIdentifierAndColour, HasIndex, - FlagStrings, + memory::FlagStrings, PopsAggregate { friend struct MapInstance; @@ -80,7 +81,7 @@ namespace OpenVic { ModifierSum const& get_owner_modifier_sum() const; CountryInstance* PROPERTY_PTR(controller, nullptr); CountryInstance* PROPERTY_PTR(country_to_report_economy, nullptr); - ordered_set PROPERTY(cores); + memory::ordered_set PROPERTY(cores); // The total/resultant modifier of local effects on this province (global effects come from the province's owner) ModifierSum PROPERTY(modifier_sum); @@ -191,7 +192,7 @@ namespace OpenVic { const Date today, PopValuesFromProvince& reusable_pop_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_PROVINCE_TICK @@ -201,7 +202,7 @@ namespace OpenVic { const Date today, PopValuesFromProvince& reusable_pop_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_PROVINCE_TICK diff --git a/src/openvic-simulation/map/Region.hpp b/src/openvic-simulation/map/Region.hpp index 8c6833d62..c4f01424b 100644 --- a/src/openvic-simulation/map/Region.hpp +++ b/src/openvic-simulation/map/Region.hpp @@ -4,7 +4,7 @@ #include #include "openvic-simulation/modifier/Modifier.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" #include "openvic-simulation/utility/Containers.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/map/TerrainType.cpp b/src/openvic-simulation/map/TerrainType.cpp index 510c232a3..fd0712987 100644 --- a/src/openvic-simulation/map/TerrainType.cpp +++ b/src/openvic-simulation/map/TerrainType.cpp @@ -4,7 +4,7 @@ #include "openvic-simulation/modifier/ModifierManager.hpp" #include "openvic-simulation/types/Colour.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" #include "openvic-simulation/core/FormatValidate.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -42,7 +42,7 @@ TerrainTypeMapping::TerrainTypeMapping( bool TerrainTypeManager::generate_modifiers(ModifierManager& modifier_manager) const { using enum ModifierEffect::format_t; - IndexedFlatMap& unit_terrain_effects = + memory::IndexedFlatMap& unit_terrain_effects = modifier_manager.modifier_effect_cache.unit_terrain_effects; unit_terrain_effects = std::move(decltype(ModifierEffectCache::unit_terrain_effects){get_terrain_types()}); diff --git a/src/openvic-simulation/map/TerrainType.hpp b/src/openvic-simulation/map/TerrainType.hpp index 802eef402..8102f3025 100644 --- a/src/openvic-simulation/map/TerrainType.hpp +++ b/src/openvic-simulation/map/TerrainType.hpp @@ -1,9 +1,9 @@ #pragma once +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/modifier/Modifier.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -56,7 +56,7 @@ namespace OpenVic { struct TerrainTypeManager { private: - using terrain_type_mappings_map_t = ordered_map; + using terrain_type_mappings_map_t = memory::ordered_map; IdentifierRegistry IDENTIFIER_REGISTRY(terrain_type); IdentifierRegistry IDENTIFIER_REGISTRY(terrain_type_mapping); diff --git a/src/openvic-simulation/military/Deployment.hpp b/src/openvic-simulation/military/Deployment.hpp index 5f6ad07ed..50f60670d 100644 --- a/src/openvic-simulation/military/Deployment.hpp +++ b/src/openvic-simulation/military/Deployment.hpp @@ -3,10 +3,11 @@ #include #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/military/Leader.hpp" #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/utility/Getters.hpp" @@ -97,7 +98,7 @@ namespace OpenVic { struct DeploymentManager { private: IdentifierRegistry IDENTIFIER_REGISTRY(deployment); - string_set_t missing_oob_files; + memory::string_set_t missing_oob_files; public: bool add_deployment( diff --git a/src/openvic-simulation/military/LeaderTrait.hpp b/src/openvic-simulation/military/LeaderTrait.hpp index 8bc4c93e2..25f8c5e02 100644 --- a/src/openvic-simulation/military/LeaderTrait.hpp +++ b/src/openvic-simulation/military/LeaderTrait.hpp @@ -4,7 +4,7 @@ #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/modifier/Modifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Containers.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/military/UnitInstanceGroup.cpp b/src/openvic-simulation/military/UnitInstanceGroup.cpp index c8eae8ae7..d03ad3f2e 100644 --- a/src/openvic-simulation/military/UnitInstanceGroup.cpp +++ b/src/openvic-simulation/military/UnitInstanceGroup.cpp @@ -9,7 +9,6 @@ #include "openvic-simulation/military/Deployment.hpp" #include "openvic-simulation/military/LeaderTrait.hpp" #include "openvic-simulation/population/Culture.hpp" -#include "openvic-simulation/types/OrderedContainersMath.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/core/FormatValidate.hpp" diff --git a/src/openvic-simulation/military/UnitInstanceGroup.hpp b/src/openvic-simulation/military/UnitInstanceGroup.hpp index 5c2281e3e..4313ac23d 100644 --- a/src/openvic-simulation/military/UnitInstanceGroup.hpp +++ b/src/openvic-simulation/military/UnitInstanceGroup.hpp @@ -4,6 +4,7 @@ #include +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/military/Leader.hpp" #include "openvic-simulation/military/UnitInstance.hpp" #include "openvic-simulation/military/UnitType.hpp" @@ -11,7 +12,6 @@ #include "openvic-simulation/types/UnitBranchType.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/Containers.hpp" - #include "openvic-simulation/military/UnitBranchedGetterMacro.hpp" //below other imports that undef the macros namespace OpenVic { @@ -170,17 +170,17 @@ namespace OpenVic { // TODO - maps from unique_ids to leader/unit/unit group pointers (one big map or multiple maps?) memory::colony PROPERTY(leaders); - ordered_map PROPERTY(leader_instance_map); + memory::ordered_map PROPERTY(leader_instance_map); memory::colony PROPERTY(regiments); memory::colony PROPERTY(ships); - ordered_map PROPERTY(unit_instance_map); + memory::ordered_map PROPERTY(unit_instance_map); OV_UNIT_BRANCHED_GETTER(get_unit_instances, regiments, ships); memory::colony PROPERTY(armies); memory::colony PROPERTY(navies); - ordered_map PROPERTY(unit_instance_group_map); + memory::ordered_map PROPERTY(unit_instance_group_map); OV_UNIT_BRANCHED_GETTER(get_unit_instance_groups, armies, navies); diff --git a/src/openvic-simulation/military/UnitType.cpp b/src/openvic-simulation/military/UnitType.cpp index e07fa3923..ec87109cd 100644 --- a/src/openvic-simulation/military/UnitType.cpp +++ b/src/openvic-simulation/military/UnitType.cpp @@ -4,6 +4,7 @@ #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/map/TerrainType.hpp" #include "openvic-simulation/modifier/ModifierManager.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "modifier/ModifierEffectCache.hpp" #include "types/UnitBranchType.hpp" @@ -203,7 +204,7 @@ bool UnitTypeManager::load_unit_type_file( UnitType::unit_type_args_t unit_args {}; - static const string_map_t unit_type_map { + static const memory::string_map_t unit_type_map { { "infantry", INFANTRY }, { "cavalry", CAVALRY }, { "support", SUPPORT }, @@ -382,7 +383,7 @@ bool UnitTypeManager::generate_modifiers(ModifierManager& modifier_manager) cons generate_stat_modifiers(modifier_manager.modifier_effect_cache.army_base_effects, "army_base"); - IndexedFlatMap& regiment_type_effects = + memory::IndexedFlatMap& regiment_type_effects = modifier_manager.modifier_effect_cache.regiment_type_effects; regiment_type_effects = std::move(decltype(ModifierEffectCache::regiment_type_effects){get_regiment_types()}); @@ -393,7 +394,7 @@ bool UnitTypeManager::generate_modifiers(ModifierManager& modifier_manager) cons generate_stat_modifiers(modifier_manager.modifier_effect_cache.navy_base_effects, "navy_base"); - IndexedFlatMap& ship_type_effects = + memory::IndexedFlatMap& ship_type_effects = modifier_manager.modifier_effect_cache.ship_type_effects; ship_type_effects = std::move(decltype(ModifierEffectCache::ship_type_effects){get_ship_types()}); diff --git a/src/openvic-simulation/military/UnitType.hpp b/src/openvic-simulation/military/UnitType.hpp index 12175818b..c31570a7a 100644 --- a/src/openvic-simulation/military/UnitType.hpp +++ b/src/openvic-simulation/military/UnitType.hpp @@ -5,13 +5,14 @@ #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" #include "openvic-simulation/economy/GoodDefinition.hpp" #include "openvic-simulation/modifier/Modifier.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" @@ -24,14 +25,14 @@ namespace OpenVic { struct UnitType : HasIdentifier { using icon_t = uint32_t; - using terrain_modifiers_t = ordered_map; + using terrain_modifiers_t = memory::ordered_map; enum struct unit_category_t : uint8_t { INVALID_UNIT_CATEGORY, INFANTRY, CAVALRY, SUPPORT, SPECIAL, BIG_SHIP, LIGHT_SHIP, TRANSPORT }; struct unit_type_args_t { - using terrain_modifier_values_t = ordered_map; + using terrain_modifier_values_t = memory::ordered_map; icon_t icon = 0; unit_category_t unit_category = unit_category_t::INVALID_UNIT_CATEGORY; @@ -186,7 +187,7 @@ namespace OpenVic { NodeTools::Callback auto callback ) { using enum unit_branch_t; - static const string_map_t branch_map { + static const memory::string_map_t branch_map { { "land", LAND }, { "naval", NAVAL }, { "sea", NAVAL } }; return NodeTools::expect_mapped_string(branch_map, callback); diff --git a/src/openvic-simulation/military/Wargoal.cpp b/src/openvic-simulation/military/Wargoal.cpp index fb7b88f03..d3b3ab597 100644 --- a/src/openvic-simulation/military/Wargoal.cpp +++ b/src/openvic-simulation/military/Wargoal.cpp @@ -2,6 +2,7 @@ #include +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/dataloader/NodeTools.hpp" using namespace OpenVic; @@ -118,7 +119,7 @@ bool WargoalTypeManager::load_wargoal_file(ovdl::v2script::Parser const& parser) bool ret = expect_dictionary_keys_and_default( [&modifiers, &identifier](std::string_view key, ast::NodeCPtr value) -> bool { using enum WargoalType::PEACE_MODIFIERS; - static const string_map_t peace_modifier_map { + static const memory::string_map_t peace_modifier_map { { "badboy_factor", BADBOY_FACTOR }, { "prestige_factor", PRESTIGE_FACTOR }, { "peace_cost_factor", PEACE_COST_FACTOR }, diff --git a/src/openvic-simulation/military/Wargoal.hpp b/src/openvic-simulation/military/Wargoal.hpp index 2373e7cbe..eec01d4b0 100644 --- a/src/openvic-simulation/military/Wargoal.hpp +++ b/src/openvic-simulation/military/Wargoal.hpp @@ -5,7 +5,7 @@ #include "openvic-simulation/scripts/ConditionScript.hpp" #include "openvic-simulation/scripts/EffectScript.hpp" #include "openvic-simulation/core/template/EnumBitfield.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/Containers.hpp" diff --git a/src/openvic-simulation/misc/Decision.hpp b/src/openvic-simulation/misc/Decision.hpp index 3ac7f0e44..54da3359c 100644 --- a/src/openvic-simulation/misc/Decision.hpp +++ b/src/openvic-simulation/misc/Decision.hpp @@ -2,7 +2,7 @@ #include "openvic-simulation/scripts/ConditionalWeight.hpp" #include "openvic-simulation/scripts/EffectScript.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" namespace OpenVic { struct DecisionManager; diff --git a/src/openvic-simulation/misc/Event.hpp b/src/openvic-simulation/misc/Event.hpp index 7ca60672d..11aef9467 100644 --- a/src/openvic-simulation/misc/Event.hpp +++ b/src/openvic-simulation/misc/Event.hpp @@ -1,9 +1,9 @@ #pragma once +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/scripts/ConditionalWeight.hpp" #include "openvic-simulation/scripts/EffectScript.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/utility/Containers.hpp" namespace OpenVic { @@ -76,7 +76,7 @@ namespace OpenVic { }; struct OnAction : HasIdentifier { - using weight_map_t = ordered_map; + using weight_map_t = memory::ordered_map; private: weight_map_t PROPERTY(weighted_events); diff --git a/src/openvic-simulation/misc/SongChance.hpp b/src/openvic-simulation/misc/SongChance.hpp index 818dc3244..6f1a77791 100644 --- a/src/openvic-simulation/misc/SongChance.hpp +++ b/src/openvic-simulation/misc/SongChance.hpp @@ -1,6 +1,6 @@ #pragma once -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/scripts/ConditionalWeight.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/misc/SoundEffect.hpp b/src/openvic-simulation/misc/SoundEffect.hpp index 628090b98..cf7033ba4 100644 --- a/src/openvic-simulation/misc/SoundEffect.hpp +++ b/src/openvic-simulation/misc/SoundEffect.hpp @@ -2,9 +2,9 @@ #include -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" namespace OpenVic { class Dataloader; diff --git a/src/openvic-simulation/modifier/ModifierEffect.hpp b/src/openvic-simulation/modifier/ModifierEffect.hpp index 8c1187664..d1b7bce4e 100644 --- a/src/openvic-simulation/modifier/ModifierEffect.hpp +++ b/src/openvic-simulation/modifier/ModifierEffect.hpp @@ -3,7 +3,7 @@ #include #include "openvic-simulation/core/template/EnumBitfield.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" namespace OpenVic { struct ModifierManager; diff --git a/src/openvic-simulation/modifier/ModifierEffectCache.hpp b/src/openvic-simulation/modifier/ModifierEffectCache.hpp index 1bd6a2849..daf08699c 100644 --- a/src/openvic-simulation/modifier/ModifierEffectCache.hpp +++ b/src/openvic-simulation/modifier/ModifierEffectCache.hpp @@ -1,6 +1,6 @@ #pragma once -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" #include "openvic-simulation/utility/Getters.hpp" diff --git a/src/openvic-simulation/modifier/ModifierManager.hpp b/src/openvic-simulation/modifier/ModifierManager.hpp index d712ad464..9d8d6717a 100644 --- a/src/openvic-simulation/modifier/ModifierManager.hpp +++ b/src/openvic-simulation/modifier/ModifierManager.hpp @@ -2,10 +2,11 @@ #include +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/modifier/Modifier.hpp" #include "openvic-simulation/modifier/ModifierEffectCache.hpp" #include "openvic-simulation/modifier/StaticModifierCache.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" namespace OpenVic { struct ModifierManager { @@ -31,7 +32,7 @@ namespace OpenVic { modifier_effect_registry_t IDENTIFIER_REGISTRY(base_country_modifier_effect); modifier_effect_registry_t IDENTIFIER_REGISTRY(base_province_modifier_effect); modifier_effect_registry_t IDENTIFIER_REGISTRY(terrain_modifier_effect); - case_insensitive_string_set_t complex_modifiers; + memory::case_insensitive_string_set_t complex_modifiers; IdentifierRegistry IDENTIFIER_REGISTRY(event_modifier); IdentifierRegistry IDENTIFIER_REGISTRY(triggered_modifier); diff --git a/src/openvic-simulation/modifier/ModifierValue.cpp b/src/openvic-simulation/modifier/ModifierValue.cpp index a50fea1ac..1bc298436 100644 --- a/src/openvic-simulation/modifier/ModifierValue.cpp +++ b/src/openvic-simulation/modifier/ModifierValue.cpp @@ -1,6 +1,6 @@ #include "ModifierValue.hpp" -#include "openvic-simulation/utility/TslHelper.hpp" +#include "openvic-simulation/core/container/MutableIterator.hpp" using namespace OpenVic; diff --git a/src/openvic-simulation/politics/BaseIssue.hpp b/src/openvic-simulation/politics/BaseIssue.hpp index d1d79ad05..e6c230685 100644 --- a/src/openvic-simulation/politics/BaseIssue.hpp +++ b/src/openvic-simulation/politics/BaseIssue.hpp @@ -2,7 +2,7 @@ #include "openvic-simulation/modifier/Modifier.hpp" #include "openvic-simulation/politics/Rule.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" namespace OpenVic { struct BaseIssueGroup; diff --git a/src/openvic-simulation/politics/Government.cpp b/src/openvic-simulation/politics/Government.cpp index 5ab8c4249..deee9af95 100644 --- a/src/openvic-simulation/politics/Government.cpp +++ b/src/openvic-simulation/politics/Government.cpp @@ -1,5 +1,6 @@ #include "Government.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/politics/Ideology.hpp" using namespace OpenVic; @@ -83,7 +84,7 @@ bool GovernmentTypeManager::load_government_types_file(IdeologyManager const& id [this, &ideology_manager, &ideologies, government_type_identifier]( std::string_view key, ast::NodeCPtr value ) -> bool { - static const string_set_t reserved_keys = { "election", "duration", "appoint_ruling_party", "flagType" }; + static const memory::string_set_t reserved_keys = { "election", "duration", "appoint_ruling_party", "flagType" }; if (reserved_keys.contains(key)) { return true; } diff --git a/src/openvic-simulation/politics/Government.hpp b/src/openvic-simulation/politics/Government.hpp index 26bdd18df..e209753c0 100644 --- a/src/openvic-simulation/politics/Government.hpp +++ b/src/openvic-simulation/politics/Government.hpp @@ -1,9 +1,10 @@ #pragma once +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/StringSet.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -38,7 +39,7 @@ namespace OpenVic { struct GovernmentTypeManager { private: IdentifierRegistry IDENTIFIER_REGISTRY(government_type); - string_set_t PROPERTY(flag_types); + memory::string_set_t PROPERTY(flag_types); public: bool add_government_type( diff --git a/src/openvic-simulation/politics/Ideology.hpp b/src/openvic-simulation/politics/Ideology.hpp index 239469da8..030efca4b 100644 --- a/src/openvic-simulation/politics/Ideology.hpp +++ b/src/openvic-simulation/politics/Ideology.hpp @@ -1,9 +1,9 @@ #pragma once #include "openvic-simulation/scripts/ConditionalWeight.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/politics/IssueManager.cpp b/src/openvic-simulation/politics/IssueManager.cpp index f37ad54d5..1252ba6aa 100644 --- a/src/openvic-simulation/politics/IssueManager.cpp +++ b/src/openvic-simulation/politics/IssueManager.cpp @@ -277,7 +277,7 @@ bool IssueManager::load_issues_file( return expect_length(add_variable_callback(expected_party_policy_groups))(value); } else { - static const string_set_t uncivilised_reform_groups { + static const memory::string_set_t uncivilised_reform_groups { "economic_reforms", "education_reforms", "military_reforms" }; diff --git a/src/openvic-simulation/politics/IssueManager.hpp b/src/openvic-simulation/politics/IssueManager.hpp index 7754f6ff9..3206ffc75 100644 --- a/src/openvic-simulation/politics/IssueManager.hpp +++ b/src/openvic-simulation/politics/IssueManager.hpp @@ -2,7 +2,7 @@ #include "openvic-simulation/politics/PartyPolicy.hpp" #include "openvic-simulation/politics/Reform.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "BaseIssue.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/politics/NationalFocus.hpp b/src/openvic-simulation/politics/NationalFocus.hpp index baa36cba7..2f3c6e84e 100644 --- a/src/openvic-simulation/politics/NationalFocus.hpp +++ b/src/openvic-simulation/politics/NationalFocus.hpp @@ -2,8 +2,8 @@ #include "openvic-simulation/modifier/Modifier.hpp" #include "openvic-simulation/scripts/ConditionScript.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Getters.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/politics/NationalValue.hpp b/src/openvic-simulation/politics/NationalValue.hpp index e7b5bb0a8..925c9f8cc 100644 --- a/src/openvic-simulation/politics/NationalValue.hpp +++ b/src/openvic-simulation/politics/NationalValue.hpp @@ -1,7 +1,7 @@ #pragma once #include "openvic-simulation/modifier/Modifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" namespace OpenVic { struct NationalValueManager; diff --git a/src/openvic-simulation/politics/PartyPolicy.hpp b/src/openvic-simulation/politics/PartyPolicy.hpp index e45dfeaf2..189f3f063 100644 --- a/src/openvic-simulation/politics/PartyPolicy.hpp +++ b/src/openvic-simulation/politics/PartyPolicy.hpp @@ -1,7 +1,7 @@ #pragma once #include "openvic-simulation/politics/BaseIssue.hpp" -#include "openvic-simulation/types/HasIndex.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/politics/PoliticsInstanceManager.hpp b/src/openvic-simulation/politics/PoliticsInstanceManager.hpp index a333c94fa..981c43820 100644 --- a/src/openvic-simulation/politics/PoliticsInstanceManager.hpp +++ b/src/openvic-simulation/politics/PoliticsInstanceManager.hpp @@ -3,7 +3,7 @@ #include #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/core/portable/ForwardableSpan.hpp" diff --git a/src/openvic-simulation/politics/Rebel.cpp b/src/openvic-simulation/politics/Rebel.cpp index 902a03955..136c45e74 100644 --- a/src/openvic-simulation/politics/Rebel.cpp +++ b/src/openvic-simulation/politics/Rebel.cpp @@ -2,6 +2,7 @@ #include +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/politics/Government.hpp" #include "openvic-simulation/politics/Ideology.hpp" #include "openvic-simulation/modifier/ModifierManager.hpp" @@ -76,7 +77,7 @@ bool RebelManager::load_rebels_file( ) { spdlog::scope scope { "common/rebel_types.txt" }; - static const string_map_t area_map = { + static const memory::string_map_t area_map = { { "nation", RebelType::area_t::NATION }, { "nation_religion", RebelType::area_t::NATION_RELIGION }, { "nation_culture", RebelType::area_t::NATION_CULTURE }, @@ -86,7 +87,7 @@ bool RebelManager::load_rebels_file( { "all", RebelType::area_t::ALL } }; - static const string_map_t defection_map = { + static const memory::string_map_t defection_map = { { "none", RebelType::defection_t::NONE }, { "culture", RebelType::defection_t::CULTURE }, { "culture_group", RebelType::defection_t::CULTURE_GROUP }, @@ -96,7 +97,7 @@ bool RebelManager::load_rebels_file( { "any", RebelType::defection_t::ANY } }; - static const string_map_t independence_map = { + static const memory::string_map_t independence_map = { { "none", RebelType::independence_t::NONE }, { "culture", RebelType::independence_t::CULTURE }, { "culture_group", RebelType::independence_t::CULTURE_GROUP }, diff --git a/src/openvic-simulation/politics/Rebel.hpp b/src/openvic-simulation/politics/Rebel.hpp index 8a87565e7..b8d618c21 100644 --- a/src/openvic-simulation/politics/Rebel.hpp +++ b/src/openvic-simulation/politics/Rebel.hpp @@ -2,12 +2,12 @@ #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/scripts/ConditionalWeight.hpp" #include "openvic-simulation/scripts/EffectScript.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { @@ -21,7 +21,7 @@ namespace OpenVic { struct RebelType : HasIndex, HasIdentifier { friend struct RebelManager; - using government_map_t = ordered_map; + using government_map_t = memory::ordered_map; using icon_t = uint16_t; enum class area_t { diff --git a/src/openvic-simulation/politics/Reform.hpp b/src/openvic-simulation/politics/Reform.hpp index 96e275fb0..138e42313 100644 --- a/src/openvic-simulation/politics/Reform.hpp +++ b/src/openvic-simulation/politics/Reform.hpp @@ -3,8 +3,8 @@ #include "openvic-simulation/politics/BaseIssue.hpp" #include "openvic-simulation/scripts/ConditionScript.hpp" #include "openvic-simulation/scripts/EffectScript.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/politics/Rule.cpp b/src/openvic-simulation/politics/Rule.cpp index 964296381..5034d6623 100644 --- a/src/openvic-simulation/politics/Rule.cpp +++ b/src/openvic-simulation/politics/Rule.cpp @@ -1,8 +1,9 @@ #include "Rule.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/MutableIterator.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/economy/BuildingType.hpp" -#include "openvic-simulation/utility/TslHelper.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/core/FormatValidate.hpp" @@ -156,7 +157,7 @@ bool RuleManager::setup_rules(BuildingTypeManager const& building_type_manager) using enum Rule::rule_group_t; - static const ordered_map> hardcoded_rules { + static const memory::ordered_map> hardcoded_rules { { ECONOMY, { "build_railway", "build_factory", "expand_factory", "open_factory", "destroy_factory", "pop_build_factory", "pop_expand_factory", "pop_open_factory", "can_subsidise", "factory_priority", "delete_factory_if_no_input", diff --git a/src/openvic-simulation/politics/Rule.hpp b/src/openvic-simulation/politics/Rule.hpp index bc5f0ab76..b2c185956 100644 --- a/src/openvic-simulation/politics/Rule.hpp +++ b/src/openvic-simulation/politics/Rule.hpp @@ -1,9 +1,9 @@ #pragma once -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { @@ -42,8 +42,8 @@ namespace OpenVic { struct RuleSet { friend struct RuleManager; - using rule_map_t = ordered_map; - using rule_group_map_t = ordered_map; + using rule_map_t = memory::ordered_map; + using rule_group_map_t = memory::ordered_map; private: rule_group_map_t PROPERTY(rule_groups); @@ -82,7 +82,7 @@ namespace OpenVic { struct RuleManager { private: IdentifierRegistry IDENTIFIER_REGISTRY(rule); - ordered_map rule_group_sizes; + memory::ordered_map rule_group_sizes; public: bool add_rule(std::string_view identifier, Rule::rule_group_t group, std::string_view localisation_key = {}); diff --git a/src/openvic-simulation/population/Culture.cpp b/src/openvic-simulation/population/Culture.cpp index 3880ee4a0..c88f38d5b 100644 --- a/src/openvic-simulation/population/Culture.cpp +++ b/src/openvic-simulation/population/Culture.cpp @@ -206,7 +206,7 @@ bool CultureManager::load_culture_file(CountryDefinitionManager const& country_d [this, &country_definition_manager](CultureGroup const& culture_group, ast::NodeCPtr culture_group_value) -> bool { return expect_dictionary( [this, &country_definition_manager, &culture_group](std::string_view key, ast::NodeCPtr value) -> bool { - static const string_set_t reserved_keys = { "leader", "unit", "union", "is_overseas" }; + static const memory::string_set_t reserved_keys = { "leader", "unit", "union", "is_overseas" }; if (reserved_keys.contains(key)) { return true; } diff --git a/src/openvic-simulation/population/Culture.hpp b/src/openvic-simulation/population/Culture.hpp index 603031593..51b090a0a 100644 --- a/src/openvic-simulation/population/Culture.hpp +++ b/src/openvic-simulation/population/Culture.hpp @@ -1,8 +1,9 @@ #pragma once -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" namespace OpenVic { struct CultureManager; @@ -74,7 +75,7 @@ namespace OpenVic { using general_admiral_picture_count_t = std::pair; // Cultural type string maps to (general picture count, admiral picture count) pair - string_map_t leader_picture_counts; + memory::string_map_t leader_picture_counts; bool _load_culture_group( CountryDefinitionManager const& country_definition_manager, size_t& total_expected_cultures, diff --git a/src/openvic-simulation/population/Pop.cpp b/src/openvic-simulation/population/Pop.cpp index e0199a6aa..2e8a14593 100644 --- a/src/openvic-simulation/population/Pop.cpp +++ b/src/openvic-simulation/population/Pop.cpp @@ -10,7 +10,9 @@ #include #include "openvic-simulation/core/error/ErrorMacros.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/country/CountryParty.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/defines/Define.hpp" @@ -34,8 +36,6 @@ #include "openvic-simulation/population/Religion.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/core/FormatValidate.hpp" @@ -93,13 +93,13 @@ void Pop::setup_pop_test_values(IssueManager const& issue_manager) { num_grown + num_promoted + num_demoted + num_migrated_internal + num_migrated_external + num_migrated_colonial; /* Generates a number between 0 and max (inclusive) and sets map[&key] to it if it's at least min. */ - auto test_weight_indexed = [](IndexedFlatMap& map, U const& key, int32_t min, int32_t max) -> void { + auto test_weight_indexed = [](memory::IndexedFlatMap& map, U const& key, int32_t min, int32_t max) -> void { const int32_t value = rand() % (max + 1); if (value >= min) { map.set(key, value); } }; - auto test_weight_ordered = [](ordered_map& map, U const& key, int32_t min, int32_t max) -> void { + auto test_weight_ordered = [](memory::ordered_map& map, U const& key, int32_t min, int32_t max) -> void { if constexpr (std::is_convertible_v || std::is_convertible_v) { const int32_t value = rand() % (max + 1); if (value >= min) { @@ -468,7 +468,7 @@ void Pop::allocate_for_needs( void Pop::pop_tick( PopValuesFromProvince const& shared_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_POP_TICK @@ -488,7 +488,7 @@ void Pop::pop_tick( void Pop::pop_tick_without_cleanup( PopValuesFromProvince const& shared_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_POP_TICK diff --git a/src/openvic-simulation/population/Pop.hpp b/src/openvic-simulation/population/Pop.hpp index a39c2b45a..eb2a000bf 100644 --- a/src/openvic-simulation/population/Pop.hpp +++ b/src/openvic-simulation/population/Pop.hpp @@ -1,11 +1,12 @@ #pragma once +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/economy/production/ArtisanalProducer.hpp" #include "openvic-simulation/population/PopNeedsMacro.hpp" #include "openvic-simulation/types/fixed_point/Atomic.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" #include "openvic-simulation/population/PopSize.hpp" #include "openvic-simulation/types/UnitBranchType.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -142,7 +143,7 @@ namespace OpenVic { fixed_point_t get_##need_category##_needs_fulfilled() const; \ private: \ fixed_point_map_t PROPERTY(need_category##_needs); /* TODO pool? (if recalculating in UI is acceptable) */ \ - ordered_map PROPERTY(need_category##_needs_fulfilled_goods); + memory::ordered_map PROPERTY(need_category##_needs_fulfilled_goods); OV_DO_FOR_ALL_NEED_CATEGORIES(NEED_MEMBERS) #undef NEED_MEMBERS @@ -176,7 +177,7 @@ namespace OpenVic { void pop_tick_without_cleanup( PopValuesFromProvince const& shared_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_POP_TICK @@ -219,7 +220,7 @@ namespace OpenVic { void pop_tick( PopValuesFromProvince const& shared_values, RandomU32& random_number_generator, - IndexedFlatMap& reusable_goods_mask, + memory::IndexedFlatMap& reusable_goods_mask, forwardable_span< memory::vector, VECTORS_FOR_POP_TICK diff --git a/src/openvic-simulation/population/PopManager.cpp b/src/openvic-simulation/population/PopManager.cpp index 3a54d3ff2..e8ba93929 100644 --- a/src/openvic-simulation/population/PopManager.cpp +++ b/src/openvic-simulation/population/PopManager.cpp @@ -2,6 +2,7 @@ #include +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/economy/GoodDefinition.hpp" #include "openvic-simulation/politics/Ideology.hpp" #include "openvic-simulation/politics/IssueManager.hpp" @@ -223,7 +224,7 @@ void PopManager::reserve_pop_types_and_delayed_nodes(size_t size) { static NodeCallback auto expect_needs_income(PopType::income_type_t& types) { using enum PopType::income_type_t; - static const string_map_t income_type_map { + static const memory::string_map_t income_type_map { { "administration", ADMINISTRATION }, { "education", EDUCATION }, { "military", MILITARY } @@ -492,7 +493,7 @@ bool PopManager::generate_modifiers(ModifierManager& modifier_manager) const { static constexpr bool HAS_NO_EFFECT = true; - IndexedFlatMap& strata_effects = + memory::IndexedFlatMap& strata_effects = modifier_manager.modifier_effect_cache.strata_effects; strata_effects = std::move(decltype(ModifierEffectCache::strata_effects){get_stratas()}); diff --git a/src/openvic-simulation/population/PopType.cpp b/src/openvic-simulation/population/PopType.cpp index c17778fa2..99b7c85b4 100644 --- a/src/openvic-simulation/population/PopType.cpp +++ b/src/openvic-simulation/population/PopType.cpp @@ -4,7 +4,7 @@ #include "openvic-simulation/country/CountryDefinition.hpp" #include "openvic-simulation/map/ProvinceInstance.hpp" -#include "openvic-simulation/utility/TslHelper.hpp" +#include "openvic-simulation/core/container/MutableIterator.hpp" using namespace OpenVic; diff --git a/src/openvic-simulation/population/PopType.hpp b/src/openvic-simulation/population/PopType.hpp index dd9073c20..80dd25fe6 100644 --- a/src/openvic-simulation/population/PopType.hpp +++ b/src/openvic-simulation/population/PopType.hpp @@ -3,9 +3,10 @@ #include "openvic-simulation/scripts/ConditionalWeight.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/population/PopSize.hpp" #include "openvic-simulation/types/PopSprite.hpp" #include "openvic-simulation/types/TypedIndices.hpp" @@ -45,9 +46,9 @@ namespace OpenVic { }; using rebel_units_t = fixed_point_map_t; - using poptype_weight_map_t = IndexedFlatMap; - using ideology_weight_map_t = IndexedFlatMap; - using issue_weight_map_t = ordered_map; + using poptype_weight_map_t = memory::IndexedFlatMap; + using ideology_weight_map_t = memory::IndexedFlatMap; + using issue_weight_map_t = memory::ordered_map; private: fixed_point_map_t PROPERTY(life_needs); diff --git a/src/openvic-simulation/population/PopValuesFromProvince.hpp b/src/openvic-simulation/population/PopValuesFromProvince.hpp index c5de706ba..6202f33e1 100644 --- a/src/openvic-simulation/population/PopValuesFromProvince.hpp +++ b/src/openvic-simulation/population/PopValuesFromProvince.hpp @@ -1,6 +1,6 @@ #pragma once -#include "openvic-simulation/types/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/utility/Getters.hpp" diff --git a/src/openvic-simulation/population/PopsAggregate.cpp b/src/openvic-simulation/population/PopsAggregate.cpp index cfea4518d..c67dbdea3 100644 --- a/src/openvic-simulation/population/PopsAggregate.cpp +++ b/src/openvic-simulation/population/PopsAggregate.cpp @@ -8,7 +8,6 @@ #include "openvic-simulation/population/Pop.hpp" #include "openvic-simulation/population/PopType.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" -#include "openvic-simulation/types/OrderedContainersMath.hpp" #include diff --git a/src/openvic-simulation/population/PopsAggregate.hpp b/src/openvic-simulation/population/PopsAggregate.hpp index 566bc4c5a..92e444676 100644 --- a/src/openvic-simulation/population/PopsAggregate.hpp +++ b/src/openvic-simulation/population/PopsAggregate.hpp @@ -1,9 +1,9 @@ #pragma once +#include "openvic-simulation/core/memory/IndexedFlatMap.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/fixed_point/FixedPointMap.hpp" -#include "openvic-simulation/types/IndexedFlatMap.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/population/PopSum.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/reactive/MutableState.hpp" @@ -37,10 +37,10 @@ namespace OpenVic { fixed_point_t PROPERTY(average_consciousness); fixed_point_t PROPERTY(average_militancy); - IndexedFlatMap militancy_by_strata_running_total_raw; - IndexedFlatMap life_needs_fulfilled_by_strata_running_total_raw; - IndexedFlatMap everyday_needs_fulfilled_by_strata_running_total_raw; - IndexedFlatMap luxury_needs_fulfilled_by_strata_running_total_raw; + memory::IndexedFlatMap militancy_by_strata_running_total_raw; + memory::IndexedFlatMap life_needs_fulfilled_by_strata_running_total_raw; + memory::IndexedFlatMap everyday_needs_fulfilled_by_strata_running_total_raw; + memory::IndexedFlatMap luxury_needs_fulfilled_by_strata_running_total_raw; OV_IFLATMAP_PROPERTY(Strata, fixed_point_t, militancy_by_strata); OV_IFLATMAP_PROPERTY(Strata, fixed_point_t, life_needs_fulfilled_by_strata); OV_IFLATMAP_PROPERTY(Strata, fixed_point_t, everyday_needs_fulfilled_by_strata); @@ -52,8 +52,8 @@ namespace OpenVic { OV_IFLATMAP_PROPERTY(Ideology, fixed_point_t, supporter_equivalents_by_ideology); fixed_point_map_t PROPERTY(supporter_equivalents_by_issue); fixed_point_map_t PROPERTY(vote_equivalents_by_party); - ordered_map PROPERTY(population_by_culture); - ordered_map PROPERTY(population_by_religion); + memory::ordered_map PROPERTY(population_by_culture); + memory::ordered_map PROPERTY(population_by_religion); protected: PopsAggregate( diff --git a/src/openvic-simulation/population/Religion.hpp b/src/openvic-simulation/population/Religion.hpp index 66287d9cb..5ef2577ee 100644 --- a/src/openvic-simulation/population/Religion.hpp +++ b/src/openvic-simulation/population/Religion.hpp @@ -1,8 +1,8 @@ #pragma once #include "openvic-simulation/dataloader/NodeTools.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" namespace OpenVic { struct ReligionGroup : HasIdentifier { diff --git a/src/openvic-simulation/research/Invention.hpp b/src/openvic-simulation/research/Invention.hpp index d03a84aa1..b1daf9e9f 100644 --- a/src/openvic-simulation/research/Invention.hpp +++ b/src/openvic-simulation/research/Invention.hpp @@ -1,10 +1,10 @@ #pragma once +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/modifier/Modifier.hpp" #include "openvic-simulation/scripts/ConditionalWeight.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" namespace OpenVic { @@ -21,9 +21,9 @@ namespace OpenVic { friend struct InventionManager; //TODO implement limit and chance - using unit_set_t = ordered_set; - using building_set_t = ordered_set; - using crime_set_t = ordered_set; + using unit_set_t = memory::ordered_set; + using building_set_t = memory::ordered_set; + using crime_set_t = memory::ordered_set; private: const bool PROPERTY_CUSTOM_PREFIX(news, is); diff --git a/src/openvic-simulation/research/Technology.cpp b/src/openvic-simulation/research/Technology.cpp index 03465761a..15fb4e079 100644 --- a/src/openvic-simulation/research/Technology.cpp +++ b/src/openvic-simulation/research/Technology.cpp @@ -245,7 +245,7 @@ bool TechnologyManager::generate_modifiers(ModifierManager& modifier_manager) co using enum ModifierEffect::format_t; using enum ModifierEffect::target_t; - IndexedFlatMap& research_bonus_effects = + memory::IndexedFlatMap& research_bonus_effects = modifier_manager.modifier_effect_cache.research_bonus_effects; research_bonus_effects = std::move(decltype(ModifierEffectCache::research_bonus_effects){get_technology_folders()}); diff --git a/src/openvic-simulation/research/Technology.hpp b/src/openvic-simulation/research/Technology.hpp index add495d67..7f6895e24 100644 --- a/src/openvic-simulation/research/Technology.hpp +++ b/src/openvic-simulation/research/Technology.hpp @@ -2,12 +2,12 @@ #include +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/HasIndex.hpp" +#include "openvic-simulation/core/memory/OrderedSet.hpp" #include "openvic-simulation/modifier/Modifier.hpp" #include "openvic-simulation/scripts/ConditionalWeight.hpp" #include "openvic-simulation/types/Date.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/HasIndex.hpp" -#include "openvic-simulation/types/OrderedContainers.hpp" #include "openvic-simulation/types/TypedIndices.hpp" #include "openvic-simulation/types/UnitVariant.hpp" #include "openvic-simulation/utility/Containers.hpp" @@ -49,8 +49,8 @@ namespace OpenVic { friend struct TechnologyManager; using area_index_t = uint8_t; - using unit_set_t = ordered_set; - using building_set_t = ordered_set; + using unit_set_t = memory::ordered_set; + using building_set_t = memory::ordered_set; private: const Date::year_t PROPERTY(year); diff --git a/src/openvic-simulation/scripts/Condition.cpp b/src/openvic-simulation/scripts/Condition.cpp index 08cc1d384..98f08fae7 100644 --- a/src/openvic-simulation/scripts/Condition.cpp +++ b/src/openvic-simulation/scripts/Condition.cpp @@ -475,7 +475,7 @@ callback_t ConditionManager::expect_parse_identifier( return callback(identified); \ } __VA_OPT__(else { \ /* TODO: the set is just a placeholder for actual logic */ \ - static const case_insensitive_string_set_t chances { __VA_ARGS__ }; \ + static const memory::case_insensitive_string_set_t chances { __VA_ARGS__ }; \ if (chances.contains(identifier)) { \ return true; \ } \ diff --git a/src/openvic-simulation/scripts/Condition.hpp b/src/openvic-simulation/scripts/Condition.hpp index 2e9633531..c6fff3f65 100644 --- a/src/openvic-simulation/scripts/Condition.hpp +++ b/src/openvic-simulation/scripts/Condition.hpp @@ -6,8 +6,8 @@ #include #include "openvic-simulation/core/template/EnumBitfield.hpp" -#include "openvic-simulation/types/HasIdentifier.hpp" -#include "openvic-simulation/types/IdentifierRegistry.hpp" +#include "openvic-simulation/core/container/HasIdentifier.hpp" +#include "openvic-simulation/core/container/IdentifierRegistry.hpp" #include "openvic-simulation/utility/Containers.hpp" namespace OpenVic { diff --git a/src/openvic-simulation/types/Colour.hpp b/src/openvic-simulation/types/Colour.hpp index acfb2605b..04005365e 100644 --- a/src/openvic-simulation/types/Colour.hpp +++ b/src/openvic-simulation/types/Colour.hpp @@ -25,7 +25,7 @@ #include -#include "openvic-simulation/types/StackString.hpp" +#include "openvic-simulation/core/container/StackString.hpp" #include "openvic-simulation/core/template/Concepts.hpp" #include "openvic-simulation/core/string/CharConv.hpp" #include "openvic-simulation/core/Typedefs.hpp" diff --git a/src/openvic-simulation/types/Date.hpp b/src/openvic-simulation/types/Date.hpp index 90c45b410..352d7a69e 100644 --- a/src/openvic-simulation/types/Date.hpp +++ b/src/openvic-simulation/types/Date.hpp @@ -17,7 +17,7 @@ #include #include "openvic-simulation/core/error/ErrorMacros.hpp" -#include "openvic-simulation/types/StackString.hpp" +#include "openvic-simulation/core/container/StackString.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/core/string/CharConv.hpp" #include "openvic-simulation/core/Typedefs.hpp" diff --git a/src/openvic-simulation/types/OrderedContainers.hpp b/src/openvic-simulation/types/OrderedContainers.hpp deleted file mode 100644 index d3af3e8ee..000000000 --- a/src/openvic-simulation/types/OrderedContainers.hpp +++ /dev/null @@ -1,206 +0,0 @@ -#pragma once - -#include -#include - -#include -#include - -#include "openvic-simulation/core/template/Concepts.hpp" -#include "openvic-simulation/utility/Containers.hpp" -#include "openvic-simulation/core/portable/Deque.hpp" -#include "openvic-simulation/core/string/Utility.hpp" - -#include -#include - -namespace OpenVic { - struct ordered_container_string_hash { - using is_transparent = void; - [[nodiscard]] size_t operator()(char const* txt) const { - return std::hash {}(txt); - } - [[nodiscard]] size_t operator()(std::string_view txt) const { - return std::hash {}(txt); - } - [[nodiscard]] size_t operator()(std::string const& txt) const { - return std::hash {}(txt); - } - [[nodiscard]] size_t operator()(memory::string const& txt) const { - return std::hash {}(txt); - } - }; - - template - struct container_hash : std::hash {}; - - template<> - struct container_hash : ordered_container_string_hash {}; - template<> - struct container_hash : ordered_container_string_hash {}; - template<> - struct container_hash : ordered_container_string_hash {}; - template<> - struct container_hash : ordered_container_string_hash {}; - template - struct container_hash : std::hash {}; - - // Useful for contiguous memory - template< - class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, - class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator, memory::tracker>> - using vector_ordered_map = - tsl::ordered_map, Allocator>, IndexType>; - - // Useful for stable memory addresses (so long as you don't remove or insert values) - template< - class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, - class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator, memory::tracker>> - using deque_ordered_map = - tsl::ordered_map, Allocator>, IndexType>; - - template< - class Key, class T, class Hash = container_hash, class KeyEqual = std::equal_to<>, - class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator, memory::tracker>> - using ordered_map = vector_ordered_map; - - // Useful for contiguous memory - template< - class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, - class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator>> - using vector_ordered_set = tsl::ordered_set, IndexType>; - - // Useful for stable memory addresses (so long as you don't remove or insert values) - template< - class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, - class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator>> - using deque_ordered_set = - tsl::ordered_set, IndexType>; - - template< - class Key, class Hash = container_hash, class KeyEqual = std::equal_to<>, - class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator>> - using ordered_set = vector_ordered_set; - - template - concept derived_ordered_map = derived_from_specialization_of; - - /* Case-Insensitive Containers */ - struct case_insensitive_string_hash { - using is_transparent = void; - - private: - /* Based on the byte array hashing functions in MSVC's . */ - [[nodiscard]] static constexpr size_t _hash_bytes_case_insensitive(char const* first, size_t count) { - constexpr size_t _offset_basis = 14695981039346656037ULL; - constexpr size_t _prime = 1099511628211ULL; - size_t hash = _offset_basis; - for (size_t i = 0; i < count; ++i) { - hash ^= static_cast(std::tolower(static_cast(first[i]))); - hash *= _prime; - } - return hash; - } - - public: - [[nodiscard]] constexpr size_t operator()(char const* txt) const { - return operator()(std::string_view { txt }); - } - [[nodiscard]] constexpr size_t operator()(std::string_view txt) const { - return _hash_bytes_case_insensitive(txt.data(), txt.length()); - } - [[nodiscard]] constexpr size_t operator()(std::string const& txt) const { - return _hash_bytes_case_insensitive(txt.data(), txt.length()); - } - [[nodiscard]] constexpr size_t operator()(memory::string const& txt) const { - return _hash_bytes_case_insensitive(txt.data(), txt.length()); - } - }; - - struct case_insensitive_string_equal { - using is_transparent = void; - - [[nodiscard]] constexpr bool operator()(std::string_view const& lhs, std::string_view const& rhs) const { - return ascii_equal_case_insensitive(lhs, rhs); - } - }; - - // Useful for contiguous memory - template< - class Key, class T, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator, memory::tracker>> - using case_insensitive_vector_ordered_map = vector_ordered_map< - Key, T, case_insensitive_string_hash, case_insensitive_string_equal, RawAllocator, IndexType, Allocator>; - - // Useful for stable memory addresses (so long as you don't remove or insert values) - template< - class Key, class T, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator, memory::tracker>> - using case_insensitive_deque_ordered_map = deque_ordered_map< - Key, T, case_insensitive_string_hash, case_insensitive_string_equal, RawAllocator, IndexType, Allocator>; - - template< - class Key, class T, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator, memory::tracker>> - using case_insensitive_ordered_map = case_insensitive_vector_ordered_map; - - // Useful for contiguous memory - template< - class Key, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator>> - using case_insensitive_vector_ordered_set = vector_ordered_set< - Key, case_insensitive_string_hash, case_insensitive_string_equal, RawAllocator, IndexType, Allocator>; - - // Useful for stable memory addresses (so long as you don't remove or insert values) - template< - class Key, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator>> - using case_insensitive_deque_ordered_set = - deque_ordered_set; - - template< - class Key, class RawAllocator = foonathan::memory::default_allocator, class IndexType = std::uint_least32_t, - class Allocator = foonathan::memory::std_allocator>> - using case_insensitive_ordered_set = case_insensitive_vector_ordered_set; - - struct StringMapCaseSensitive { - using hash = container_hash; - using equal = std::equal_to<>; - }; - struct StringMapCaseInsensitive { - using hash = case_insensitive_string_hash; - using equal = case_insensitive_string_equal; - }; - - /* Intermediate struct that "remembers" Case, instead of just decomposing it into its hash and equal components, - * needed so that templates can deduce the Case with which a type was defined. */ - template typename Container, string_map_case Case, typename... Args> - struct template_case_container_t : Container { - using container_t = Container; - using container_t::container_t; - - using case_t = Case; - }; - - /* Template for map with string keys, supporting search by string_view without creating an intermediate string. */ - template - using template_string_map_t = template_case_container_t; - - template - using string_map_t = template_string_map_t; - template - using case_insensitive_string_map_t = template_string_map_t; - - /* Template for set with string elements, supporting search by string_view without creating an intermediate string. */ - template - using template_string_set_t = template_case_container_t; - - using string_set_t = template_string_set_t; - using case_insensitive_string_set_t = template_string_set_t; -} diff --git a/src/openvic-simulation/types/OrderedContainersMath.hpp b/src/openvic-simulation/types/OrderedContainersMath.hpp deleted file mode 100644 index 5527ba03d..000000000 --- a/src/openvic-simulation/types/OrderedContainersMath.hpp +++ /dev/null @@ -1,173 +0,0 @@ -#pragma once - -#include -#include - -#include "openvic-simulation/types/OrderedContainers.hpp" -#include "openvic-simulation/core/template/Concepts.hpp" - -namespace OpenVic { - template - constexpr ordered_map operator-(ordered_map const& rhs) { - ordered_map result {}; - auto view = rhs | std::views::transform( - [](KeyType const& key, ValueType const& value) { - return std::make_pair(key, -value); - } - ); - result.insert(view.begin(), view.end()); - return result; - } - - template - constexpr ordered_map& operator+=( - ordered_map& lhs, - ordered_map const& rhs - ) requires add_assignable { - for (auto const& [key, rhs_value] : rhs) { - lhs[key] += rhs_value; - } - return lhs; - } - - template - constexpr ordered_map& operator-=( - ordered_map& lhs, - ordered_map const& rhs - ) requires subtract_assignable { - for (auto const& [key, rhs_value] : rhs) { - lhs[key] -= rhs_value; - } - return lhs; - } - - template - constexpr ordered_map& operator*=( - ordered_map& lhs, - ordered_map const& rhs - ) requires multiply_assignable { - for (auto const& [key, rhs_value] : rhs) { - lhs[key] *= rhs_value; - } - return lhs; - } - - template - constexpr ordered_map& operator/=( - ordered_map& lhs, - ordered_map const& rhs - ) requires divide_assignable { - for (auto const& [key, rhs_value] : rhs) { - lhs[key] = rhs_value; - } - return lhs; - } - - template - constexpr ordered_map& operator+=( - ordered_map& lhs, - RhsValueType const& rhs - ) requires add_assignable { - for (typename decltype(lhs)::iterator it = lhs.begin(); it != lhs.end(); ++it) { - it.value() += rhs; - } - return lhs; - } - - template - constexpr ordered_map& operator-=( - ordered_map& lhs, - RhsValueType const& rhs - ) requires subtract_assignable { - for (typename decltype(lhs)::iterator it = lhs.begin(); it != lhs.end(); ++it) { - it.value() -= rhs; - } - return lhs; - } - - template - constexpr ordered_map& operator*=( - ordered_map& lhs, - RhsValueType const& rhs - ) requires multiply_assignable { - for (typename decltype(lhs)::iterator it = lhs.begin(); it != lhs.end(); ++it) { - it.value() *= rhs; - } - return lhs; - } - - template - constexpr ordered_map& operator/=( - ordered_map& lhs, - RhsValueType const& rhs - ) requires divide_assignable { - for (auto it = lhs.begin(); it != lhs.end(); ++it) { - it.value() /= rhs; - } - return lhs; - } - - template - constexpr static ValueType get_total( - ordered_map const& map - ) requires std::is_default_constructible_v { - ValueType running_total {}; - for (auto const& [key, value] : map) { - running_total += value; - } - return running_total; - } - - template - constexpr static typename ordered_map::const_iterator get_largest_item( - ordered_map const& map - ) requires std::three_way_comparable_with { - constexpr auto pred = []( - typename ordered_map::value_type const& lhs, - typename ordered_map::value_type const& rhs - ) -> bool { - return lhs.second < rhs.second; - }; - - return std::max_element(map.begin(), map.end(), pred); - } - - /* This function includes a key comparator to choose between entries with equal values. */ - template - constexpr static typename ordered_map::const_iterator get_largest_item_tie_break( - ordered_map const& map, const auto key_pred - ) requires std::three_way_comparable_with { - constexpr auto pred = [key_pred]( - typename ordered_map::value_type const& lhs, - typename ordered_map::value_type const& rhs - ) -> bool { - return lhs.second < rhs.second || (lhs.second == rhs.second && key_pred(lhs.first, rhs.first)); - }; - - return std::max_element(map.begin(), map.end(), pred); - } - - template - constexpr static std::pair< - typename ordered_map::const_iterator, - typename ordered_map::const_iterator - > get_largest_two_items( - ordered_map const& map - ) requires std::three_way_comparable_with { - typename ordered_map::const_iterator largest = map.end(), second_largest = map.end(); - - for (typename ordered_map::const_iterator it = map.begin(); it != map.end(); ++it) { - if (largest == map.end() || it->second > largest->second) { - second_largest = largest; - largest = it; - } else if (second_largest == map.end() || it->second > second_largest->second) { - second_largest = it; - } - } - - return std::make_pair( - std::move(largest), - std::move(second_largest) - ); - } -} \ No newline at end of file diff --git a/src/openvic-simulation/types/Signal.hpp b/src/openvic-simulation/types/Signal.hpp index 882ed3d46..fa4f08736 100644 --- a/src/openvic-simulation/types/Signal.hpp +++ b/src/openvic-simulation/types/Signal.hpp @@ -12,8 +12,7 @@ #include #include -#include "openvic-simulation/types/CowPtr.hpp" -#include "openvic-simulation/types/CowVector.hpp" +#include "openvic-simulation/core/container/CowVector.hpp" #include "openvic-simulation/core/thread/NullMutex.hpp" #include "openvic-simulation/utility/Containers.hpp" #include "openvic-simulation/core/Typedefs.hpp" @@ -1243,7 +1242,7 @@ namespace OpenVic::_detail::signal { // create a new slot template inline std::shared_ptr make_slot(A&&... a) { - return make_shared(*this, std::forward(a)...); + return signal::make_shared(*this, std::forward(a)...); } // add the slot to the list of slots of the right group diff --git a/src/openvic-simulation/types/Vector.hpp b/src/openvic-simulation/types/Vector.hpp index 082bd1d03..c2d5b7f3f 100644 --- a/src/openvic-simulation/types/Vector.hpp +++ b/src/openvic-simulation/types/Vector.hpp @@ -5,7 +5,7 @@ #include -#include "openvic-simulation/types/BasicIterator.hpp" // IWYU pragma: keep +#include "openvic-simulation/core/container/BasicIterator.hpp" // IWYU pragma: keep #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/core/template/Concepts.hpp" // IWYU pragma: keep #include "openvic-simulation/core/Math.hpp" // IWYU pragma: keep diff --git a/src/openvic-simulation/types/fixed_point/FixedPoint.hpp b/src/openvic-simulation/types/fixed_point/FixedPoint.hpp index 764c7c4fb..105ec2907 100644 --- a/src/openvic-simulation/types/fixed_point/FixedPoint.hpp +++ b/src/openvic-simulation/types/fixed_point/FixedPoint.hpp @@ -16,7 +16,7 @@ #include -#include "openvic-simulation/types/StackString.hpp" +#include "openvic-simulation/core/container/StackString.hpp" #include "openvic-simulation/utility/Getters.hpp" #include "openvic-simulation/utility/Logger.hpp" #include "openvic-simulation/core/string/CharConv.hpp" diff --git a/src/openvic-simulation/types/fixed_point/FixedPointMap.hpp b/src/openvic-simulation/types/fixed_point/FixedPointMap.hpp index 82762167f..43c802d6b 100644 --- a/src/openvic-simulation/types/fixed_point/FixedPointMap.hpp +++ b/src/openvic-simulation/types/fixed_point/FixedPointMap.hpp @@ -1,13 +1,13 @@ #pragma once -#include "openvic-simulation/types/OrderedContainers.hpp" -#include "openvic-simulation/types/OrderedContainersMath.hpp" +#include "openvic-simulation/core/container/MutableIterator.hpp" +#include "openvic-simulation/core/memory/OrderedMap.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" namespace OpenVic { template - using fixed_point_map_t = ordered_map; + using fixed_point_map_t = memory::ordered_map; template using fixed_point_map_value_t = typename fixed_point_map_t::value_type; diff --git a/src/openvic-simulation/utility/Containers.hpp b/src/openvic-simulation/utility/Containers.hpp index eb115a663..cfb3321ea 100644 --- a/src/openvic-simulation/utility/Containers.hpp +++ b/src/openvic-simulation/utility/Containers.hpp @@ -12,8 +12,6 @@ #include -#include "openvic-simulation/types/CowPtr.hpp" -#include "openvic-simulation/types/CowVector.hpp" #include "openvic-simulation/utility/DequeMemory.hpp" #include "openvic-simulation/utility/MemoryTracker.hpp" @@ -267,12 +265,6 @@ namespace OpenVic::memory { using stringstream = stringstream_alloc<>; using wstringstream = wstringstream_alloc<>; - template - using cow_ptr = cow_ptr>>; - - template - using cow_vector = cow_vector>>; - namespace fmt { template using basic_memory_buffer = ::fmt::basic_memory_buffer< diff --git a/src/openvic-simulation/utility/ThreadPool.cpp b/src/openvic-simulation/utility/ThreadPool.cpp index 2fc169548..8b9edbb19 100644 --- a/src/openvic-simulation/utility/ThreadPool.cpp +++ b/src/openvic-simulation/utility/ThreadPool.cpp @@ -1,5 +1,7 @@ #include "ThreadPool.hpp" +#include "openvic-simulation/core/container/TypedSpan.hpp" +#include "openvic-simulation/core/memory/FixedVector.hpp" #include "openvic-simulation/country/CountryInstance.hpp" #include "openvic-simulation/economy/GoodDefinition.hpp" // IWYU pragma: keep for constructor requirement #include "openvic-simulation/economy/GoodInstance.hpp" @@ -7,7 +9,6 @@ #include "openvic-simulation/map/ProvinceInstance.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/TypedIndices.hpp" -#include "openvic-simulation/types/TypedSpan.hpp" #include "openvic-simulation/utility/Containers.hpp" using namespace OpenVic; @@ -24,7 +25,7 @@ void ThreadPool::loop_until_cancelled( forwardable_span strata_keys, forwardable_span work_bundles ) { - IndexedFlatMap reusable_goods_mask { good_keys }; + memory::IndexedFlatMap reusable_goods_mask { good_keys }; memory::FixedVector reusable_country_map_0 { country_keys.size(), fixed_point_t::_0 }; memory::FixedVector reusable_country_map_1 { country_keys.size(), fixed_point_t::_0 }; diff --git a/tests/src/types/FixedVector.cpp b/tests/src/core/container/FixedVector.cpp similarity index 98% rename from tests/src/types/FixedVector.cpp rename to tests/src/core/container/FixedVector.cpp index 5ead40c0e..bd8d54961 100644 --- a/tests/src/types/FixedVector.cpp +++ b/tests/src/core/container/FixedVector.cpp @@ -1,4 +1,4 @@ -#include "openvic-simulation/types/FixedVector.hpp" +#include "openvic-simulation/core/container/FixedVector.hpp" #include #include @@ -6,7 +6,7 @@ #include #include -using namespace OpenVic::_detail; +using namespace OpenVic; // A simple test type to demonstrate a more complex object. // It has a multi-argument constructor to test emplace_back. diff --git a/tests/src/types/RingBuffer.cpp b/tests/src/core/container/RingBuffer.cpp similarity index 99% rename from tests/src/types/RingBuffer.cpp rename to tests/src/core/container/RingBuffer.cpp index 9fa4e434a..ab73be81b 100644 --- a/tests/src/types/RingBuffer.cpp +++ b/tests/src/core/container/RingBuffer.cpp @@ -1,4 +1,4 @@ -#include "openvic-simulation/types/RingBuffer.hpp" +#include "openvic-simulation/core/container/RingBuffer.hpp" #include "Helper.hpp" // IWYU pragma: keep #include diff --git a/tests/src/dataloader/NodeTools.cpp b/tests/src/dataloader/NodeTools.cpp index ca3842d42..bef5bc1a7 100644 --- a/tests/src/dataloader/NodeTools.cpp +++ b/tests/src/dataloader/NodeTools.cpp @@ -22,6 +22,7 @@ #include #include +#include "openvic-simulation/core/memory/StringMap.hpp" #include "openvic-simulation/types/Colour.hpp" #include "openvic-simulation/types/Date.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" @@ -559,7 +560,7 @@ TEST_CASE( auto callback = [](FlatValue const* ptr, text_format_t val) -> bool { using enum text_format_t; - static const string_map_t format_map = // + static const memory::string_map_t format_map = // { // { "left", left }, // { "right", right }, @@ -1397,14 +1398,14 @@ TEST_CASE( ) { Ast ast; - static const string_map_t map // + static const memory::string_map_t map // { // { "key_test1", "value_test1"sv }, { "key_test2", "value_test2"sv }, { "key_test3", "value_test3"sv } }; - static auto callback = [](string_map_t const& map, size_t expected_index, std::string_view val) { + static auto callback = [](memory::string_map_t const& map, size_t expected_index, std::string_view val) { CHECK_IF(map.size() > expected_index); else { return false; @@ -1426,7 +1427,7 @@ TEST_CASE( CHECK(NodeTools::expect_mapped_string(map, std::bind_front(callback, map, 1))(map.values_container()[1].first)); CHECK(NodeTools::expect_mapped_string(map, std::bind_front(callback, map, 2))(map.values_container()[2].first)); - static auto callback_false = [](string_map_t const& map, size_t check_index, std::string_view val) { + static auto callback_false = [](memory::string_map_t const& map, size_t check_index, std::string_view val) { for (auto [index, pair] : map | ranges::views::enumerate) { if (index != check_index) { continue; diff --git a/tests/src/economy/trading/GoodMarket.cpp b/tests/src/economy/trading/GoodMarket.cpp index f8932c948..0e4948a0e 100644 --- a/tests/src/economy/trading/GoodMarket.cpp +++ b/tests/src/economy/trading/GoodMarket.cpp @@ -5,7 +5,7 @@ #include "openvic-simulation/types/Colour.hpp" #include "openvic-simulation/types/fixed_point/FixedPoint.hpp" #include "openvic-simulation/types/TypedIndices.hpp" -#include "openvic-simulation/types/TypedSpan.hpp" +#include "openvic-simulation/core/container/TypedSpan.hpp" #include #include