Bundle all property sequences for menus, items and functions together in one file

src/ObjLoading/Parsing/Menu/MenuFileParser.cpp

@@ -6,8 +6,9 @@
 #include "Sequence/SequenceLoadMenu.h"
 #include "Sequence/SequenceMenuDef.h"
 #include "Sequence/SequenceOpenGlobalScopeBlock.h"
-#include "Sequence/Properties/SequenceFullScreen.h"
+#include "Sequence/Properties/FunctionPropertySequences.h"
-#include "Sequence/Properties/SequenceName.h"
+#include "Sequence/Properties/ItemPropertySequences.h"
+#include "Sequence/Properties/MenuPropertySequences.h"
 
 using namespace menu;
 
@@ -17,7 +18,7 @@ MenuFileParser::MenuFileParser(SimpleLexer* lexer, const FeatureLevel featureLev
     CreateTestCollections();
 }
 
-void MenuFileParser::AddTest(std::vector<sequence_t*>& collection, std::unique_ptr<sequence_t> test)
+void MenuFileParser::AddSequence(std::vector<sequence_t*>& collection, std::unique_ptr<sequence_t> test)
 {
     collection.push_back(test.get());
     m_all_tests.emplace_back(std::move(test));
@@ -25,36 +26,40 @@ void MenuFileParser::AddTest(std::vector<sequence_t*>& collection, std::unique_p
 
 void MenuFileParser::CreateNoScopeTests()
 {
-    AddTest(m_no_scope_tests, std::make_unique<SequenceOpenGlobalScopeBlock>());
+    AddSequence(m_no_scope_tests, std::make_unique<SequenceOpenGlobalScopeBlock>());
 }
 
 void MenuFileParser::CreateGlobalScopeTests()
 {
-    AddTest(m_global_scope_tests, std::make_unique<SequenceCloseBlock>());
+    AddSequence(m_global_scope_tests, std::make_unique<SequenceCloseBlock>());
-    AddTest(m_global_scope_tests, std::make_unique<SequenceMenuDef>());
+    AddSequence(m_global_scope_tests, std::make_unique<SequenceMenuDef>());
-    AddTest(m_global_scope_tests, std::make_unique<SequenceFunctionDef>());
+    AddSequence(m_global_scope_tests, std::make_unique<SequenceFunctionDef>());
-    AddTest(m_global_scope_tests, std::make_unique<SequenceLoadMenu>());
+    AddSequence(m_global_scope_tests, std::make_unique<SequenceLoadMenu>());
 }
 
 void MenuFileParser::CreateFunctionScopeTests()
 {
-    AddTest(m_function_scope_tests, std::make_unique<SequenceName>());
+    AddSequence(m_function_scope_tests, std::make_unique<SequenceCloseBlock>());
-    AddTest(m_function_scope_tests, std::make_unique<SequenceCloseBlock>());
+
+    FunctionPropertySequences functionPropertySequences(m_all_tests, m_function_scope_tests);
+    functionPropertySequences.AddSequences(m_state->m_feature_level);
 }
 
 void MenuFileParser::CreateMenuScopeTests()
 {
-    AddTest(m_menu_scope_tests, std::make_unique<SequenceCloseBlock>());
+    AddSequence(m_menu_scope_tests, std::make_unique<SequenceCloseBlock>());
-    AddTest(m_menu_scope_tests, std::make_unique<SequenceName>());
+    AddSequence(m_menu_scope_tests, std::make_unique<SequenceItemDef>());
-    AddTest(m_menu_scope_tests, std::make_unique<SequenceFullScreen>());
 
-    AddTest(m_menu_scope_tests, std::make_unique<SequenceItemDef>());
+    MenuPropertySequences menuPropertySequences(m_all_tests, m_menu_scope_tests);
+    menuPropertySequences.AddSequences(m_state->m_feature_level);
 }
 
 void MenuFileParser::CreateItemScopeTests()
 {
-    AddTest(m_item_scope_tests, std::make_unique<SequenceName>());
+    AddSequence(m_item_scope_tests, std::make_unique<SequenceCloseBlock>());
-    AddTest(m_item_scope_tests, std::make_unique<SequenceCloseBlock>());
+
+    ItemPropertySequences itemPropertySequences(m_all_tests, m_item_scope_tests);
+    itemPropertySequences.AddSequences(m_state->m_feature_level);
 }
 
 void MenuFileParser::CreateTestCollections()

src/ObjLoading/Parsing/Menu/MenuFileParser.h

@@ -17,7 +17,7 @@ namespace menu
         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 AddSequence(std::vector<sequence_t*>& collection, std::unique_ptr<sequence_t> test);
         void CreateNoScopeTests();
         void CreateGlobalScopeTests();
         void CreateFunctionScopeTests();

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

@@ -0,0 +1,15 @@
+#include "AbstractPropertySequenceHolder.h"
+
+using namespace menu;
+
+AbstractPropertySequenceHolder::AbstractPropertySequenceHolder(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : m_all_sequences(allSequences),
+      m_scope_sequences(scopeSequences)
+{
+}
+
+void AbstractPropertySequenceHolder::AddSequence(std::unique_ptr<MenuFileParser::sequence_t> test) const
+{
+    m_scope_sequences.push_back(test.get());
+    m_all_sequences.emplace_back(std::move(test));
+}

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "Parsing/Menu/MenuFileParser.h"
+
+namespace menu
+{
+    class AbstractPropertySequenceHolder
+    {
+        std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& m_all_sequences;
+        std::vector<MenuFileParser::sequence_t*>& m_scope_sequences;
+
+    protected:
+        AbstractPropertySequenceHolder(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences);
+
+        void AddSequence(std::unique_ptr<MenuFileParser::sequence_t> test) const;
+
+    public:
+        virtual ~AbstractPropertySequenceHolder() = default;
+        AbstractPropertySequenceHolder(const AbstractPropertySequenceHolder& other) = delete;
+        AbstractPropertySequenceHolder(AbstractPropertySequenceHolder&& other) noexcept = default;
+        AbstractPropertySequenceHolder& operator=(const AbstractPropertySequenceHolder& other) = delete;
+        AbstractPropertySequenceHolder& operator=(AbstractPropertySequenceHolder&& other) noexcept = default;
+
+        virtual void AddSequences(FeatureLevel featureLevel) = 0;
+    };
+}

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

@@ -0,0 +1,45 @@
+#include "FunctionPropertySequences.h"
+
+#include "Parsing/Menu/MenuMatcherFactory.h"
+
+using namespace menu;
+
+namespace menu::function_properties
+{
+    class SequenceName final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_NAME = 1;
+
+    public:
+        SequenceName()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.KeywordIgnoreCase("name"),
+                create.Text().Capture(CAPTURE_NAME)
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            assert(state->m_current_function);
+
+            const auto nameValue = MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_NAME));
+            state->m_current_function->m_name = nameValue;
+        }
+    };
+}
+
+using namespace function_properties;
+
+FunctionPropertySequences::FunctionPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : AbstractPropertySequenceHolder(allSequences, scopeSequences)
+{
+}
+
+void FunctionPropertySequences::AddSequences(FeatureLevel featureLevel)
+{
+    AddSequence(std::make_unique<SequenceName>());
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractPropertySequenceHolder.h"
+
+namespace menu
+{
+    class FunctionPropertySequences final : AbstractPropertySequenceHolder
+    {
+    public:
+        FunctionPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences);
+
+        void AddSequences(FeatureLevel featureLevel) override;
+    };
+}

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

