Merge pull request #77 from Laupetin/refactor/localize-remove-duplication

Remove duplicated code in localize asset loading

src/ObjCommon/Localize/CommonLocalizeEntry.cpp

@@ -0,0 +1,9 @@
+#include "CommonLocalizeEntry.h"
+
+CommonLocalizeEntry::CommonLocalizeEntry() = default;
+
+CommonLocalizeEntry::CommonLocalizeEntry(std::string key, std::string value)
+    : m_key(std::move(key)),
+      m_value(std::move(value))
+{
+}

src/ObjCommon/Localize/CommonLocalizeEntry.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <string>
+
+class CommonLocalizeEntry
+{
+public:
+    std::string m_key;
+    std::string m_value;
+
+    CommonLocalizeEntry();
+    CommonLocalizeEntry(std::string key, std::string value);
+};

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,9 +1,6 @@
 #include "AssetLoaderLocalizeEntry.h"
 
-#include "Localize/LocalizeCommon.h"
+#include "Localize/LocalizeCommonAssetLoader.h"
-#include "Localize/Parsing/LocalizeFileReader.h"
-
-#include <sstream>
 
 using namespace IW4;
 
@@ -25,29 +22,15 @@ bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
 bool AssetLoaderLocalizeEntry::LoadFromRaw(
     const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
 {
-    std::string fileName;
+    LocalizeCommonAssetLoader commonLoader(
-    {
+        [memory, manager](const CommonLocalizeEntry& entry)
-        std::ostringstream str;
-        str << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
-        fileName = str.str();
-    }
-
-    const auto file = searchPath->Open(fileName);
-    if (!file.IsOpen())
-        return false;
-
-    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<LocalizeReadingZoneState>();
-    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language, zoneState);
-    const auto localizeEntries = reader.ReadLocalizeFile();
-
-    for (const auto& [key, value] : localizeEntries)
         {
             auto* localizeEntry = memory->Create<LocalizeEntry>();
-        localizeEntry->name = memory->Dup(key.c_str());
+            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-        localizeEntry->value = memory->Dup(value.c_str());
+            localizeEntry->value = memory->Dup(entry.m_value.c_str());
 
-        manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, key, localizeEntry);
+            manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, entry.m_key, localizeEntry);
-    }
+        });
 
-    return true;
+    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
 }

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
 #include "Game/IW4/IW4.h"

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,9 +1,6 @@
 #include "AssetLoaderLocalizeEntry.h"
 
-#include "Localize/LocalizeCommon.h"
+#include "Localize/LocalizeCommonAssetLoader.h"
-#include "Localize/Parsing/LocalizeFileReader.h"
-
-#include <sstream>
 
 using namespace IW5;
 
@@ -25,29 +22,15 @@ bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
 bool AssetLoaderLocalizeEntry::LoadFromRaw(
     const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
 {
-    std::string fileName;
+    LocalizeCommonAssetLoader commonLoader(
-    {
+        [memory, manager](const CommonLocalizeEntry& entry)
-        std::ostringstream str;
-        str << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
-        fileName = str.str();
-    }
-
-    const auto file = searchPath->Open(fileName);
-    if (!file.IsOpen())
-        return false;
-
-    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<LocalizeReadingZoneState>();
-    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language, zoneState);
-    const auto localizeEntries = reader.ReadLocalizeFile();
-
-    for (const auto& [key, value] : localizeEntries)
         {
             auto* localizeEntry = memory->Create<LocalizeEntry>();
-        localizeEntry->name = memory->Dup(key.c_str());
+            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-        localizeEntry->value = memory->Dup(value.c_str());
+            localizeEntry->value = memory->Dup(entry.m_value.c_str());
 
-        manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, key, localizeEntry);
+            manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, entry.m_key, localizeEntry);
-    }
+        });
 
-    return true;
+    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
 }

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
 #include "Game/IW5/IW5.h"

src/ObjLoading/Game/T5/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,9 +1,6 @@
 #include "AssetLoaderLocalizeEntry.h"
 
-#include "Localize/LocalizeCommon.h"
+#include "Localize/LocalizeCommonAssetLoader.h"
-#include "Localize/Parsing/LocalizeFileReader.h"
-
-#include <sstream>
 
 using namespace T5;
 
