Use unordered set for disabled module names

MaximDude · MaximDude · commit aa243deb5f9a · 2023-07-23T07:19:52.000+03:00
Check modules for enabled instead of disabled
diff --git a/Managers/ModuleMan.cpp b/Managers/ModuleMan.cpp
@@ -18,7 +18,7 @@ namespace RTE {
 
 	void ModuleMan::Clear() {
 		m_LoadedDataModules.clear();
-		m_DisabledMods.clear();
+		m_DisabledDataModuleNames.clear();
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -158,8 +158,6 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	bool ModuleMan::LoadAllDataModules() {
-		Destroy();
-
 		LoadOfficialModules();
 
 		// If a single module is specified, skip loading all other unofficial modules and load specified module only.
@@ -230,7 +228,7 @@ namespace RTE {
 			std::string directoryEntryPath = directoryEntry.path().generic_string();
 			if (directoryEntryPath.ends_with(".rte")) {
 				std::string moduleName = directoryEntryPath.substr(directoryEntryPath.find_last_of('/') + 1, std::string::npos);
-				if (!g_ModuleMan.IsModDisabled(moduleName) && !IsModuleOfficial(moduleName) && !IsModuleUserdata(moduleName)) {
+				if (g_ModuleMan.IsModuleEnabled(moduleName) && !IsModuleOfficial(moduleName) && !IsModuleUserdata(moduleName)) {
 					// NOTE: LoadDataModule can return false (especially since it may try to load already loaded modules, which is okay) and shouldn't cause stop, so we can ignore its return value here.
 					LoadDataModule(moduleName, DataModule::DataModuleType::Unofficial, LoadingScreen::LoadingSplashProgressReport);
 				}
@@ -253,7 +251,11 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	bool ModuleMan::IsModDisabled(const std::string &modModule) const {
-		return (m_DisabledMods.find(modModule) != m_DisabledMods.end()) ? m_DisabledMods.at(modModule) : false;
+	bool ModuleMan::IsModuleEnabled(const std::string_view &moduleName) const {
+		return std::none_of(m_DisabledDataModuleNames.begin(), m_DisabledDataModuleNames.end(),
+			[&moduleName](const std::string_view &disabledModuleName) {
+				return disabledModuleName == moduleName;
+			}
+		);
 	}
 }
diff --git a/Managers/ModuleMan.h b/Managers/ModuleMan.h
@@ -118,6 +118,21 @@ namespace RTE {
 		std::string GetFullModulePath(const std::string &modulePath) const;
 #pragma endregion
 
+#pragma region DataModule Management
+		/// <summary>
+		/// Gets the DataModule names that are disabled and should not be loaded at startup.
+		/// </summary>
+		/// <returns>Map of mods which are disabled.</returns>
+		std::unordered_set<std::string> & GetDisabledDataModuleNames() { return m_DisabledDataModuleNames; }
+
+		/// <summary>
+		/// Gets whether the specified mod is disabled in the settings.
+		/// </summary>
+		/// <param name="moduleName">Mod to check.</param>
+		/// <returns>Whether the module is disabled via settings.</returns>
+		bool IsModuleEnabled(const std::string_view &moduleName) const;
+#pragma endregion
+
 #pragma region Contrete Methods
 		/// <summary>
 		/// Reads an entire DataModule and adds it to this. NOTE that official modules can't be loaded after any non-official ones!
@@ -134,18 +149,7 @@ namespace RTE {
 		bool LoadAllDataModules();
 #pragma endregion
 
-		/// <summary>
-		/// Gets the map of mods which are disabled.
-		/// </summary>
-		/// <returns>Map of mods which are disabled.</returns>
-		std::map<std::string, bool> & GetDisabledModsMap() { return m_DisabledMods; }
 
-		/// <summary>
-		/// Gets whether the specified mod is disabled in the settings.
-		/// </summary>
-		/// <param name="modModule">Mod to check.</param>
-		/// <returns>Whether the mod is disabled via settings.</returns>
-		bool IsModDisabled(const std::string &modModule) const;
 
 	private:
 
@@ -154,10 +158,9 @@ namespace RTE {
 
 		std::unordered_map<int, DataModule *> m_LoadedDataModules; //!< Map of all loaded DataModules by their ID. Owned by this.
 
+		std::unordered_set<std::string> m_DisabledDataModuleNames; //!< The DataModule names that are disabled and should not be loaded at startup.
 		std::string m_SingleModuleToLoad; //!< Name of the single module to load after the official modules.
 
-		std::map<std::string, bool> m_DisabledMods; //!< Map of the module names that are disabled.
-
 #pragma region Module Loading Breakdown
 		/// <summary>
 		/// Loads all the official DataModules individually with LoadDataModule.
diff --git a/Managers/SettingsMan.cpp b/Managers/SettingsMan.cpp
@@ -289,7 +289,7 @@ namespace RTE {
 		} else if (propName == "VisibleAssemblyGroup") {
 			m_VisibleAssemblyGroupsList.push_back(reader.ReadPropValue());
 		} else if (propName == "DisableMod") {
-			g_ModuleMan.m_DisabledMods.try_emplace(reader.ReadPropValue(), true);
+			g_ModuleMan.m_DisabledDataModuleNames.emplace(reader.ReadPropValue());
 		} else if (propName == "EnableGlobalScript") {
 			m_EnabledGlobalScripts.try_emplace(reader.ReadPropValue(), true);
 		} else if (propName == "MouseSensitivity") {
@@ -472,13 +472,13 @@ namespace RTE {
 			}
 		}
 
-		if (!g_ModuleMan.m_DisabledMods.empty()) {
+		if (!g_ModuleMan.m_DisabledDataModuleNames.empty()) {
 			writer.NewLine(false, 2);
 			writer.NewDivider(false);
 			writer.NewLineString("// Disabled Mods", false);
 			writer.NewLine(false);
-			for (const auto &[modPath, modDisabled] : g_ModuleMan.m_DisabledMods) {
-				if (modDisabled) { writer.NewPropertyWithValue("DisableMod", modPath); }
+			for (const std::string &disabledModuleName : g_ModuleMan.m_DisabledDataModuleNames) {
+				writer.NewPropertyWithValue("DisableMod", disabledModuleName);
 			}
 		}
 
diff --git a/Menus/ModManagerGUI.cpp b/Menus/ModManagerGUI.cpp
@@ -58,21 +58,20 @@ namespace RTE {
 	void ModManagerGUI::PopulateKnownModsList() {
 		for (const auto &[moduleID, dataModule] : g_ModuleMan.GetLoadedDataModules()) {
 			if (!dataModule->IsOfficial() && !dataModule->IsUserdata()) {
-				m_KnownMods.emplace_back(dataModule->GetFileName(), dataModule->GetFriendlyName(), dataModule->GetDescription(), g_ModuleMan.IsModDisabled(dataModule->GetFileName()));
+				m_KnownMods.emplace_back(dataModule->GetFileName(), dataModule->GetFriendlyName(), dataModule->GetDescription(), g_ModuleMan.IsModuleEnabled(dataModule->GetFileName()));
 			}
 		}
 		// Add missing data from disabled mods settings
-		for (const auto &[modPath, modDisabled] : g_ModuleMan.GetDisabledModsMap()) {
+		for (const std::string &disabledModuleName : g_ModuleMan.GetDisabledDataModuleNames()) {
 			bool found = false;
 			for (const ModRecord &knowModListEntry : m_KnownMods) {
-				if (modPath == knowModListEntry.ModulePath) {
+				if (disabledModuleName == knowModListEntry.ModulePath) {
 					found = true;
 					break;
 				}
 			}
 			if (!found) {
-				ModRecord disabledModRecord = { modPath, "N/A, Module not loaded", "N/A, Module not loaded", modDisabled };
-				m_KnownMods.emplace_back(disabledModRecord);
+				m_KnownMods.emplace_back(disabledModuleName, "N/A, Module not loaded", "N/A, Module not loaded", false);
 			}
 		}
 		std::sort(m_KnownMods.begin(), m_KnownMods.end());
@@ -110,21 +109,17 @@ namespace RTE {
 	void ModManagerGUI::ToggleMod() {
 		int index = m_ModsListBox->GetSelectedIndex();
 		if (index > -1) {
-			std::map<std::string, bool> &disabledModsList = g_ModuleMan.GetDisabledModsMap();
+			std::unordered_set<std::string> &disabledModsList = g_ModuleMan.GetDisabledDataModuleNames();
 			GUIListPanel::Item *selectedItem = m_ModsListBox->GetSelected();
 			ModRecord &modRecord = m_KnownMods.at(selectedItem->m_ExtraIndex);
 
-			modRecord.Disabled = !modRecord.Disabled;
-			if (modRecord.Disabled) {
-				m_ToggleModButton->SetText("Enable Mod");
-				if (disabledModsList.find(modRecord.ModulePath) != disabledModsList.end()) {
-					disabledModsList.at(modRecord.ModulePath) = true;
-				} else {
-					disabledModsList.try_emplace(modRecord.ModulePath, true);
-				}
-			} else {
+			modRecord.Enabled = !modRecord.Enabled;
+			if (modRecord.Enabled) {
 				m_ToggleModButton->SetText("Disable Mod");
-				disabledModsList.at(modRecord.ModulePath) = false;
+				disabledModsList.erase(disabledModsList.find(modRecord.ModulePath));
+			} else {
+				m_ToggleModButton->SetText("Enable Mod");
+				disabledModsList.emplace(modRecord.ModulePath);
 			}
 			selectedItem->m_Name = modRecord.GetDisplayString();
 			m_ModsListBox->SetSelectedIndex(index);
@@ -186,7 +181,7 @@ namespace RTE {
 				if (guiEvent.GetControl() == m_ModsListBox && (guiEvent.GetMsg() == GUIListBox::Select && m_ModsListBox->GetSelectedIndex() > -1)) {
 					const ModRecord &modRecord = m_KnownMods.at(m_ModsListBox->GetSelected()->m_ExtraIndex);
 					m_ModOrScriptDescriptionLabel->SetText(modRecord.Description);
-					m_ToggleModButton->SetText(modRecord.Disabled ? "Enable Mod" : "Disable Mod");
+					m_ToggleModButton->SetText(modRecord.Enabled ? "Disable Mod" : "Enable Mod");
 				} else if (guiEvent.GetControl() == m_ScriptsListBox && (guiEvent.GetMsg() == GUIListBox::Select && m_ScriptsListBox->GetSelectedIndex() > -1)) {
 					const ScriptRecord &scriptRecord = m_KnownScripts.at(m_ScriptsListBox->GetSelected()->m_ExtraIndex);
 					m_ModOrScriptDescriptionLabel->SetText(scriptRecord.Description);
diff --git a/Menus/ModManagerGUI.h b/Menus/ModManagerGUI.h
@@ -48,13 +48,13 @@ namespace RTE {
 			std::string ModulePath; //!< Mod DataModule path.
 			std::string ModuleName; //!< Mod ModuleName.
 			std::string Description; //!< Mod description.
-			bool Disabled; //!< Whether the mod is disabled through the settings file or not.
+			bool Enabled; //!< Whether the mod is disabled through the settings file or not.
 
 			/// <summary>
 			/// Makes GUI displayable string with mod info.
 			/// </summary>
 			/// <returns>String with mod info.</returns>
-			std::string GetDisplayString() const { return (Disabled ? "- " : "+ ") + ModulePath + " - " + ModuleName; }
+			std::string GetDisplayString() const { return (Enabled ? "+ " : "- ") + ModulePath + " - " + ModuleName; }
 
 			/// <summary>
 			/// Comparison operator for sorting the KnownMods list alphabetically by path with std::sort.

Original file line number	Diff line number	Diff line change
`@@ -289,7 +289,7 @@ namespace RTE {`
`289`	`289`	`} else if (propName == "VisibleAssemblyGroup") {`
`290`	`290`	`m_VisibleAssemblyGroupsList.push_back(reader.ReadPropValue());`
`291`	`291`	`} else if (propName == "DisableMod") {`
`292`		`- g_ModuleMan.m_DisabledMods.try_emplace(reader.ReadPropValue(), true);`
	`292`	`+ g_ModuleMan.m_DisabledDataModuleNames.emplace(reader.ReadPropValue());`
`293`	`293`	`} else if (propName == "EnableGlobalScript") {`
`294`	`294`	`m_EnabledGlobalScripts.try_emplace(reader.ReadPropValue(), true);`
`295`	`295`	`} else if (propName == "MouseSensitivity") {`
`@@ -472,13 +472,13 @@ namespace RTE {`
`472`	`472`	`}`
`473`	`473`	`}`
`474`	`474`
`475`		`- if (!g_ModuleMan.m_DisabledMods.empty()) {`
	`475`	`+ if (!g_ModuleMan.m_DisabledDataModuleNames.empty()) {`
`476`	`476`	`writer.NewLine(false, 2);`
`477`	`477`	`writer.NewDivider(false);`
`478`	`478`	`writer.NewLineString("// Disabled Mods", false);`
`479`	`479`	`writer.NewLine(false);`
`480`		`- for (const auto &[modPath, modDisabled] : g_ModuleMan.m_DisabledMods) {`
`481`		`- if (modDisabled) { writer.NewPropertyWithValue("DisableMod", modPath); }`
	`480`	`+ for (const std::string &disabledModuleName : g_ModuleMan.m_DisabledDataModuleNames) {`
	`481`	`+ writer.NewPropertyWithValue("DisableMod", disabledModuleName);`
`482`	`482`	`}`
`483`	`483`	`}`
`484`	`484`