@@ -0,0 +1,45 @@
+#include "ItemPropertySequences.h"
+
+#include "Parsing/Menu/MenuMatcherFactory.h"
+
+using namespace menu;
+
+namespace menu::item_properties
+{
+    class SequenceName final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_NAME = 1;
+
+    public:
+        SequenceName()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.KeywordIgnoreCase("name"),
+                create.Text().Capture(CAPTURE_NAME)
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            assert(state->m_current_item);
+
+            const auto nameValue = MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_NAME));
+            state->m_current_item->m_name = nameValue;
+        }
+    };
+}
+
+using namespace item_properties;
+
+ItemPropertySequences::ItemPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : AbstractPropertySequenceHolder(allSequences, scopeSequences)
+{
+}
+
+void ItemPropertySequences::AddSequences(FeatureLevel featureLevel)
+{
+    AddSequence(std::make_unique<SequenceName>());
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractPropertySequenceHolder.h"
+
+namespace menu
+{
+    class ItemPropertySequences final : AbstractPropertySequenceHolder
+    {
+    public:
+        ItemPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences);
+
+        void AddSequences(FeatureLevel featureLevel) override;
+    };
+}

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

@@ -0,0 +1,71 @@
+#include "MenuPropertySequences.h"
+
+#include "Parsing/Menu/MenuMatcherFactory.h"
+
+using namespace menu;
+
+namespace menu::menu_properties
+{
+    class SequenceName final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_NAME = 1;
+
+    public:
+        SequenceName()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.KeywordIgnoreCase("name"),
+                create.Text().Capture(CAPTURE_NAME)
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            assert(state->m_current_menu);
+
+            const auto nameValue = MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_NAME));
+            state->m_current_menu->m_name = nameValue;
+        }
+    };
+
+    class SequenceFullScreen final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_VALUE = 1;
+
+    public:
+        SequenceFullScreen()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.KeywordIgnoreCase("fullscreen"),
+                create.Numeric().Capture(CAPTURE_VALUE)
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            assert(state->m_current_menu);
+
+            const auto value = MenuMatcherFactory::TokenNumericIntValue(result.NextCapture(CAPTURE_VALUE));
+            state->m_current_menu->m_fullscreen = value > 0;
+        }
+    };
+}
+
+using namespace menu_properties;
+
+MenuPropertySequences::MenuPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : AbstractPropertySequenceHolder(allSequences, scopeSequences)
+{
+}
+
+void MenuPropertySequences::AddSequences(FeatureLevel featureLevel)
+{
+    AddSequence(std::make_unique<SequenceName>());
+    AddSequence(std::make_unique<SequenceFullScreen>());
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractPropertySequenceHolder.h"
+
+namespace menu
+{
+    class MenuPropertySequences final : AbstractPropertySequenceHolder
+    {
+    public:
+        MenuPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences);
+
+        void AddSequences(FeatureLevel featureLevel) override;
+    };
+}

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

