create enum definitions from headers

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParser.cpp

@@ -2,9 +2,8 @@
 
 #include "Parsing/Header/Sequence/SequenceNamespace.h"
 
-HeaderParser::HeaderParser(HeaderLexer* lexer, IDataRepository* targetRepository)
-    : AbstractParser(lexer, std::make_unique<HeaderParserState>()),
-      m_repository(targetRepository)
+HeaderParser::HeaderParser(HeaderLexer* lexer)
+    : AbstractParser(lexer, std::make_unique<HeaderParserState>())
 {
     auto sequenceNamespace = std::make_unique<SequenceNamespace>();
 }
@@ -13,3 +12,8 @@ const std::vector<HeaderParser::sequence_t*>& HeaderParser::GetTestsForState()
 {
     return m_state->GetBlock()->GetTestsForBlock();
 }
+
+void HeaderParser::SaveToRepository(IDataRepository* repository)
+{
+
+}

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParser.h

@@ -7,11 +7,11 @@
 
 class HeaderParser final : public AbstractParser<HeaderParserValue, HeaderParserState>
 {
-    IDataRepository* m_repository;
-
 protected:
     const std::vector<sequence_t*>& GetTestsForState() override;
 
 public:
-    HeaderParser(HeaderLexer* lexer, IDataRepository* targetRepository);
+    explicit HeaderParser(HeaderLexer* lexer);
+
+    void SaveToRepository(IDataRepository* repository);
 };

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserState.cpp

@@ -1,10 +1,19 @@
 #include "HeaderParserState.h"
 
+#include "Domain/Definition/EnumDefinition.h"
 #include "Parsing/Header/Block/HeaderBlockNone.h"
 
 HeaderParserState::HeaderParserState()
 {
     m_blocks.push(std::make_unique<HeaderBlockNone>());
+
+    for(auto i = 0u; i < BaseTypeDefinition::ALL_BASE_TYPES_COUNT; i++)
+        AddBaseDataType(BaseTypeDefinition::ALL_BASE_TYPES[i]);
+}
+
+void HeaderParserState::AddBaseDataType(const BaseTypeDefinition* baseType)
+{
+    m_definitions.insert(std::make_pair(baseType->GetFullName(), baseType));
 }
 
 IHeaderBlock* HeaderParserState::GetBlock() const
@@ -29,3 +38,48 @@ void HeaderParserState::PopBlock()
         m_blocks.top()->OnChildBlockClose(this, poppedBlock.get());
     }
 }
+
+void HeaderParserState::AddDataType(std::unique_ptr<DataDefinition> definition)
+{
+    if(definition->GetType() == DataDefinitionType::ENUM)
+    {
+        for(const auto& enumMember : dynamic_cast<EnumDefinition*>(definition.get())->m_members)
+        {
+            m_enum_members.insert(std::make_pair(enumMember->m_name, enumMember.get()));
+        }
+    }
+
+    const DataDefinition* dataDefinition = definition.get();
+    m_header_definitions.emplace_back(std::move(definition));
+    m_definitions.insert(std::make_pair(dataDefinition->m_name, dataDefinition));
+}
+
+void HeaderParserState::AddForwardDeclaration(std::unique_ptr<ForwardDeclaration> forwardDeclaration)
+{
+    m_forward_declarations.insert(std::make_pair(forwardDeclaration->m_name, std::move(forwardDeclaration)));
+}
+
+const DataDefinition* HeaderParserState::FindType(const std::string& typeName)
+{
+    const auto foundDefinitionEntry = m_definitions.find(typeName);
+
+    if (foundDefinitionEntry != m_definitions.end())
+        return foundDefinitionEntry->second;
+
+    const auto foundForwardEntry = m_forward_declarations.find(typeName);
+
+    if (foundForwardEntry != m_forward_declarations.end())
+        return foundForwardEntry->second.get();
+
+    return nullptr;
+}
+
+EnumMember* HeaderParserState::FindEnumMember(const std::string& enumMemberName)
+{
+    const auto foundEntry = m_enum_members.find(enumMemberName);
+
+    if (foundEntry != m_enum_members.end())
+        return foundEntry->second;
+
+    return nullptr;
+}

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserState.h

@@ -2,15 +2,28 @@
 
 #include <memory>
 #include <stack>
+#include <unordered_map>
 
 #include "Utils/ClassUtils.h"
+#include "Domain/Definition/BaseTypeDefinition.h"
+#include "Domain/Definition/DataDefinition.h"
+#include "Domain/Definition/EnumMember.h"
+#include "Domain/Definition/ForwardDeclaration.h"
 #include "Utils/NamespaceBuilder.h"
 #include "Parsing/Header/Block/IHeaderBlock.h"
 
 class IHeaderBlock;
+
 class HeaderParserState
 {
+    std::vector<std::unique_ptr<DataDefinition>> m_header_definitions;
+
     std::stack<std::unique_ptr<IHeaderBlock>> m_blocks;
+    std::unordered_map<std::string, const DataDefinition*> m_definitions;
+    std::unordered_map<std::string, EnumMember*> m_enum_members;
+    std::unordered_map<std::string, std::unique_ptr<ForwardDeclaration>> m_forward_declarations;
+
+    void AddBaseDataType(const BaseTypeDefinition* baseType);
 
 public:
     NamespaceBuilder m_namespace;
@@ -20,4 +33,10 @@ public:
     _NODISCARD IHeaderBlock* GetBlock() const;
     void PushBlock(std::unique_ptr<IHeaderBlock> block);
     void PopBlock();
+
+    void AddDataType(std::unique_ptr<DataDefinition> definition);
+    void AddForwardDeclaration(std::unique_ptr<ForwardDeclaration> forwardDeclaration);
+
+    const DataDefinition* FindType(const std::string& typeName);
+    EnumMember* FindEnumMember(const std::string& enumMemberName);
 };