Move menu parsing classes to menu namespace

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

@@ -28,7 +28,7 @@ bool AssetLoaderMenuList::LoadFromRaw(const std::string& assetName, ISearchPath*
     if (!file.IsOpen())
         return false;
 
-    MenuFileReader reader(*file.m_stream, assetName, MenuFeatureLevel::IW4, [searchPath](const std::string& filename, const std::string& sourceFile) -> std::unique_ptr<std::istream>
+    menu::MenuFileReader reader(*file.m_stream, assetName, menu::FeatureLevel::IW4, [searchPath](const std::string& filename, const std::string& sourceFile) -> std::unique_ptr<std::istream>
     {
         auto foundFileToInclude = searchPath->Open(filename);
         if (!foundFileToInclude.IsOpen() || !foundFileToInclude.m_stream)

src/ObjLoading/Parsing/Menu/Domain/CommonFunctionDef.h

@@ -2,8 +2,11 @@
 
 #include <string>
 
-class CommonFunctionDef
+namespace menu
 {
-public:
+    class CommonFunctionDef
-    std::string m_name;
+    {
-};
+    public:
+        std::string m_name;
+    };
+}

src/ObjLoading/Parsing/Menu/Domain/CommonItemDef.h

@@ -2,8 +2,11 @@
 
 #include <string>
 
-class CommonItemDef
+namespace menu
 {
-public:
+    class CommonItemDef
-    std::string m_name;
+    {
-};
+    public:
+        std::string m_name;
+    };
+}

src/ObjLoading/Parsing/Menu/Domain/CommonMenuDef.h

@@ -5,9 +5,12 @@
 
 #include "CommonItemDef.h"
 
-class CommonMenuDef
+namespace menu
 {
-public:
+    class CommonMenuDef
-    std::string m_name;
+    {
-    std::vector<std::unique_ptr<CommonItemDef>> m_items;
+    public:
-};
+        std::string m_name;
+        std::vector<std::unique_ptr<CommonItemDef>> m_items;
+    };
+}

src/ObjLoading/Parsing/Menu/Domain/MenuFeatureLevel.h

@@ -1,7 +1,10 @@
 #pragma once
 
-enum class MenuFeatureLevel
+namespace menu
 {
-    IW4,
+    enum class FeatureLevel
-    IW5
+    {
-};
+        IW4,
+        IW5
+    };
+}

src/ObjLoading/Parsing/Menu/Domain/MenuParsingResult.h

@@ -6,10 +6,13 @@
 #include "CommonFunctionDef.h"
 #include "CommonMenuDef.h"
 
-class MenuParsingResult
+namespace menu
 {
-public:
+    class ParsingResult
-    std::vector<std::unique_ptr<CommonMenuDef>> m_menus;
+    {
-    std::vector<std::unique_ptr<CommonFunctionDef>> m_functions;
+    public:
-    std::vector<std::string> m_menus_to_load;
+        std::vector<std::unique_ptr<CommonMenuDef>> m_menus;
-};
+        std::vector<std::unique_ptr<CommonFunctionDef>> m_functions;
+        std::vector<std::string> m_menus_to_load;
+    };
+}

src/ObjLoading/Parsing/Menu/MenuFileParser.cpp

@@ -8,7 +8,9 @@
 #include "Sequence/SequenceOpenGlobalScopeBlock.h"
 #include "Sequence/Properties/SequenceName.h"
 