@@ -1,24 +0,0 @@
-#include "SequenceFullScreen.h"
-
-#include "Parsing/Menu/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceFullScreen::SequenceFullScreen()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.KeywordIgnoreCase("fullscreen"),
-        create.Numeric().Capture(CAPTURE_VALUE)
-    });
-}
-
-void SequenceFullScreen::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(state->m_current_menu);
-    
-    const auto nameValue = MenuMatcherFactory::TokenNumericIntValue(result.NextCapture(CAPTURE_VALUE));
-
-    state->m_current_menu->m_fullscreen = nameValue > 0;
-}

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

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

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

@@ -1,29 +0,0 @@
-#include "SequenceName.h"
-
-#include "Parsing/Menu/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceName::SequenceName()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.KeywordIgnoreCase("name"),
-        create.Text().Capture(CAPTURE_NAME)
-    });
-}
-
-void SequenceName::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(state->m_current_item || state->m_current_menu || state->m_current_function);
-    
-    const auto nameValue = MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_NAME));
-
-    if (state->m_current_item)
-        state->m_current_item->m_name = nameValue;
-    else if (state->m_current_menu)
-        state->m_current_menu->m_name = nameValue;
-    else if (state->m_current_function)
-        state->m_current_function->m_name = nameValue;
-}

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

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