Move item parsing sequences for different scopes into the same class

src/ObjLoading/Parsing/Menu/MenuFileParser.cpp

@@ -1,14 +1,10 @@
 #include "MenuFileParser.h"
 
-#include "Sequence/SequenceCloseBlock.h"
+#include "Sequence/FunctionScopeSequences.h"
-#include "Sequence/SequenceFunctionDef.h"
+#include "Sequence/GlobalScopeSequences.h"
-#include "Sequence/SequenceItemDef.h"
+#include "Sequence/ItemScopeSequences.h"
-#include "Sequence/SequenceLoadMenu.h"
+#include "Sequence/MenuScopeSequences.h"
-#include "Sequence/SequenceMenuDef.h"
+#include "Sequence/NoScopeSequences.h"
-#include "Sequence/SequenceOpenGlobalScopeBlock.h"
-#include "Sequence/Properties/FunctionPropertySequences.h"
-#include "Sequence/Properties/ItemPropertySequences.h"
-#include "Sequence/Properties/MenuPropertySequences.h"
 
 using namespace menu;
 
@@ -26,39 +22,31 @@ void MenuFileParser::AddSequence(std::vector<sequence_t*>& collection, std::uniq
 
 void MenuFileParser::CreateNoScopeTests()
 {
-    AddSequence(m_no_scope_tests, std::make_unique<SequenceOpenGlobalScopeBlock>());
+    NoScopeSequences noScopeSequences(m_all_tests, m_no_scope_tests);
+    noScopeSequences.AddSequences(m_state->m_feature_level);
 }
 
 void MenuFileParser::CreateGlobalScopeTests()
 {
-    AddSequence(m_global_scope_tests, std::make_unique<SequenceCloseBlock>());
+    GlobalScopeSequences globalScopeSequences(m_all_tests, m_global_scope_tests);
-    AddSequence(m_global_scope_tests, std::make_unique<SequenceMenuDef>());
+    globalScopeSequences.AddSequences(m_state->m_feature_level);
-    AddSequence(m_global_scope_tests, std::make_unique<SequenceFunctionDef>());
-    AddSequence(m_global_scope_tests, std::make_unique<SequenceLoadMenu>());
 }
 
 void MenuFileParser::CreateFunctionScopeTests()
 {
-    AddSequence(m_function_scope_tests, std::make_unique<SequenceCloseBlock>());
+    FunctionScopeSequences functionPropertySequences(m_all_tests, m_function_scope_tests);
-
-    FunctionPropertySequences functionPropertySequences(m_all_tests, m_function_scope_tests);
     functionPropertySequences.AddSequences(m_state->m_feature_level);
 }
 
 void MenuFileParser::CreateMenuScopeTests()
 {
-    AddSequence(m_menu_scope_tests, std::make_unique<SequenceCloseBlock>());
+    MenuScopeSequences menuPropertySequences(m_all_tests, m_menu_scope_tests);
-    AddSequence(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()
 {
-    AddSequence(m_item_scope_tests, std::make_unique<SequenceCloseBlock>());
+    ItemScopeSequences itemPropertySequences(m_all_tests, m_item_scope_tests);
-
-    ItemPropertySequences itemPropertySequences(m_all_tests, m_item_scope_tests);
     itemPropertySequences.AddSequences(m_state->m_feature_level);
 }
 
@@ -80,9 +68,6 @@ void MenuFileParser::CreateTestCollections()
 
 const std::vector<MenuFileParser::sequence_t*>& MenuFileParser::GetTestsForState()
 {
-    if (!m_state->m_in_global_scope)
-        return m_no_scope_tests;
-
     if (m_state->m_current_item)
         return m_item_scope_tests;
 
@@ -92,7 +77,10 @@ const std::vector<MenuFileParser::sequence_t*>& MenuFileParser::GetTestsForState
     if (m_state->m_current_menu)
         return m_menu_scope_tests;
 
+    if (m_state->m_in_global_scope)
         return m_global_scope_tests;
+
+    return m_no_scope_tests;
 }
 
 MenuFileParserState* MenuFileParser::GetState() const

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

@@ -0,0 +1,15 @@
+#include "AbstractScopeSequenceHolder.h"
+
+using namespace menu;
+
+AbstractScopeSequenceHolder::AbstractScopeSequenceHolder(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : m_all_sequences(allSequences),
+      m_scope_sequences(scopeSequences)
+{
+}
+
+void AbstractScopeSequenceHolder::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/AbstractScopeSequenceHolder.h

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

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

@@ -0,0 +1,60 @@
+#include "FunctionScopeSequences.h"
+
+#include <sstream>
+
+#include "Generic/GenericStringPropertySequence.h"
+#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
+
+using namespace menu;
+
+namespace menu::function_scope_sequences
+{
+    class SequenceCloseBlock final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_TOKEN = 1;
+
+    public:
+        SequenceCloseBlock()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Char('}')
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            const auto existingFunction = state->m_functions_by_name.find(state->m_current_function->m_name);
+            if (existingFunction == state->m_functions_by_name.end())
+            {
+                state->m_functions_by_name.emplace(std::make_pair(state->m_current_function->m_name, state->m_current_function.get()));
+                state->m_functions.emplace_back(std::move(state->m_current_function));
+                state->m_current_function = nullptr;
+            }
+            else
+            {
+                std::ostringstream ss;
+                ss << "Function with name \"" << state->m_current_menu->m_name << "\" already exists";
+                throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
+            }
+        }
+    };
+}
+
+using namespace function_scope_sequences;
+
+FunctionScopeSequences::FunctionScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : AbstractScopeSequenceHolder(allSequences, scopeSequences)
+{
+}
+
+void FunctionScopeSequences::AddSequences(FeatureLevel featureLevel)
+{
+    AddSequence(std::make_unique<SequenceCloseBlock>());
+    AddSequence(std::make_unique<GenericStringPropertySequence>("name", [](const MenuFileParserState* state, const std::string& value)
+    {
+        state->m_current_function->m_name = value;
+    }));
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractScopeSequenceHolder.h"
+
+namespace menu
+{
+    class FunctionScopeSequences final : AbstractScopeSequenceHolder
+    {
+    public:
+        FunctionScopeSequences(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/GlobalScopeSequences.cpp

@@ -0,0 +1,112 @@
+#include "GlobalScopeSequences.h"
+
+#include "Generic/GenericStringPropertySequence.h"
+#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
+
+using namespace menu;
+
+namespace menu::global_scope_sequences
+{
+    class SequenceCloseBlock final : public MenuFileParser::sequence_t
+    {
+    public:
+        SequenceCloseBlock()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Char('}')
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            state->m_in_global_scope = false;
+        }
+    };
+
+    class SequenceFunctionDef final : public MenuFileParser::sequence_t
+    {
+    public:
+        SequenceFunctionDef()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Keyword("functionDef"),
+                create.Char('{'),
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            state->m_current_function = std::make_unique<CommonFunctionDef>();
+        }
+    };
+
+    class SequenceMenuDef final : public MenuFileParser::sequence_t
+    {
+    public:
+        SequenceMenuDef()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Keyword("menuDef"),
+                create.Char('{'),
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            state->m_current_menu = std::make_unique<CommonMenuDef>();
+        }
+    };
+
+    class SequenceLoadMenu final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_MENU_NAME = 1;
+
+    public:
+        SequenceLoadMenu()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Keyword("loadMenu"),
+                create.Char('{'),
+                create.String().Capture(CAPTURE_MENU_NAME),
+                create.Char('}'),
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            const auto& menuNameToken = result.NextCapture(CAPTURE_MENU_NAME);
+
+            if (menuNameToken.StringValue().empty())
+                throw ParsingException(menuNameToken.GetPos(), "Invalid menu name");
+
+            state->m_menus_to_load.emplace_back(menuNameToken.StringValue());
+        }
+    };
+}
+
+using namespace global_scope_sequences;
+
+GlobalScopeSequences::GlobalScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : AbstractScopeSequenceHolder(allSequences, scopeSequences)
+{
+}
+
+void GlobalScopeSequences::AddSequences(FeatureLevel featureLevel)
+{
+    AddSequence(std::make_unique<SequenceCloseBlock>());
+    AddSequence(std::make_unique<SequenceFunctionDef>());
+    AddSequence(std::make_unique<SequenceMenuDef>());
+    AddSequence(std::make_unique<SequenceLoadMenu>());
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractScopeSequenceHolder.h"
+
+namespace menu
+{
+    class GlobalScopeSequences final : AbstractScopeSequenceHolder
+    {
+    public:
+        GlobalScopeSequences(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/ItemScopeSequences.cpp

@@ -1,19 +1,39 @@
-#include "ItemPropertySequences.h"
+#include "ItemScopeSequences.h"
 
 #include <vector>
 #include <string>
 
-#include "GenericColorPropertySequence.h"
+#include "Generic/GenericColorPropertySequence.h"
-#include "GenericFloatingPointPropertySequence.h"
+#include "Generic/GenericFloatingPointPropertySequence.h"
-#include "GenericIntPropertySequence.h"
+#include "Generic/GenericIntPropertySequence.h"
-#include "GenericKeywordPropertySequence.h"
+#include "Generic/GenericKeywordPropertySequence.h"
-#include "GenericStringPropertySequence.h"
+#include "Generic/GenericStringPropertySequence.h"
 #include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
 
 using namespace menu;
 
-namespace menu::item_properties
+namespace menu::item_scope_sequences
 {
+    class SequenceCloseBlock final : public MenuFileParser::sequence_t
+    {
+    public:
+        SequenceCloseBlock()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Char('}')
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            state->m_current_menu->m_items.emplace_back(std::move(state->m_current_item));
+            state->m_current_item = nullptr;
+        }
+    };
+
     class SequenceRect final : public MenuFileParser::sequence_t
     {
         static constexpr auto CAPTURE_X = 1;
@@ -142,15 +162,16 @@ namespace menu::item_properties
     };
 }
 
-using namespace item_properties;
+using namespace item_scope_sequences;
 
-ItemPropertySequences::ItemPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+ItemScopeSequences::ItemScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
-    : AbstractPropertySequenceHolder(allSequences, scopeSequences)
+    : AbstractScopeSequenceHolder(allSequences, scopeSequences)
 {
 }
 
-void ItemPropertySequences::AddSequences(FeatureLevel featureLevel)
+void ItemScopeSequences::AddSequences(FeatureLevel featureLevel)
 {
+    AddSequence(std::make_unique<SequenceCloseBlock>());
     AddSequence(std::make_unique<GenericStringPropertySequence>("name", [](const MenuFileParserState* state, const std::string& value)
     {
         state->m_current_item->m_name = value;

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractScopeSequenceHolder.h"
+
+namespace menu
+{
+    class ItemScopeSequences final : AbstractScopeSequenceHolder
+    {
+    public:
+        ItemScopeSequences(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/MenuScopeSequences.cpp

@@ -1,20 +1,80 @@
-#include "MenuPropertySequences.h"
+#include "MenuScopeSequences.h"
 
-#include "GenericBoolPropertySequence.h"
+#include <sstream>
-#include "GenericColorPropertySequence.h"
+
-#include "GenericExpressionPropertySequence.h"
+#include "Generic/GenericBoolPropertySequence.h"
-#include "GenericFloatingPointPropertySequence.h"
+#include "Generic/GenericColorPropertySequence.h"
-#include "GenericIntPropertySequence.h"
+#include "Generic/GenericExpressionPropertySequence.h"
-#include "GenericKeywordPropertySequence.h"
+#include "Generic/GenericFloatingPointPropertySequence.h"
-#include "GenericStringPropertySequence.h"
+#include "Generic/GenericIntPropertySequence.h"
+#include "Generic/GenericKeywordPropertySequence.h"
+#include "Generic/GenericStringPropertySequence.h"
 #include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
 #include "Parsing/Menu/Domain/CommonMenuTypes.h"
 #include "Parsing/Menu/Matcher/MenuCommonMatchers.h"
 
 using namespace menu;
 
-namespace menu::menu_properties
+namespace menu::menu_scope_sequences
 {
+    class SequenceCloseBlock final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_TOKEN = 1;
+
+    public:
+        SequenceCloseBlock()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Char('}').Capture(CAPTURE_TOKEN)
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            if (state->m_current_menu->m_name.empty())
+                throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), "Menu must have a name");
+
+            const auto existingMenu = state->m_menus_by_name.find(state->m_current_menu->m_name);
+            if (existingMenu == state->m_menus_by_name.end())
+            {
+                state->m_menus_by_name.emplace(std::make_pair(state->m_current_menu->m_name, state->m_current_menu.get()));
+                state->m_menus.emplace_back(std::move(state->m_current_menu));
+                state->m_current_menu = nullptr;
+            }
+            else
+            {
+                std::ostringstream ss;
+                ss << "Menu with name \"" << state->m_current_menu->m_name << "\" already exists";
+                throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
+            }
+        }
+    };
+
+    class SequenceItemDef final : public MenuFileParser::sequence_t
+    {
+        static constexpr auto CAPTURE_TOKEN = 1;
+
+    public:
+        SequenceItemDef()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Keyword("itemDef"),
+                create.Char('{')
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            state->m_current_item = std::make_unique<CommonItemDef>();
+        }
+    };
+
     class SequenceRect final : public MenuFileParser::sequence_t
     {
         static constexpr auto CAPTURE_X = 1;
@@ -67,15 +127,17 @@ namespace menu::menu_properties
     };
 }
 
-using namespace menu_properties;
+using namespace menu_scope_sequences;
 
-MenuPropertySequences::MenuPropertySequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+MenuScopeSequences::MenuScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
-    : AbstractPropertySequenceHolder(allSequences, scopeSequences)
+    : AbstractScopeSequenceHolder(allSequences, scopeSequences)
 {
 }
 
-void MenuPropertySequences::AddSequences(FeatureLevel featureLevel)
+void MenuScopeSequences::AddSequences(FeatureLevel featureLevel)
 {
+    AddSequence(std::make_unique<SequenceCloseBlock>());
+    AddSequence(std::make_unique<SequenceItemDef>());
     AddSequence(std::make_unique<GenericStringPropertySequence>("name", [](const MenuFileParserState* state, const std::string& value)
     {
         state->m_current_menu->m_name = value;

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractScopeSequenceHolder.h"
+
+namespace menu
+{
+    class MenuScopeSequences final : AbstractScopeSequenceHolder
+    {
+    public:
+        MenuScopeSequences(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/NoScopeSequences.cpp

@@ -0,0 +1,40 @@
+#include "NoScopeSequences.h"
+
+#include "Generic/GenericStringPropertySequence.h"
+#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
+
+using namespace menu;
+
+namespace menu::no_scope_sequences
+{
+    class SequenceOpenGlobalScope final : public MenuFileParser::sequence_t
+    {
+    public:
+        SequenceOpenGlobalScope()
+        {
+            const MenuMatcherFactory create(this);
+
+            AddMatchers({
+                create.Char('{')
+            });
+        }
+
+    protected:
+        void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
+        {
+            state->m_in_global_scope = true;
+        }
+    };
+}
+
+using namespace no_scope_sequences;
+
+NoScopeSequences::NoScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
+    : AbstractScopeSequenceHolder(allSequences, scopeSequences)
+{
+}
+
+void NoScopeSequences::AddSequences(FeatureLevel featureLevel)
+{
+    AddSequence(std::make_unique<SequenceOpenGlobalScope>());
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractScopeSequenceHolder.h"
+
+namespace menu
+{
+    class NoScopeSequences final : AbstractScopeSequenceHolder
+    {
+    public:
+        NoScopeSequences(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/AbstractPropertySequenceHolder.cpp

@@ -1,15 +0,0 @@
-#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

@@ -1,29 +0,0 @@
-#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

@@ -1,25 +0,0 @@
-#include "FunctionPropertySequences.h"
-
-#include "GenericStringPropertySequence.h"
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-namespace menu::function_properties
-{
-}
-
-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<GenericStringPropertySequence>("name", [](const MenuFileParserState* state, const std::string& value)
-    {
-        state->m_current_function->m_name = value;
-    }));
-}

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

@@ -1,14 +0,0 @@
-#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.h

@@ -1,14 +0,0 @@
-#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.h

@@ -1,14 +0,0 @@
-#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/SequenceCloseBlock.cpp

@@ -1,69 +0,0 @@
-#include "SequenceCloseBlock.h"
-
-#include <sstream>
-
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceCloseBlock::SequenceCloseBlock()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.Char('}').Capture(CAPTURE_TOKEN)
-    });
-}
-
-void SequenceCloseBlock::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(state->m_current_item || state->m_current_menu || state->m_current_function || state->m_in_global_scope);
-    assert(!state->m_current_item || (state->m_current_item && state->m_current_menu));
-
-    if(state->m_current_item && state->m_current_menu)
-    {
-        state->m_current_menu->m_items.emplace_back(std::move(state->m_current_item));
-        state->m_current_item = nullptr;
-    }
-    else if(state->m_current_menu)
-    {
-        if(state->m_current_menu->m_name.empty())
-            throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), "Menu must have a name");
-
-        const auto existingMenu = state->m_menus_by_name.find(state->m_current_menu->m_name);
-        if(existingMenu == state->m_menus_by_name.end())
-        {
-            state->m_menus_by_name.emplace(std::make_pair(state->m_current_menu->m_name, state->m_current_menu.get()));
-            state->m_menus.emplace_back(std::move(state->m_current_menu));
-            state->m_current_menu = nullptr;
-        }
-        else
-        {
-            std::ostringstream ss;
-            ss << "Menu with name \"" << state->m_current_menu->m_name << "\" already exists";
-            throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
-        }
-    }
-    else if(state->m_current_function)
-    {
-        const auto existingFunction = state->m_functions_by_name.find(state->m_current_function->m_name);
-        if (existingFunction == state->m_functions_by_name.end())
-        {
-            state->m_functions_by_name.emplace(std::make_pair(state->m_current_function->m_name, state->m_current_function.get()));
-            state->m_functions.emplace_back(std::move(state->m_current_function));
-            state->m_current_function = nullptr;
-        }
-        else
-        {
-            std::ostringstream ss;
-            ss << "Function with name \"" << state->m_current_menu->m_name << "\" already exists";
-            throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
-        }
-    }
-    else if(state->m_in_global_scope)
-    {
-        state->m_in_global_scope = false;
-    }
-    else
-        throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), "Invalid close block");
-}

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

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

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

@@ -1,22 +0,0 @@
-#include "SequenceFunctionDef.h"
-
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceFunctionDef::SequenceFunctionDef()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.Keyword("functionDef"),
-        create.Char('{'),
-    });
-}
-
-void SequenceFunctionDef::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(!state->m_current_menu);
-
-    state->m_current_item = std::make_unique<CommonItemDef>();
-}

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

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

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

@@ -1,22 +0,0 @@
-#include "SequenceItemDef.h"
-
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceItemDef::SequenceItemDef()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.Keyword("itemDef"),
-        create.Char('{'),
-    });
-}
-
-void SequenceItemDef::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(state->m_current_menu);
-
-    state->m_current_item = std::make_unique<CommonItemDef>();
-}

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

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

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