-MenuFileParser::MenuFileParser(SimpleLexer* lexer, const MenuFeatureLevel featureLevel)
+using namespace menu;
+
+MenuFileParser::MenuFileParser(SimpleLexer* lexer, const FeatureLevel featureLevel)
     : AbstractParser(lexer, std::make_unique<MenuFileParserState>(featureLevel))
 {
     CreateTestCollections();

src/ObjLoading/Parsing/Menu/MenuFileParser.h

@@ -6,27 +6,30 @@
 #include "Parsing/Simple/SimpleParserValue.h"
 #include "Parsing/Impl/AbstractParser.h"
 
-class MenuFileParser final : public AbstractParser<SimpleParserValue, MenuFileParserState>
+namespace menu
 {
-    std::vector<std::unique_ptr<sequence_t>> m_all_tests;
+    class MenuFileParser final : public AbstractParser<SimpleParserValue, MenuFileParserState>
-    std::vector<sequence_t*> m_no_scope_tests;
+    {
-    std::vector<sequence_t*> m_global_scope_tests;
+        std::vector<std::unique_ptr<sequence_t>> m_all_tests;
-    std::vector<sequence_t*> m_function_scope_tests;
+        std::vector<sequence_t*> m_no_scope_tests;
-    std::vector<sequence_t*> m_menu_scope_tests;
+        std::vector<sequence_t*> m_global_scope_tests;
-    std::vector<sequence_t*> m_item_scope_tests;
+        std::vector<sequence_t*> m_function_scope_tests;
+        std::vector<sequence_t*> m_menu_scope_tests;
+        std::vector<sequence_t*> m_item_scope_tests;
 
-    void AddTest(std::vector<sequence_t*>& collection, std::unique_ptr<sequence_t> test);
+        void AddTest(std::vector<sequence_t*>& collection, std::unique_ptr<sequence_t> test);
-    void CreateNoScopeTests();
+        void CreateNoScopeTests();
-    void CreateGlobalScopeTests();
+        void CreateGlobalScopeTests();
-    void CreateFunctionScopeTests();
+        void CreateFunctionScopeTests();
-    void CreateMenuScopeTests();
+        void CreateMenuScopeTests();
-    void CreateItemScopeTests();
+        void CreateItemScopeTests();
-    void CreateTestCollections();
+        void CreateTestCollections();
 
-protected:
+    protected:
-    const std::vector<sequence_t*>& GetTestsForState() override;
+        const std::vector<sequence_t*>& GetTestsForState() override;
 
-public:
+    public:
-    MenuFileParser(SimpleLexer* lexer, MenuFeatureLevel featureLevel);
+        MenuFileParser(SimpleLexer* lexer, FeatureLevel featureLevel);
-    _NODISCARD MenuFileParserState* GetState() const;
+        _NODISCARD MenuFileParserState* GetState() const;
-};
+    };
+}

src/ObjLoading/Parsing/Menu/MenuFileParserState.cpp

@@ -1,6 +1,8 @@
 #include "MenuFileParserState.h"
 
-MenuFileParserState::MenuFileParserState(const MenuFeatureLevel featureLevel)
+using namespace menu;
+
+MenuFileParserState::MenuFileParserState(const FeatureLevel featureLevel)
     : m_feature_level(featureLevel),
       m_in_global_scope(false)
 {

src/ObjLoading/Parsing/Menu/MenuFileParserState.h

@@ -8,22 +8,25 @@
 #include "Domain/CommonMenuDef.h"
 #include "Domain/MenuFeatureLevel.h"
 
-class MenuFileParserState
+namespace menu
 {
-public:
+    class MenuFileParserState
-    const MenuFeatureLevel m_feature_level;
+    {
+    public:
+        const FeatureLevel m_feature_level;
 
-    std::vector<std::string> m_menus_to_load;
+        std::vector<std::string> m_menus_to_load;
-    std::vector<std::unique_ptr<CommonFunctionDef>> m_functions;
+        std::vector<std::unique_ptr<CommonFunctionDef>> m_functions;
-    std::vector<std::unique_ptr<CommonMenuDef>> m_menus;
+        std::vector<std::unique_ptr<CommonMenuDef>> m_menus;
 
-    std::map<std::string, CommonFunctionDef*> m_functions_by_name;
+        std::map<std::string, CommonFunctionDef*> m_functions_by_name;
-    std::map<std::string, CommonMenuDef*> m_menus_by_name;
+        std::map<std::string, CommonMenuDef*> m_menus_by_name;
 
-    bool m_in_global_scope;
+        bool m_in_global_scope;
-    std::unique_ptr<CommonFunctionDef> m_current_function;
+        std::unique_ptr<CommonFunctionDef> m_current_function;
-    std::unique_ptr<CommonMenuDef> m_current_menu;
+        std::unique_ptr<CommonMenuDef> m_current_menu;
-    std::unique_ptr<CommonItemDef> m_current_item;
+        std::unique_ptr<CommonItemDef> m_current_item;
 
-    explicit MenuFileParserState(MenuFeatureLevel featureLevel);
+        explicit MenuFileParserState(FeatureLevel featureLevel);
-};
+    };
+}

src/ObjLoading/Parsing/Menu/MenuFileReader.cpp

@@ -8,7 +8,9 @@
 #include "Parsing/Impl/ParserSingleInputStream.h"
 #include "Parsing/Simple/SimpleLexer.h"
 
