refactor: use OutputPathFilesystem for writing fastfiles

src/ZoneWriting/Writing/AssetWriter.cpp

@@ -2,7 +2,7 @@
 
 #include <cassert>
 
-AssetWriter::AssetWriter(XAssetInfoGeneric* asset, Zone* zone, IZoneOutputStream* stream)
+AssetWriter::AssetWriter(XAssetInfoGeneric* asset, const Zone& zone, IZoneOutputStream& stream)
     : ContentWriterBase(zone, stream),
       m_asset(asset),
       varScriptString(nullptr),
@@ -14,11 +14,11 @@ scr_string_t AssetWriter::UseScriptString(const scr_string_t scrString) const
 {
     assert(scrString < m_asset->m_zone->m_script_strings.Count());
 
-    if (m_asset->m_zone == m_zone)
+    if (m_asset->m_zone == &m_zone)
         return scrString;
 
     const auto strValue = m_asset->m_zone->m_script_strings.CValue(scrString);
-    return m_zone->m_script_strings.GetScriptString(strValue);
+    return m_zone.m_script_strings.GetScriptString(strValue);
 }
 
 void AssetWriter::WriteScriptStringArray(const bool atStreamStart, const size_t count)

src/ZoneWriting/Writing/AssetWriter.h

@@ -9,13 +9,13 @@
 class AssetWriter : public ContentWriterBase
 {
 protected:
+    AssetWriter(XAssetInfoGeneric* asset, const Zone& zone, IZoneOutputStream& stream);
+
+    _NODISCARD scr_string_t UseScriptString(scr_string_t scrString) const;
+    void WriteScriptStringArray(bool atStreamStart, size_t count);
+
     XAssetInfoGeneric* m_asset;
 
     scr_string_t* varScriptString;
     scr_string_t* varScriptStringWritten;
-
-    AssetWriter(XAssetInfoGeneric* asset, Zone* zone, IZoneOutputStream* stream);
-
-    _NODISCARD scr_string_t UseScriptString(scr_string_t scrString) const;
-    void WriteScriptStringArray(bool atStreamStart, size_t count);
 };

src/ZoneWriting/Writing/ContentWriterBase.cpp

@@ -2,19 +2,19 @@
 
 #include <cassert>
 
-ContentWriterBase::ContentWriterBase()
-    : varXString(nullptr),
-      varXStringWritten(nullptr),
-      m_zone(nullptr),
-      m_stream(nullptr)
+ContentWriterBase::ContentWriterBase(const Zone& zone)
+    : m_zone(zone),
+      m_stream(nullptr),
+      varXString(nullptr),
+      varXStringWritten(nullptr)
 {
 }
 
-ContentWriterBase::ContentWriterBase(Zone* zone, IZoneOutputStream* stream)
-    : varXString(nullptr),
-      varXStringWritten(nullptr),
-      m_zone(zone),
-      m_stream(stream)
+ContentWriterBase::ContentWriterBase(const Zone& zone, IZoneOutputStream& stream)
+    : m_zone(zone),
+      m_stream(&stream),
+      varXString(nullptr),
+      varXStringWritten(nullptr)
 {
 }
 

src/ZoneWriting/Writing/ContentWriterBase.h

@@ -6,17 +6,8 @@
 class ContentWriterBase
 {
 protected:
-    const char** varXString;
-    const char** varXStringWritten;
-
-    Zone* m_zone;
-    IZoneOutputStream* m_stream;
-
-    ContentWriterBase();
-    ContentWriterBase(Zone* zone, IZoneOutputStream* stream);
-
-    void WriteXString(bool atStreamStart);
-    void WriteXStringArray(bool atStreamStart, size_t count);
+    explicit ContentWriterBase(const Zone& zone);
+    ContentWriterBase(const Zone& zone, IZoneOutputStream& stream);
 
 public:
     virtual ~ContentWriterBase() = default;
@@ -24,4 +15,14 @@ public:
     ContentWriterBase(ContentWriterBase&& other) noexcept = default;
     ContentWriterBase& operator=(const ContentWriterBase& other) = default;
     ContentWriterBase& operator=(ContentWriterBase&& other) noexcept = default;
+
+protected:
+    void WriteXString(bool atStreamStart);
+    void WriteXStringArray(bool atStreamStart, size_t count);
+
+    const Zone& m_zone;
+    IZoneOutputStream* m_stream;
+
+    const char** varXString;
+    const char** varXStringWritten;
 };

