chore: implement obj loading skeleton with localize asset

src/ObjLoading/Localize/Parsing/ILocalizeFileDuplicationChecker.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+class ILocalizeFileDuplicationChecker
+{
+public:
+    virtual ~ILocalizeFileDuplicationChecker() = default;
+
+    /**
+     * Checks whether a localize key was already added.
+     * Inserts key if it was not added yet.
+     *
+     * \param key The key to check
+     * \returns \c true if key was not duplicated yet, \c false otherwise
+     */
+    virtual bool CheckLocalizeEntryForDuplicates(const std::string& key) = 0;
+};

src/ObjLoading/Localize/Parsing/LocalizeFileParser.cpp

@@ -8,8 +8,8 @@
 #include "Sequence/SequenceLocalizeFileReference.h"
 #include "Sequence/SequenceLocalizeFileVersion.h"
 
-LocalizeFileParser::LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, LocalizeReadingZoneState* zoneState)
-    : AbstractParser(lexer, std::make_unique<LocalizeFileParserState>(language, zoneState))
+LocalizeFileParser::LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker)
+    : AbstractParser(lexer, std::make_unique<LocalizeFileParserState>(language, duplicationChecker))
 {
 }
 

src/ObjLoading/Localize/Parsing/LocalizeFileParser.h

@@ -12,6 +12,6 @@ protected:
     const std::vector<sequence_t*>& GetTestsForState() override;
 
 public:
-    LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, LocalizeReadingZoneState* zoneState);
+    LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker);
     std::vector<CommonLocalizeEntry> GetParsedValues();
 };

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.cpp

@@ -3,10 +3,10 @@
 #include "Localize/LocalizeCommon.h"
 #include "Utils/StringUtils.h"
 
-LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language, LocalizeReadingZoneState* zoneState)
+LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker)
     : m_end(false),
       m_language(language),
-      m_zone_state(zoneState)
+      m_duplication_checker(duplicationChecker)
 {
     m_language_name_caps = LocalizeCommon::GetNameOfLanguage(m_language);
     utils::MakeStringUpperCase(m_language_name_caps);

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "Game/GameLanguage.h"
+#include "ILocalizeFileDuplicationChecker.h"
 #include "Localize/CommonLocalizeEntry.h"
-#include "Localize/LocalizeReadingZoneState.h"
 
 #include <unordered_set>
 #include <vector>
@@ -10,16 +10,16 @@
 class LocalizeFileParserState
 {
 public:
+    LocalizeFileParserState(GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker);
+
     bool m_end;
 
     std::vector<CommonLocalizeEntry> m_entries;
 
     GameLanguage m_language;
-    LocalizeReadingZoneState* m_zone_state;
+    ILocalizeFileDuplicationChecker& m_duplication_checker;
     std::string m_language_name_caps;
 
     std::string m_current_reference;
     std::unordered_set<std::string> m_current_reference_languages;
-
-    LocalizeFileParserState(GameLanguage language, LocalizeReadingZoneState* zoneState);
 };

src/ObjLoading/Localize/Parsing/LocalizeFileReader.cpp

@@ -4,11 +4,11 @@
 #include "Parsing/Impl/CommentRemovingStreamProxy.h"
 #include "Parsing/Impl/ParserSingleInputStream.h"
 
-LocalizeFileReader::LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, LocalizeReadingZoneState* zoneState)
+LocalizeFileReader::LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker)
     : m_file_name(std::move(fileName)),
       m_stream(nullptr),
       m_language(language),
-      m_zone_state(zoneState)
+      m_duplication_checker(duplicationChecker)
 {
     OpenBaseStream(stream);
     SetupStreamProxies();
@@ -38,7 +38,7 @@ bool LocalizeFileReader::ReadLocalizeFile(std::vector<CommonLocalizeEntry>& entr
     lexerConfig.m_read_floating_point_numbers = false;
     const auto lexer = std::make_unique<SimpleLexer>(m_stream, std::move(lexerConfig));
 
-    const auto parser = std::make_unique<LocalizeFileParser>(lexer.get(), m_language, m_zone_state);
+    const auto parser = std::make_unique<LocalizeFileParser>(lexer.get(), m_language, m_duplication_checker);
 
     if (parser->Parse())
     {

src/ObjLoading/Localize/Parsing/LocalizeFileReader.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "Game/GameLanguage.h"
+#include "ILocalizeFileDuplicationChecker.h"
 #include "Localize/CommonLocalizeEntry.h"
-#include "Localize/LocalizeReadingZoneState.h"
 #include "Parsing/IParserLineStream.h"
 
 #include <map>
@@ -16,13 +16,13 @@ class LocalizeFileReader
     IParserLineStream* m_stream;
     std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
     GameLanguage m_language;
-    LocalizeReadingZoneState* m_zone_state;
+    ILocalizeFileDuplicationChecker& m_duplication_checker;
 
     bool OpenBaseStream(std::istream& stream);
     void SetupStreamProxies();
 
 public:
-    LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, LocalizeReadingZoneState* zoneState);
+    LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker);
 
     bool ReadLocalizeFile(std::vector<CommonLocalizeEntry>& entries);
 };

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

@@ -33,7 +33,7 @@ void SequenceLocalizeFileLanguageValue::ProcessMatch(LocalizeFileParserState* st
     if (langName == state->m_language_name_caps)
     {
         const auto& currentReference = state->m_current_reference;
-        if (!state->m_zone_state->DoLocalizeEntryDuplicateCheck(currentReference))
+        if (!state->m_duplication_checker.CheckLocalizeEntryForDuplicates(currentReference))
         {
             std::cout << "Localize: a value for reference \"" << currentReference << "\" was already defined\n";
         }