Add ZoneWriting basis

src/ZoneWriting/Writing/Steps/StepAddOutputProcessor.cpp

@@ -0,0 +1,16 @@
+#include "StepAddOutputProcessor.h"
+#include <cassert>
+
+StepAddOutputProcessor::StepAddOutputProcessor(std::unique_ptr<OutputStreamProcessor> streamProcessor)
+    : m_stream_processor(std::move(streamProcessor))
+{
+}
+
+void StepAddOutputProcessor::PerformStep(ZoneWriter* zoneLoader, IWritingStream* stream)
+{
+    assert(zoneLoader != nullptr);
+    assert(m_stream_processor != nullptr);
+
+    zoneLoader->AddStreamProcessor(std::move(m_stream_processor));
+    m_stream_processor = nullptr;
+}

src/ZoneWriting/Writing/Steps/StepAddOutputProcessor.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <memory>
+
+#include "Writing/IWritingStep.h"
+
+class StepAddOutputProcessor final : public IWritingStep
+{
+    std::unique_ptr<OutputStreamProcessor> m_stream_processor;
+
+public:
+    explicit StepAddOutputProcessor(std::unique_ptr<OutputStreamProcessor> streamProcessor);
+
+    void PerformStep(ZoneWriter* zoneLoader, IWritingStream* stream) override;
+};

src/ZoneWriting/Writing/Steps/StepWriteXBlockSizes.cpp

@@ -0,0 +1,10 @@
+#include "StepWriteXBlockSizes.h"
+
+StepWriteXBlockSizes::StepWriteXBlockSizes(Zone* zone)
+    : m_zone(zone)
+{
+}
+
+void StepWriteXBlockSizes::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
+{
+}

src/ZoneWriting/Writing/Steps/StepWriteXBlockSizes.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "Writing/IWritingStep.h"
+#include "Zone/Zone.h"
+
+class StepWriteXBlockSizes final : public IWritingStep
+{
+    Zone* m_zone;
+
+public:
+    explicit StepWriteXBlockSizes(Zone* zone);
+
+    void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+};

src/ZoneWriting/Writing/Steps/StepWriteZero.cpp

@@ -0,0 +1,20 @@
+#include "StepWriteZero.h"
+
+#include <algorithm>
+
+StepWriteZero::StepWriteZero(const size_t count)
+    : m_count(count)
+{
+}
+
+void StepWriteZero::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
+{
+    const uint64_t num = 0;
+    size_t toWrite;
+
+    for(auto i = 0u; i < m_count; i += toWrite)
+    {
+        toWrite = std::min(sizeof(uint64_t), m_count - i);
+        stream->Write(&num, toWrite);
+    }
+}

src/ZoneWriting/Writing/Steps/StepWriteZero.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "Writing/IWritingStep.h"
+
+class StepWriteZero final : public IWritingStep
+{
+    size_t m_count;
+
+public:
+    explicit StepWriteZero(size_t count);
+
+    void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+};

src/ZoneWriting/Writing/Steps/StepWriteZoneContentToFile.cpp

@@ -0,0 +1,10 @@
+#include "StepWriteZoneContentToFile.h"
+
+StepWriteZoneContentToFile::StepWriteZoneContentToFile(StepWriteZoneContentToMemory* zoneMemory)
+    : m_memory(zoneMemory)
+{
+}
+
+void StepWriteZoneContentToFile::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
+{
+}

src/ZoneWriting/Writing/Steps/StepWriteZoneContentToFile.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "StepWriteZoneContentToMemory.h"
+#include "Writing/IWritingStep.h"
+
+class StepWriteZoneContentToFile final : public IWritingStep
+{
+    StepWriteZoneContentToMemory* m_memory;
+
+public:
+    explicit StepWriteZoneContentToFile(StepWriteZoneContentToMemory* zoneMemory);
+
+    void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+};

src/ZoneWriting/Writing/Steps/StepWriteZoneContentToMemory.cpp