src/ZoneWriting/Writing/IContentWritingEntryPoint.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "Zone/Stream/IZoneOutputStream.h"
-#include "Zone/Zone.h"
 
 class IContentWritingEntryPoint
 {
@@ -13,5 +12,5 @@ public:
     IContentWritingEntryPoint& operator=(const IContentWritingEntryPoint& other) = default;
     IContentWritingEntryPoint& operator=(IContentWritingEntryPoint&& other) noexcept = default;
 
-    virtual void WriteContent(Zone* zone, IZoneOutputStream* stream) = 0;
+    virtual void WriteContent(IZoneOutputStream& stream) = 0;
 };

src/ZoneWriting/Writing/IZoneWriterFactory.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "Utils/ClassUtils.h"
 #include "Zone/Zone.h"
 #include "ZoneWriter.h"
 
@@ -14,7 +13,7 @@ public:
     IZoneWriterFactory& operator=(const IZoneWriterFactory& other) = default;
     IZoneWriterFactory& operator=(IZoneWriterFactory&& other) noexcept = default;
 
-    _NODISCARD virtual std::unique_ptr<ZoneWriter> CreateWriter(Zone* zone) const = 0;
+    [[nodiscard]] virtual std::unique_ptr<ZoneWriter> CreateWriter(const Zone& zone) const = 0;
 
     static const IZoneWriterFactory* GetZoneWriterFactoryForGame(GameId game);
 };

src/ZoneWriting/Writing/Steps/StepWriteXBlockSizes.cpp

@@ -1,6 +1,6 @@
 #include "StepWriteXBlockSizes.h"
 
-StepWriteXBlockSizes::StepWriteXBlockSizes(Zone* zone)
+StepWriteXBlockSizes::StepWriteXBlockSizes(const Zone& zone)
     : m_zone(zone)
 {
 }

src/ZoneWriting/Writing/Steps/StepWriteXBlockSizes.h

@@ -4,10 +4,11 @@
 
 class StepWriteXBlockSizes final : public IWritingStep
 {
-    Zone* m_zone;
-
 public:
-    explicit StepWriteXBlockSizes(Zone* zone);
+    explicit StepWriteXBlockSizes(const Zone& zone);
 
     void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
+
+private:
+    const Zone& m_zone;
 };

src/ZoneWriting/Writing/Steps/StepWriteZoneContentToMemory.cpp

@@ -3,9 +3,9 @@
 #include "Zone/Stream/Impl/InMemoryZoneOutputStream.h"
 
 StepWriteZoneContentToMemory::StepWriteZoneContentToMemory(std::unique_ptr<IContentWritingEntryPoint> entryPoint,
-                                                           Zone* zone,
-                                                           int offsetBlockBitCount,
-                                                           block_t insertBlock)
+                                                           const Zone& zone,
+                                                           const int offsetBlockBitCount,
+                                                           const block_t insertBlock)
     : m_content_loader(std::move(entryPoint)),
       m_zone_data(std::make_unique<InMemoryZoneData>()),
       m_zone(zone),
@@ -17,11 +17,12 @@ StepWriteZoneContentToMemory::StepWriteZoneContentToMemory(std::unique_ptr<ICont
 void StepWriteZoneContentToMemory::PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream)
 {
     std::vector<XBlock*> blocks;
+    blocks.reserve(zoneWriter->m_blocks.size());
     for (const auto& block : zoneWriter->m_blocks)
-        blocks.push_back(block.get());
+        blocks.emplace_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());
+    m_content_loader->WriteContent(*zoneOutputStream);
 }
 
 InMemoryZoneData* StepWriteZoneContentToMemory::GetData() const

src/ZoneWriting/Writing/Steps/StepWriteZoneContentToMemory.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "Utils/ClassUtils.h"
 #include "Writing/IContentWritingEntryPoint.h"
 #include "Writing/IWritingStep.h"
 #include "Writing/InMemoryZoneData.h"
@@ -9,15 +8,16 @@
 
 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);
+    StepWriteZoneContentToMemory(std::unique_ptr<IContentWritingEntryPoint> entryPoint, const Zone& zone, int offsetBlockBitCount, block_t insertBlock);
 
     void PerformStep(ZoneWriter* zoneWriter, IWritingStream* stream) override;
-    _NODISCARD InMemoryZoneData* GetData() const;
+    [[nodiscard]] InMemoryZoneData* GetData() const;
+
+private:
+    std::unique_ptr<IContentWritingEntryPoint> m_content_loader;
+    std::unique_ptr<InMemoryZoneData> m_zone_data;
+    const Zone& m_zone;
+    int m_offset_block_bit_count;
+    block_t m_insert_block;
 };