Add ZoneDefinition Parsing

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionEntry.cpp

@@ -0,0 +1,23 @@
+#include "SequenceZoneDefinitionEntry.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceZoneDefinitionEntry::SequenceZoneDefinitionEntry()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Identifier().Capture(CAPTURE_TYPE_NAME),
+        create.Char(','),
+        create.Optional(create.Char(',').Tag(TAG_REFERENCE)),
+        create.Identifier().Capture(CAPTURE_ASSET_NAME)
+    });
+}
+
+void SequenceZoneDefinitionEntry::ProcessMatch(ZoneDefinition* state, SequenceResult<SimpleParserValue>& result) const
+{
+    state->m_assets.emplace_back(
+        result.NextCapture(CAPTURE_TYPE_NAME).IdentifierValue(),
+        result.NextCapture(CAPTURE_ASSET_NAME).IdentifierValue(),
+        result.NextTag() == TAG_REFERENCE);
+}

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionEntry.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Parsing/ZoneDefinition/ZoneDefinitionParser.h"
+
+class SequenceZoneDefinitionEntry final : public ZoneDefinitionParser::sequence_t
+{
+    static constexpr auto TAG_REFERENCE = 1;
+
+    static constexpr auto CAPTURE_TYPE_NAME = 1;
+    static constexpr auto CAPTURE_ASSET_NAME = 2;
+
+protected:
+    void ProcessMatch(ZoneDefinition* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceZoneDefinitionEntry();
+};

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionMetaData.cpp

@@ -0,0 +1,20 @@
+#include "SequenceZoneDefinitionMetaData.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceZoneDefinitionMetaData::SequenceZoneDefinitionMetaData()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Char('>'),
+        create.Identifier().Capture(CAPTURE_KEY),
+        create.Char(','),
+        create.Identifier().Capture(CAPTURE_VALUE)
+    });
+}
+
+void SequenceZoneDefinitionMetaData::ProcessMatch(ZoneDefinition* state, SequenceResult<SimpleParserValue>& result) const
+{
+    state->m_metadata[result.NextCapture(CAPTURE_KEY).IdentifierValue()] = result.NextCapture(CAPTURE_VALUE).IdentifierValue();
+}

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionMetaData.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Parsing/ZoneDefinition/ZoneDefinitionParser.h"
+
+class SequenceZoneDefinitionMetaData final : public ZoneDefinitionParser::sequence_t
+{
+    static constexpr auto CAPTURE_KEY = 1;
+    static constexpr auto CAPTURE_VALUE = 2;
+
+protected:
+    void ProcessMatch(ZoneDefinition* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceZoneDefinitionMetaData();
+};

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParser.cpp

@@ -0,0 +1,24 @@
+#include "ZoneDefinitionParser.h"
+
+#include "Sequence/SequenceZoneDefinitionEntry.h"
+#include "Sequence/SequenceZoneDefinitionMetaData.h"
+
+ZoneDefinitionParser::ZoneDefinitionParser(SimpleLexer* lexer)
+    : AbstractParser(lexer, std::make_unique<ZoneDefinition>())
+{
+}
+
+const std::vector<AbstractParser<SimpleParserValue, ZoneDefinition>::sequence_t*>& ZoneDefinitionParser::GetTestsForState()
+{
+    static std::vector<sequence_t*> tests({
+        new SequenceZoneDefinitionMetaData(),
+        new SequenceZoneDefinitionEntry()
+    });
+
+    return tests;
+}
+
+std::unique_ptr<ZoneDefinition> ZoneDefinitionParser::GetParsedValue()
+{
+    return std::move(m_state);
+}

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParser.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Parsing/Simple/SimpleLexer.h"
+#include "Parsing/Simple/SimpleParserValue.h"
+#include "Parsing/Impl/AbstractParser.h"
+#include "Zone/Definition/ZoneDefinition.h"
+
+class ZoneDefinitionParser final : public AbstractParser<SimpleParserValue, ZoneDefinition>
+{
+protected:
+    const std::vector<sequence_t*>& GetTestsForState() override;
+
+public:
+    explicit ZoneDefinitionParser(SimpleLexer* lexer);
+    std::unique_ptr<ZoneDefinition> GetParsedValue();
+};

src/ZoneCommon/Zone/Definition/ZoneDefinitionStream.cpp

@@ -1,13 +1,62 @@
 #include "ZoneDefinitionStream.h"
 
-ZoneDefinitionInputStream::ZoneDefinitionInputStream(std::istream& stream)
+#include <chrono>
-    : m_stream(stream)
+
+#include "Parsing/Impl/ParserInputStream.h"
+#include <Parsing/Impl/CommentRemovingStreamProxy.h>
+
+#include "Parsing/Impl/DefinesStreamProxy.h"
+#include "Parsing/Simple/SimpleLexer.h"
+#include "Parsing/ZoneDefinition/ZoneDefinitionParser.h"
+
+ZoneDefinitionInputStream::ZoneDefinitionInputStream(std::istream& stream, std::string fileName, bool verbose)
+    : m_file_name(std::move(fileName)),
+      m_verbose(verbose),
+      m_stream(nullptr)
 {
+    OpenBaseStream(stream);
+    SetupStreamProxies();
+    m_stream = m_open_streams.back().get();
+}
+
+bool ZoneDefinitionInputStream::OpenBaseStream(std::istream& stream)
+{
+    m_open_streams.emplace_back(std::make_unique<ParserInputStream>(stream, m_file_name));
+    return true;
+}
+
+void ZoneDefinitionInputStream::SetupStreamProxies()
+{
+    m_open_streams.emplace_back(std::make_unique<CommentRemovingStreamProxy>(m_open_streams.back().get()));
+    auto definesProxy = std::make_unique<DefinesStreamProxy>(m_open_streams.back().get());
+    definesProxy->AddDefine(DefinesStreamProxy::Define(ZONE_CODE_GENERATOR_DEFINE_NAME, ZONE_CODE_GENERATOR_DEFINE_VALUE));
+    m_open_streams.emplace_back(std::move(definesProxy));
+
+    m_stream = m_open_streams.back().get();
 }
 
 std::unique_ptr<ZoneDefinition> ZoneDefinitionInputStream::ReadDefinition()
 {
-    return nullptr;
+    if (m_verbose)
+    {
+        std::cout << "Reading zone definition file: " << m_file_name << std::endl;
+    }
+
+    const auto lexer = std::make_unique<SimpleLexer>(m_stream);
+    const auto parser = std::make_unique<ZoneDefinitionParser>(lexer.get());
+
+    const auto start = std::chrono::steady_clock::now();
+    std::unique_ptr<ZoneDefinition> definition;
+    if (parser->Parse())
+        definition = parser->GetParsedValue();
+    const auto end = std::chrono::steady_clock::now();
+
+    if (m_verbose)
+    {
+        std::cout << "Processing zone definition took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
+    }
+
+    return std::move(definition);
 }
 
 ZoneDefinitionOutputStream::ZoneDefinitionOutputStream(std::ostream& stream)

src/ZoneCommon/Zone/Definition/ZoneDefinitionStream.h

@@ -3,13 +3,23 @@
 #include <memory>
 
 #include "ZoneDefinition.h"
+#include "Parsing/IParserLineStream.h"
 
 class ZoneDefinitionInputStream
 {
-    std::istream& m_stream;
+    static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
+    static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1";
+
+    std::string m_file_name;
+    bool m_verbose;
+    IParserLineStream* m_stream;
+    std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
+
+    bool OpenBaseStream(std::istream& stream);
+    void SetupStreamProxies();
 
 public:
-    explicit ZoneDefinitionInputStream(std::istream& stream);
+    ZoneDefinitionInputStream(std::istream& stream, std::string fileName, bool verbose);
 
     std::unique_ptr<ZoneDefinition> ReadDefinition();
 };