@@ -25,29 +22,15 @@ bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
 bool AssetLoaderLocalizeEntry::LoadFromRaw(
     const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
 {
-    std::string fileName;
+    LocalizeCommonAssetLoader commonLoader(
-    {
+        [memory, manager](const CommonLocalizeEntry& entry)
-        std::ostringstream str;
-        str << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
-        fileName = str.str();
-    }
-
-    const auto file = searchPath->Open(fileName);
-    if (!file.IsOpen())
-        return false;
-
-    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<LocalizeReadingZoneState>();
-    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language, zoneState);
-    const auto localizeEntries = reader.ReadLocalizeFile();
-
-    for (const auto& [key, value] : localizeEntries)
         {
             auto* localizeEntry = memory->Create<LocalizeEntry>();
-        localizeEntry->name = memory->Dup(key.c_str());
+            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-        localizeEntry->value = memory->Dup(value.c_str());
+            localizeEntry->value = memory->Dup(entry.m_value.c_str());
 
-        manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, key, localizeEntry);
+            manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, entry.m_key, localizeEntry);
-    }
+        });
 
-    return true;
+    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
 }

src/ObjLoading/Game/T5/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
 #include "Game/T5/T5.h"

src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,9 +1,6 @@
 #include "AssetLoaderLocalizeEntry.h"
 
-#include "Localize/LocalizeCommon.h"
+#include "Localize/LocalizeCommonAssetLoader.h"
-#include "Localize/Parsing/LocalizeFileReader.h"
-
-#include <sstream>
 
 using namespace T6;
 
@@ -25,29 +22,15 @@ bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
 bool AssetLoaderLocalizeEntry::LoadFromRaw(
     const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
 {
-    std::string fileName;
+    LocalizeCommonAssetLoader commonLoader(
-    {
+        [memory, manager](const CommonLocalizeEntry& entry)
-        std::ostringstream str;
-        str << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
-        fileName = str.str();
-    }
-
-    const auto file = searchPath->Open(fileName);
-    if (!file.IsOpen())
-        return false;
-
-    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<LocalizeReadingZoneState>();
-    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language, zoneState);
-    const auto localizeEntries = reader.ReadLocalizeFile();
-
-    for (const auto& [key, value] : localizeEntries)
         {
             auto* localizeEntry = memory->Create<LocalizeEntry>();
-        localizeEntry->name = memory->Dup(key.c_str());
+            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-        localizeEntry->value = memory->Dup(value.c_str());
+            localizeEntry->value = memory->Dup(entry.m_value.c_str());
 
-        manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, key, localizeEntry);
+            manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, entry.m_key, localizeEntry);
-    }
+        });
 
-    return true;
+    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
 }

src/ObjLoading/Localize/LocalizeCommonAssetLoader.cpp

@@ -0,0 +1,42 @@
+#include "LocalizeCommonAssetLoader.h"
+
+#include "Localize/LocalizeCommon.h"
+#include "Localize/LocalizeReadingZoneState.h"
+#include "Localize/Parsing/LocalizeFileReader.h"
+
+#include <sstream>
+
+LocalizeCommonAssetLoader::LocalizeCommonAssetLoader(std::function<void(const CommonLocalizeEntry&)> entryCallback)
+    : m_entry_callback(std::move(entryCallback))
+{
+}
+
+std::string LocalizeCommonAssetLoader::GetFileName(const std::string& assetName, Zone* zone) const
+{
+    std::ostringstream ss;
+    ss << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
+    return ss.str();
+}
+
+bool LocalizeCommonAssetLoader::LoadLocalizeAsset(const std::string& assetName, ISearchPath* searchPath, IAssetLoadingManager* manager, Zone* zone) const
+{
+    std::string fileName = GetFileName(assetName, zone);
+
+    const auto file = searchPath->Open(fileName);
+    if (!file.IsOpen())
+        return false;
+
+    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<LocalizeReadingZoneState>();
+    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language, zoneState);
+
+    std::vector<CommonLocalizeEntry> localizeEntries;
+    if (!reader.ReadLocalizeFile(localizeEntries))
+        return false;
+
+    for (const auto& entry : localizeEntries)
+    {
+        m_entry_callback(entry);
+    }
+
+    return true;
+}

src/ObjLoading/Localize/LocalizeCommonAssetLoader.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "Localize/CommonLocalizeEntry.h"
+#include "SearchPath/ISearchPath.h"
+#include "Zone/Zone.h"
+
+#include <functional>
+#include <string>
+
+class LocalizeCommonAssetLoader
+{
+public:
+    explicit LocalizeCommonAssetLoader(std::function<void(const CommonLocalizeEntry&)> entryCallback);
+
+    bool LoadLocalizeAsset(const std::string& assetName, ISearchPath* searchPath, IAssetLoadingManager* manager, Zone* zone) const;
+
+private:
+    std::string GetFileName(const std::string& assetName, Zone* zone) const;
+
+    std::function<void(const CommonLocalizeEntry&)> m_entry_callback;
+};

