Dump StructuredDataDef enums

src/ObjWriting/Dumping/StructuredDataDef/StructuredDataDefDumper.cpp

@@ -4,7 +4,9 @@
 
 StructuredDataDefDumper::StructuredDataDefDumper(std::ostream& stream)
     : AbstractTextDumper(stream),
-      m_flags{}
+      m_block(Block::BLOCK_NONE),
+      m_flags{},
+      m_enum_size(0u)
 {
 }
 
@@ -16,15 +18,12 @@ void StructuredDataDefDumper::BeginVersion(const int version)
 
     if (m_flags.m_empty_line_before_version)
         m_stream << "\n";
-    else
-        m_flags.m_empty_line_before_version = true;
 
     Indent();
     m_stream << "version " << version << "\n";
 
     Indent();
     m_stream << "{\n";
-
     IncIndent();
 
     m_flags.m_in_version = true;
@@ -40,4 +39,105 @@ void StructuredDataDefDumper::EndVersion()
     Indent();
     m_stream << "}\n";
     m_flags.m_in_version = false;
+    m_flags.m_empty_line_before_version = true;
+    m_flags.m_empty_line_before_block = false;
+}
+
+void StructuredDataDefDumper::BeginEnum(const std::string& enumName, const size_t enumEntryCount)
+{
+    assert(m_flags.m_in_version);
+    assert(m_block == Block::BLOCK_NONE);
+
+    if (m_block != Block::BLOCK_NONE)
+        return;
+
+    if (m_flags.m_empty_line_before_block)
+        m_stream << "\n";
+
+    Indent();
+    m_stream << "enum " << enumName << "\n";
+
+    Indent();
+    m_stream << "{\n";
+    IncIndent();
+
+    m_block = Block::BLOCK_ENUM;
+
+    m_enum_entries.resize(enumEntryCount);
+    m_enum_size = enumEntryCount;
+}
+
+void StructuredDataDefDumper::EndEnum()
+{
+    assert(m_block == Block::BLOCK_ENUM);
+
+    if (m_block != Block::BLOCK_ENUM)
+        return;
+
+    bool firstEntry = true;
+    for(const auto& entry : m_enum_entries)
+    {
+        if (firstEntry)
+            firstEntry = false;
+        else
+            m_stream << ",\n";
+
+        Indent();
+        m_stream << entry;
+    }
+
+    if (!firstEntry)
+        m_stream << "\n";
+
+    DecIndent();
+    Indent();
+    m_stream << "};\n";
+    m_block = Block::BLOCK_NONE;
+    m_flags.m_empty_line_before_block = true;
+}
+
+void StructuredDataDefDumper::WriteEnumEntry(const std::string& entryName, const size_t entryValue)
+{
+    assert(m_block == Block::BLOCK_ENUM);
+    assert(entryValue < m_enum_size);
+
+    if (m_block != Block::BLOCK_ENUM || entryValue >= m_enum_size)
+        return;
+
+    m_enum_entries[entryValue] = entryName;
+}
+
+void StructuredDataDefDumper::BeginStruct(const std::string& structName)
+{
+    assert(m_flags.m_in_version);
+    assert(m_block == Block::BLOCK_NONE);
+
+    if (m_block != Block::BLOCK_NONE)
+        return;
+
+    if (m_flags.m_empty_line_before_block)
+        m_stream << "\n";
+
+    Indent();
+    m_stream << "struct " << structName << "\n";
+
+    Indent();
+    m_stream << "{\n";
+    IncIndent();
+
+    m_block = Block::BLOCK_STRUCT;
+}
+
+void StructuredDataDefDumper::EndStruct()
+{
+    assert(m_block == Block::BLOCK_STRUCT);
+
+    if (m_block != Block::BLOCK_STRUCT)
+        return;
+
+    DecIndent();
+    Indent();
+    m_stream << "};\n";
+    m_block = Block::BLOCK_NONE;
+    m_flags.m_empty_line_before_block = true;
 }

src/ObjWriting/Dumping/StructuredDataDef/StructuredDataDefDumper.h

@@ -1,18 +1,38 @@
 #pragma once
 
+#include <vector>
+
 #include "Dumping/AbstractTextDumper.h"
 
 class StructuredDataDefDumper : AbstractTextDumper
 {
+    enum class Block
+    {
+        BLOCK_NONE = 0,
+        BLOCK_ENUM = 1,
+        BLOCK_STRUCT = 2
+    } m_block;
+
     struct
     {
         bool m_in_version : 1;
         bool m_empty_line_before_version : 1;
+        bool m_empty_line_before_block : 1;
     } m_flags;
 
+    std::vector<std::string> m_enum_entries;
+    size_t m_enum_size;
+
 public:
     explicit StructuredDataDefDumper(std::ostream& stream);
 
     void BeginVersion(int version);
     void EndVersion();
+
+    void BeginEnum(const std::string& enumName, size_t enumEntryCount);
+    void EndEnum();
+    void WriteEnumEntry(const std::string& entryName, size_t entryValue);
+
+    void BeginStruct(const std::string& structName);
+    void EndStruct();
 };