-MenuFileReader::MenuFileReader(std::istream& stream, std::string fileName, const MenuFeatureLevel featureLevel, include_callback_t includeCallback)
+using namespace menu;
+
+MenuFileReader::MenuFileReader(std::istream& stream, std::string fileName, const FeatureLevel featureLevel, include_callback_t includeCallback)
     : m_feature_level(featureLevel),
       m_file_name(std::move(fileName)),
       m_stream(nullptr)
@@ -18,7 +20,7 @@ MenuFileReader::MenuFileReader(std::istream& stream, std::string fileName, const
     m_stream = m_open_streams.back().get();
 }
 
-MenuFileReader::MenuFileReader(std::istream& stream, std::string fileName, const MenuFeatureLevel featureLevel)
+MenuFileReader::MenuFileReader(std::istream& stream, std::string fileName, const FeatureLevel featureLevel)
     : m_feature_level(featureLevel),
       m_file_name(std::move(fileName)),
       m_stream(nullptr)
@@ -45,10 +47,10 @@ void MenuFileReader::SetupDefinesProxy()
     defines->AddDefine(DefinesStreamProxy::Define("PC", "1"));
     switch(m_feature_level)
     {
-    case MenuFeatureLevel::IW4:
+    case FeatureLevel::IW4:
         defines->AddDefine(DefinesStreamProxy::Define("FEATURE_LEVEL_IW4", "1"));
         break;
-    case MenuFeatureLevel::IW5:
+    case FeatureLevel::IW5:
         defines->AddDefine(DefinesStreamProxy::Define("FEATURE_LEVEL_IW5", "1"));
         break;
     default:
@@ -97,9 +99,9 @@ bool MenuFileReader::IsValidEndState(const MenuFileParserState* state) const
     return true;
 }
 