src/ObjLoading/Localize/Parsing/LocalizeFileParser.cpp

@@ -32,7 +32,7 @@ const std::vector<AbstractParser<SimpleParserValue, LocalizeFileParserState>::se
     return !m_state->m_end ? tests : noTests;
 }
 
-std::map<std::string, std::string> LocalizeFileParser::GetParsedValues()
+std::vector<CommonLocalizeEntry> LocalizeFileParser::GetParsedValues()
 {
     return std::move(m_state->m_entries);
 }

src/ObjLoading/Localize/Parsing/LocalizeFileParser.h

@@ -13,5 +13,5 @@ protected:
 
 public:
     LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, LocalizeReadingZoneState* zoneState);
-    std::map<std::string, std::string> GetParsedValues();
+    std::vector<CommonLocalizeEntry> GetParsedValues();
 };

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.cpp

@@ -1,6 +1,7 @@
 #include "LocalizeFileParserState.h"
 
 #include "Localize/LocalizeCommon.h"
+#include "Utils/StringUtils.h"
 
 LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language, LocalizeReadingZoneState* zoneState)
     : m_end(false),
@@ -8,6 +9,5 @@ LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language, Lo
       m_zone_state(zoneState)
 {
     m_language_name_caps = LocalizeCommon::GetNameOfLanguage(m_language);
-    for (auto& c : m_language_name_caps)
+    utils::MakeStringUpperCase(m_language_name_caps);
-        c = static_cast<char>(toupper(c));
 }

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.h

@@ -1,17 +1,18 @@
 #pragma once
 
 #include "Game/GameLanguage.h"
+#include "Localize/CommonLocalizeEntry.h"
 #include "Localize/LocalizeReadingZoneState.h"
 
-#include <map>
 #include <unordered_set>
+#include <vector>
 
 class LocalizeFileParserState
 {
 public:
     bool m_end;
 
-    std::map<std::string, std::string> m_entries;
+    std::vector<CommonLocalizeEntry> m_entries;
 
     GameLanguage m_language;
     LocalizeReadingZoneState* m_zone_state;

src/ObjLoading/Localize/Parsing/LocalizeFileReader.cpp

@@ -28,7 +28,7 @@ void LocalizeFileReader::SetupStreamProxies()
     m_stream = m_open_streams.back().get();
 }
 
-std::map<std::string, std::string> LocalizeFileReader::ReadLocalizeFile()
+bool LocalizeFileReader::ReadLocalizeFile(std::vector<CommonLocalizeEntry>& entries)
 {
     SimpleLexer::Config lexerConfig;
     lexerConfig.m_emit_new_line_tokens = true;
@@ -41,8 +41,11 @@ std::map<std::string, std::string> LocalizeFileReader::ReadLocalizeFile()
     const auto parser = std::make_unique<LocalizeFileParser>(lexer.get(), m_language, m_zone_state);
 
     if (parser->Parse())
-        return parser->GetParsedValues();
+    {
+        entries = parser->GetParsedValues();
+        return true;
+    }
 
-    std::cout << "Parsing localization file failed!" << std::endl;
+    std::cerr << "Parsing localization file failed!" << std::endl;
-    return std::map<std::string, std::string>();
+    return false;
 }

src/ObjLoading/Localize/Parsing/LocalizeFileReader.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Game/GameLanguage.h"
+#include "Localize/CommonLocalizeEntry.h"
 #include "Localize/LocalizeReadingZoneState.h"
 #include "Parsing/IParserLineStream.h"
 
@@ -23,5 +24,5 @@ class LocalizeFileReader
 public:
     LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, LocalizeReadingZoneState* zoneState);
 
-    std::map<std::string, std::string> ReadLocalizeFile();
+    bool ReadLocalizeFile(std::vector<CommonLocalizeEntry>& entries);
 };

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileLanguageValue.cpp

@@ -38,6 +38,6 @@ void SequenceLocalizeFileLanguageValue::ProcessMatch(LocalizeFileParserState* st
             std::cout << "Localize: a value for reference \"" << currentReference << "\" was already defined\n";
         }
 
-        state->m_entries[currentReference] = valueToken.StringValue();
+        state->m_entries.emplace_back(currentReference, valueToken.StringValue());
     }
 }