@@ -0,0 +1,27 @@
+#include "StepWriteZoneContentToMemory.h"
+
+#include "Zone/Stream/Impl/InMemoryZoneOutputStream.h"
+
+StepWriteZoneContentToMemory::StepWriteZoneContentToMemory(std::unique_ptr<IContentWritingEntryPoint> entryPoint, Zone* zone, int offsetBlockBitCount, block_t insertBlock)
+    : m_content_loader(std::move(entryPoint)),
+      m_zone_data(std::make_unique<InMemoryZoneData>()),
+      m_zone(zone),
+      m_offset_block_bit_count(offsetBlockBitCount),
+      m_insert_block(insertBlock)
+{
+}
+
+void StepWriteZoneContentToMemory::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
+{
+    std::vector<XBlock*> blocks;
+    for (const auto& block : zoneWriter->m_blocks)
+        blocks.push_back(block.get());
+
+    const auto zoneOutputStream = std::make_unique<InMemoryZoneOutputStream>(m_zone_data.get(), std::move(blocks), m_offset_block_bit_count, m_insert_block);
+    m_content_loader->WriteContent(m_zone, zoneOutputStream.get());
+}
+
+InMemoryZoneData* StepWriteZoneContentToMemory::GetData() const
+{
+    return m_zone_data.get();
+}

src/ZoneWriting/Writing/Steps/StepWriteZoneContentToMemory.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <memory>
+
+#include "Utils/ClassUtils.h"
+#include "Writing/IContentWritingEntryPoint.h"
+#include "Writing/InMemoryZoneData.h"
+#include "Writing/IWritingStep.h"
+
+class StepWriteZoneContentToMemory final : public IWritingStep
+{
+    std::unique_ptr<IContentWritingEntryPoint> m_content_loader;
+    std::unique_ptr<InMemoryZoneData> m_zone_data;
+    Zone* m_zone;
+    int m_offset_block_bit_count;
+    block_t m_insert_block;
+
+public:
+    StepWriteZoneContentToMemory(std::unique_ptr<IContentWritingEntryPoint> entryPoint, Zone* zone, int offsetBlockBitCount, block_t insertBlock);
+
+    void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+    _NODISCARD InMemoryZoneData* GetData() const;
+};

src/ZoneWriting/Writing/Steps/StepWriteZoneHeader.cpp

@@ -0,0 +1,11 @@
+#include "StepWriteZoneHeader.h"
+
+StepWriteZoneHeader::StepWriteZoneHeader(const ZoneHeader header)
+    : m_header(header)
+{
+}
+
+void StepWriteZoneHeader::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
+{
+    stream->Write(&m_header, sizeof(m_header));
+}

src/ZoneWriting/Writing/Steps/StepWriteZoneHeader.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "Writing/IWritingStep.h"
+
+class StepWriteZoneHeader final : public IWritingStep
+{
+    ZoneHeader m_header;
+
+public:
+    explicit StepWriteZoneHeader(ZoneHeader header);
+
+    void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+};

src/ZoneWriting/Writing/Steps/StepWriteZoneSizes.cpp

@@ -0,0 +1,15 @@
+#include "StepWriteZoneSizes.h"
+
+StepWriteZoneSizes::StepWriteZoneSizes(StepWriteZoneContentToMemory* memory)
+    : m_memory(memory)
+{
+}
+
+void StepWriteZoneSizes::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
+{
+    auto totalSize = static_cast<size_t>(m_memory->GetData()->m_total_size);
+    size_t externalSize = 0;
+
+    stream->Write(&totalSize, sizeof(totalSize));
+    stream->Write(&externalSize, sizeof(externalSize));
+}

src/ZoneWriting/Writing/Steps/StepWriteZoneSizes.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "StepWriteZoneContentToMemory.h"
+#include "Writing/IWritingStep.h"
+
+class StepWriteZoneSizes final : public IWritingStep
+{
+    StepWriteZoneContentToMemory* m_memory;
+
+public:
+    explicit StepWriteZoneSizes(StepWriteZoneContentToMemory* memory);
+
+    void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+};