-std::unique_ptr<MenuParsingResult> MenuFileReader::CreateParsingResult(MenuFileParserState* state) const
+std::unique_ptr<ParsingResult> MenuFileReader::CreateParsingResult(MenuFileParserState* state) const
 {
-    auto result = std::make_unique<MenuParsingResult>();
+    auto result = std::make_unique<ParsingResult>();
     result->m_menus = std::move(state->m_menus);
     result->m_functions = std::move(state->m_functions);
     result->m_menus_to_load = std::move(state->m_menus_to_load);
@@ -107,9 +109,9 @@ std::unique_ptr<MenuParsingResult> MenuFileReader::CreateParsingResult(MenuFileP
     return result;
 }
 
-std::unique_ptr<MenuParsingResult> MenuFileReader::ReadMenuFile()
+std::unique_ptr<ParsingResult> MenuFileReader::ReadMenuFile()
 {
-    const auto lexer = std::make_unique<SimpleLexer>(m_stream, SimpleLexer::Config{false, true, false});
+    const auto lexer = std::make_unique<SimpleLexer>(m_stream, SimpleLexer::Config{false, true, true});
     const auto parser = std::make_unique<MenuFileParser>(lexer.get(), m_feature_level);
 
     if (!parser->Parse())

src/ObjLoading/Parsing/Menu/MenuFileReader.h

@@ -9,28 +9,31 @@
 #include "Domain/MenuParsingResult.h"
 #include "Parsing/IParserLineStream.h"
 
-class MenuFileReader
+namespace menu
 {
-public:
+    class MenuFileReader
-    using include_callback_t = std::function<std::unique_ptr<std::istream>(const std::string& filename, const std::string& sourceFile)>;
+    {
-    
+    public:
-private:
+        using include_callback_t = std::function<std::unique_ptr<std::istream>(const std::string& filename, const std::string& sourceFile)>;
-    const MenuFeatureLevel m_feature_level;
-    const std::string m_file_name;
 
-    IParserLineStream* m_stream;
+    private:
-    std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
+        const FeatureLevel m_feature_level;
+        const std::string m_file_name;
 
-    bool OpenBaseStream(std::istream& stream, include_callback_t includeCallback);
+        IParserLineStream* m_stream;
-    void SetupDefinesProxy();
+        std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
-    void SetupStreamProxies();
 
-    bool IsValidEndState(const MenuFileParserState* state) const;
+        bool OpenBaseStream(std::istream& stream, include_callback_t includeCallback);
-    std::unique_ptr<MenuParsingResult> CreateParsingResult(MenuFileParserState* state) const;
+        void SetupDefinesProxy();
+        void SetupStreamProxies();
 
-public:
+        bool IsValidEndState(const MenuFileParserState* state) const;
-    MenuFileReader(std::istream& stream, std::string fileName, MenuFeatureLevel featureLevel);
+        std::unique_ptr<ParsingResult> CreateParsingResult(MenuFileParserState* state) const;
-    MenuFileReader(std::istream& stream, std::string fileName, MenuFeatureLevel featureLevel, include_callback_t includeCallback);
 
-    std::unique_ptr<MenuParsingResult> ReadMenuFile();
+    public:
-};
+        MenuFileReader(std::istream& stream, std::string fileName, FeatureLevel featureLevel);
+        MenuFileReader(std::istream& stream, std::string fileName, FeatureLevel featureLevel, include_callback_t includeCallback);
+
+        std::unique_ptr<ParsingResult> ReadMenuFile();
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/Properties/SequenceName.cpp

@@ -2,6 +2,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceName::SequenceName()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/Properties/SequenceName.h

@@ -2,13 +2,16 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceName final : public MenuFileParser::sequence_t
+namespace menu
 {
-    static constexpr auto CAPTURE_NAME = 1;
+    class SequenceName final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_NAME = 1;
 
-protected:
+    protected:
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceName();
+        SequenceName();
-};
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/SequenceCloseBlock.cpp

@@ -4,6 +4,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceCloseBlock::SequenceCloseBlock()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/SequenceCloseBlock.h

@@ -2,13 +2,16 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceCloseBlock final : public MenuFileParser::sequence_t
+namespace menu
 {
-    static constexpr auto CAPTURE_TOKEN = 1;
+    class SequenceCloseBlock final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_TOKEN = 1;
 
-protected:
+    protected:
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceCloseBlock();
+        SequenceCloseBlock();
-};
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/SequenceFunctionDef.cpp

@@ -2,6 +2,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceFunctionDef::SequenceFunctionDef()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/SequenceFunctionDef.h

@@ -2,11 +2,14 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceFunctionDef final : public MenuFileParser::sequence_t
+namespace menu
 {
-protected:
+    class SequenceFunctionDef final : public MenuFileParser::sequence_t
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+    {
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceFunctionDef();
+        SequenceFunctionDef();
-};
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/SequenceItemDef.cpp

@@ -2,6 +2,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceItemDef::SequenceItemDef()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/SequenceItemDef.h

@@ -2,11 +2,14 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceItemDef final : public MenuFileParser::sequence_t
+namespace menu
 {
-protected:
+    class SequenceItemDef final : public MenuFileParser::sequence_t
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+    {
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceItemDef();
+        SequenceItemDef();
-};
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/SequenceLoadMenu.cpp

@@ -2,6 +2,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceLoadMenu::SequenceLoadMenu()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/SequenceLoadMenu.h

@@ -2,13 +2,16 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceLoadMenu final : public MenuFileParser::sequence_t
+namespace menu
 {
-    static constexpr auto CAPTURE_MENU_NAME = 1;
+    class SequenceLoadMenu final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_MENU_NAME = 1;
 
-protected:
+    protected:
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceLoadMenu();
+        SequenceLoadMenu();
-};
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/SequenceMenuDef.cpp

@@ -2,6 +2,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceMenuDef::SequenceMenuDef()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/SequenceMenuDef.h

@@ -2,11 +2,14 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceMenuDef final : public MenuFileParser::sequence_t
+namespace menu
 {
-protected:
+    class SequenceMenuDef final : public MenuFileParser::sequence_t
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+    {
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceMenuDef();
+        SequenceMenuDef();
-};
+    };
+}

src/ObjLoading/Parsing/Menu/Sequence/SequenceOpenGlobalScopeBlock.cpp

@@ -2,6 +2,8 @@
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
+using namespace menu;
+
 SequenceOpenGlobalScopeBlock::SequenceOpenGlobalScopeBlock()
 {
     const SimpleMatcherFactory create(this);

src/ObjLoading/Parsing/Menu/Sequence/SequenceOpenGlobalScopeBlock.h

@@ -2,11 +2,14 @@
 
 #include "Parsing/Menu/MenuFileParser.h"
 
-class SequenceOpenGlobalScopeBlock final : public MenuFileParser::sequence_t
+namespace menu
 {
-protected:
+    class SequenceOpenGlobalScopeBlock final : public MenuFileParser::sequence_t
-    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+    {
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
 
-public:
+    public:
-    SequenceOpenGlobalScopeBlock();
+        SequenceOpenGlobalScopeBlock();
-};
+    };
+}