// This kinda belongs in LanguageIni.cs, but it's separated to prevent it from being removed when that // file is re-generated. I could make it so it doesn't get removed, but meh. internal static void AddLanguageFromFile(string file, DictionaryI <string> langDict) { StreamReader?sr = null; try { sr = new StreamReader(file, Encoding.UTF8); bool inMeta = false; string?line; while ((line = sr.ReadLine()) != null) { string lineT = line.Trim(); if (inMeta && lineT.StartsWithFast_NoNullChecks(nameof(LText.Meta.TranslatedLanguageName) + "=")) { string key = file.GetFileNameFast().RemoveExtension(); string value = line.TrimStart().Substring(nameof(LText.Meta.TranslatedLanguageName).Length + 1); langDict[key] = value; return; } else if (lineT == "[" + nameof(LText.Meta) + "]") { inMeta = true; } else if (!lineT.IsEmpty() && lineT[0] == '[' && lineT[lineT.Length - 1] == ']') { inMeta = false; } } } catch (Exception ex) { Log("There was an error while reading " + file + ".", ex); } finally { sr?.Dispose(); } }
public FMCategoriesCollection(int capacity) { _list = new List <string>(capacity); _dict = new DictionaryI <FMTagsCollection>(capacity); }
// MT: On startup only, this is run in parallel with MainForm.ctor and .InitThreadable() // So don't touch anything the other touches: anything affecting the view. // @CAN_RUN_BEFORE_VIEW_INIT private static List <int> FindInternal(bool startup) { if (!startup) { // Make sure we don't lose anything when we re-find! // NOTE: This also writes out TagsStrings and then reads them back in and syncs them with Tags. // Critical that that gets done. Ini.WriteFullFMDataIni(); // Do this every time we modify FMsViewList in realtime, to prevent FMsDGV from redrawing from // the list when it's in an indeterminate state (which can cause a selection change (bad) and/or // a visible change of the list (not really bad but unprofessional looking)). // MT: Don't do this on startup because we're running in parallel with the form new/init in that case. Core.View.SetRowCount(0); } // Init or reinit - must be deep-copied or changes propagate back because reference types // MT: This is thread-safe, the view ctor and InitThreadable() doesn't touch it. PresetTags.DeepCopyTo(GlobalTags); #region Back up lists and read FM data file // Copy FMs to backup lists before clearing, in case we can't read the ini file. We don't want to end // up with a blank or incomplete list and then glibly save it out later. FanMission[] backupList = new FanMission[FMDataIniList.Count]; FMDataIniList.CopyTo(backupList); FanMission[] viewBackupList = new FanMission[FMsViewList.Count]; FMsViewList.CopyTo(viewBackupList); FMDataIniList.Clear(); FMsViewList.Clear(); bool fmDataIniExists = File.Exists(Paths.FMDataIni); if (fmDataIniExists) { try { Ini.ReadFMDataIni(Paths.FMDataIni, FMDataIniList); } catch (Exception ex) { Log("Exception reading FM data ini", ex); if (startup) { // Language will be loaded by this point Dialogs.ShowError(LText.AlertMessages.FindFMs_ExceptionReadingFMDataIni); Core.EnvironmentExitDoShutdownTasks(1); } else { FMDataIniList.ClearAndAdd(backupList); FMsViewList.ClearAndAdd(viewBackupList); return(new List <int>()); } } } #endregion #region Get installed dirs from disk // Could check inside the folder for a .mis file to confirm it's really an FM folder, but that's // horrendously expensive. Talking like eight seconds vs. < 4ms for the 1098 set. Weird. var perGameInstFMDirsList = new List <List <string> >(SupportedGameCount); var perGameInstFMDirsDatesList = new List <List <DateTime> >(SupportedGameCount); for (int gi = 0; gi < SupportedGameCount; gi++) { // NOTE! Make sure this list ends up with SupportedGameCount items in it. Just in case I change // the loop or something. perGameInstFMDirsList.Add(new List <string>()); perGameInstFMDirsDatesList.Add(new List <DateTime>()); string instPath = Config.GetFMInstallPath((GameIndex)gi); if (Directory.Exists(instPath)) { try { var dirs = FastIO.GetDirsTopOnly_FMs(instPath, "*", out List <DateTime> dateTimes); for (int di = 0; di < dirs.Count; di++) { string d = dirs[di]; if (!d.EqualsI(Paths.FMSelCache)) { perGameInstFMDirsList[gi].Add(d); perGameInstFMDirsDatesList[gi].Add(dateTimes[di]); } } } catch (Exception ex) { Log("Exception getting directories in " + instPath, ex); } } } #endregion #region Get archives from disk var fmArchivesAndDatesDict = new DictionaryI <DateTime>(); var archivePaths = FMArchives.GetFMArchivePaths(); bool onlyOnePath = archivePaths.Count == 1; for (int ai = 0; ai < archivePaths.Count; ai++) { try { // Returns filenames only (not full paths) var files = FastIO.GetFilesTopOnly_FMs(archivePaths[ai], "*", out List <DateTime> dateTimes); for (int fi = 0; fi < files.Count; fi++) { string f = files[fi]; // Do this first because it should be faster than a dictionary lookup if (!f.ExtIsArchive()) { continue; } // NOTE: We do a ContainsKey check to keep behavior the same as previously. When we use // dict[key] = value, it _replaces_ the value with the new one every time. What we want // is for it to just not touch it at all if the key is already in there. This check does // technically slow it down some, but the actual perf degradation is negligible. And we // still avoid the n-squared 1.6-million-call nightmare we get with ~1600 FMs in the list. // Nevertheless, we can avoid even this small extra cost if we only have one FM archive // path, so no harm in keeping the only-one-path check. if ((onlyOnePath || !fmArchivesAndDatesDict.ContainsKey(f)) && // @DIRSEP: These are filename only, no need for PathContainsI() !f.ContainsI(Paths.FMSelBak)) { fmArchivesAndDatesDict[f] = dateTimes[fi]; } } } catch (Exception ex) { Log("Exception getting files in " + archivePaths[ai], ex); } } int fmArchivesAndDatesDictLen = fmArchivesAndDatesDict.Count; // PERF_TODO: May want to keep these as dicts later or change other vars to dicts string[] fmArchives = new string[fmArchivesAndDatesDictLen]; DateTime[] fmArchivesDates = new DateTime[fmArchivesAndDatesDictLen]; { int i = 0; foreach (var item in fmArchivesAndDatesDict) { fmArchives[i] = item.Key; fmArchivesDates[i] = item.Value; i++; } } #endregion #region Build FanMission objects from installed dirs var perGameFMsList = new List <List <FanMission> >(SupportedGameCount); for (int gi = 0; gi < SupportedGameCount; gi++) { // NOTE! List must have SupportedGameCount items in it perGameFMsList.Add(new List <FanMission>()); for (int di = 0; di < perGameInstFMDirsList[gi].Count; di++) { perGameFMsList[gi].Add(new FanMission { InstalledDir = perGameInstFMDirsList[gi][di], Game = GameIndexToGame((GameIndex)gi), Installed = true }); } } #endregion MergeNewArchiveFMs(fmArchives, fmArchivesDates); int instInitCount = FMDataIniList.Count; for (int i = 0; i < SupportedGameCount; i++) { var curGameInstFMsList = perGameFMsList[i]; if (curGameInstFMsList.Count > 0) { MergeNewInstalledFMs(curGameInstFMsList, perGameInstFMDirsDatesList[i], instInitCount); } } SetArchiveNames(fmArchives); SetInstalledNames(); // Super quick-n-cheap hack for perf: So we don't have to iterate the whole list looking for unscanned // FMs. This will contain indexes into FMDataIniList (not FMsViewList!) var fmsViewListUnscanned = new List <int>(FMDataIniList.Count); BuildViewList(fmArchives, perGameInstFMDirsList, fmsViewListUnscanned); return(fmsViewListUnscanned); /* * TODO: There's an extreme corner case where duplicate FMs can appear in the list * It's so unlikely it's almost not worth worrying about, but here's the scenario: * -The FM is installed by hand and not truncated * -The FM is not in the list * -A matching archive exists for the FM * In this scenario, the FM is added twice to the list, once with the full installed folder name and * NoArchive set to true, and once with a truncated installed dir name, the correct archive name, and * NoArchive not present (false). * The code in here is so crazy-go-nuts I can't even find where this is happening. But putting this * note down for the future. */ }
public FMCategoriesCollection() { _list = new List <string>(); _dict = new DictionaryI <FMTagsCollection>(); }