@@ -1,29 +0,0 @@
-#include "SequenceLoadMenu.h"
-
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceLoadMenu::SequenceLoadMenu()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.Keyword("loadMenu"),
-        create.Char('{'),
-        create.String().Capture(CAPTURE_MENU_NAME),
-        create.Char('}'),
-    });
-}
-
-void SequenceLoadMenu::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(!state->m_current_menu);
-
-    const auto& menuNameToken = result.NextCapture(CAPTURE_MENU_NAME);
-
-    if (menuNameToken.StringValue().empty())
-        throw ParsingException(menuNameToken.GetPos(), "Invalid menu name");
-
-    state->m_menus_to_load.emplace_back(menuNameToken.StringValue());
-}

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

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

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

@@ -1,22 +0,0 @@
-#include "SequenceMenuDef.h"
-
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceMenuDef::SequenceMenuDef()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.Keyword("menuDef"),
-        create.Char('{'),
-    });
-}
-
-void SequenceMenuDef::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(!state->m_current_menu);
-
-    state->m_current_menu = std::make_unique<CommonMenuDef>();
-}

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

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

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

@@ -1,20 +0,0 @@
-#include "SequenceOpenGlobalScopeBlock.h"
-
-#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
-
-using namespace menu;
-
-SequenceOpenGlobalScopeBlock::SequenceOpenGlobalScopeBlock()
-{
-    const MenuMatcherFactory create(this);
-
-    AddMatchers({
-        create.Char('{')
-    });
-}
-
-void SequenceOpenGlobalScopeBlock::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    assert(!state->m_in_global_scope);
-    state->m_in_global_scope = true;
-}

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

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