refactor: merge ZoneInputStream interface with only implementation

src/ZoneLoading/Loading/AssetLoader.cpp

@@ -3,7 +3,7 @@
 #include <algorithm>
 #include <cassert>
 
-AssetLoader::AssetLoader(const asset_type_t assetType, Zone& zone, IZoneInputStream* stream)
+AssetLoader::AssetLoader(const asset_type_t assetType, Zone& zone, ZoneInputStream& stream)
     : ContentLoaderBase(zone, stream),
       varScriptString(nullptr),
       m_asset_type(assetType)

src/ZoneLoading/Loading/AssetLoader.h

@@ -9,7 +9,7 @@
 class AssetLoader : public ContentLoaderBase
 {
 protected:
-    AssetLoader(asset_type_t assetType, Zone& zone, IZoneInputStream* stream);
+    AssetLoader(asset_type_t assetType, Zone& zone, ZoneInputStream& stream);
 
     XAssetInfoGeneric* LinkAsset(std::string name,
                                  void* asset,

src/ZoneLoading/Loading/ContentLoaderBase.cpp

@@ -10,11 +10,11 @@ ContentLoaderBase::ContentLoaderBase(Zone& zone)
 {
 }
 
-ContentLoaderBase::ContentLoaderBase(Zone& zone, IZoneInputStream* stream)
+ContentLoaderBase::ContentLoaderBase(Zone& zone, ZoneInputStream& stream)
     : varXString(nullptr),
       m_zone(zone),
       m_memory(zone.Memory()),
-      m_stream(stream)
+      m_stream(&stream)
 {
 }
 

src/ZoneLoading/Loading/ContentLoaderBase.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Zone/Stream/IZoneInputStream.h"
+#include "Zone/Stream/ZoneInputStream.h"
 #include "Zone/Zone.h"
 
 class ContentLoaderBase
@@ -18,7 +18,7 @@ public:
 
 protected:
     explicit ContentLoaderBase(Zone& zone);
-    ContentLoaderBase(Zone& zone, IZoneInputStream* stream);
+    ContentLoaderBase(Zone& zone, ZoneInputStream& stream);
 
     void LoadXString(bool atStreamStart) const;
     void LoadXStringArray(bool atStreamStart, size_t count);
@@ -27,5 +27,5 @@ protected:
 
     Zone& m_zone;
     MemoryManager& m_memory;
-    IZoneInputStream* m_stream;
+    ZoneInputStream* m_stream;
 };

src/ZoneLoading/Loading/IContentLoadingEntryPoint.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Zone/Stream/IZoneInputStream.h"
+#include "Zone/Stream/ZoneInputStream.h"
 
 class IContentLoadingEntryPoint
 {
@@ -12,5 +12,5 @@ public:
     IContentLoadingEntryPoint& operator=(const IContentLoadingEntryPoint& other) = default;
     IContentLoadingEntryPoint& operator=(IContentLoadingEntryPoint&& other) noexcept = default;
 
-    virtual void Load(IZoneInputStream* stream) = 0;
+    virtual void Load(ZoneInputStream& stream) = 0;
 };

src/ZoneLoading/Loading/ILoadingStep.h

@@ -15,5 +15,5 @@ public:
     ILoadingStep& operator=(const ILoadingStep& other) = default;
     ILoadingStep& operator=(ILoadingStep&& other) noexcept = default;
 
-    virtual void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) = 0;
+    virtual void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) = 0;
 };

src/ZoneLoading/Loading/Steps/StepAddProcessor.cpp

@@ -7,11 +7,10 @@ StepAddProcessor::StepAddProcessor(std::unique_ptr<StreamProcessor> streamProces
 {
 }
 
-void StepAddProcessor::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepAddProcessor::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    assert(zoneLoader != nullptr);
     assert(m_stream_processor != nullptr);
 
-    zoneLoader->AddStreamProcessor(std::move(m_stream_processor));
+    zoneLoader.AddStreamProcessor(std::move(m_stream_processor));
     m_stream_processor = nullptr;
 }

src/ZoneLoading/Loading/Steps/StepAddProcessor.h

@@ -9,7 +9,7 @@ class StepAddProcessor final : public ILoadingStep
 public:
     explicit StepAddProcessor(std::unique_ptr<StreamProcessor> streamProcessor);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     std::unique_ptr<StreamProcessor> m_stream_processor;

src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp

@@ -7,12 +7,12 @@ namespace
     constexpr uint64_t MAX_XBLOCK_SIZE = 0x3C000000;
 }
 
-void StepAllocXBlocks::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepAllocXBlocks::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    const auto blockCount = static_cast<unsigned>(zoneLoader->m_blocks.size());
+    const auto blockCount = static_cast<unsigned>(zoneLoader.m_blocks.size());
 
     const auto blockSizes = std::make_unique<xblock_size_t[]>(blockCount);
-    stream->Load(blockSizes.get(), sizeof(xblock_size_t) * blockCount);
+    stream.Load(blockSizes.get(), sizeof(xblock_size_t) * blockCount);
 
     uint64_t totalMemory = 0;
     for (unsigned int block = 0; block < blockCount; block++)
@@ -27,6 +27,6 @@ void StepAllocXBlocks::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* strea
 
     for (unsigned int block = 0; block < blockCount; block++)
     {
-        zoneLoader->m_blocks[block]->Alloc(blockSizes[block]);
+        zoneLoader.m_blocks[block]->Alloc(blockSizes[block]);
     }
 }

src/ZoneLoading/Loading/Steps/StepAllocXBlocks.h

@@ -5,5 +5,5 @@
 class StepAllocXBlocks final : public ILoadingStep
 {
 public:
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 };

src/ZoneLoading/Loading/Steps/StepDumpData.cpp

@@ -7,7 +7,7 @@ StepDumpData::StepDumpData(const size_t dumpCount)
 {
 }
 
-void StepDumpData::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepDumpData::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
     uint8_t tempBuffer[128];
     auto dumpedBytes = 0uz;
@@ -27,7 +27,7 @@ void StepDumpData::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
             toDump = sizeof(tempBuffer);
         }
 
-        const auto loadedSize = stream->Load(tempBuffer, toDump);
+        const auto loadedSize = stream.Load(tempBuffer, toDump);
         dumpedBytes += loadedSize;
 
         if (loadedSize == 0)

src/ZoneLoading/Loading/Steps/StepDumpData.h

@@ -7,7 +7,7 @@ class StepDumpData final : public ILoadingStep
 public:
     explicit StepDumpData(size_t dumpCount);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     size_t m_dump_count;

src/ZoneLoading/Loading/Steps/StepLoadHash.cpp

@@ -13,11 +13,9 @@ StepLoadHash::StepLoadHash(const size_t hashSize, const unsigned hashCount)
 
 StepLoadHash::~StepLoadHash() = default;
 
-void StepLoadHash::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepLoadHash::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    assert(stream != nullptr);
-
-    if (stream->Load(m_hashes.get(), m_hash_size * m_hash_count) != m_hash_size * m_hash_count)
+    if (stream.Load(m_hashes.get(), m_hash_size * m_hash_count) != m_hash_size * m_hash_count)
         throw UnexpectedEndOfFileException();
 }
 

src/ZoneLoading/Loading/Steps/StepLoadHash.h

@@ -18,7 +18,7 @@ public:
     StepLoadHash& operator=(const StepLoadHash& other) = delete;
     StepLoadHash& operator=(StepLoadHash&& other) noexcept = delete;
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
     void GetHash(unsigned hashIndex, const uint8_t** pHash, size_t* pSize) override;
     void GetCapturedData(const uint8_t** pCapturedData, size_t* pSize) override;
 

src/ZoneLoading/Loading/Steps/StepLoadSignature.cpp

@@ -10,11 +10,9 @@ StepLoadSignature::StepLoadSignature(const size_t signatureSize)
 {
 }
 
-void StepLoadSignature::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepLoadSignature::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    assert(stream != nullptr);
-
-    if (stream->Load(m_signature.get(), m_signature_size) != m_signature_size)
+    if (stream.Load(m_signature.get(), m_signature_size) != m_signature_size)
         throw UnexpectedEndOfFileException();
 }
 

src/ZoneLoading/Loading/Steps/StepLoadSignature.h

@@ -10,7 +10,7 @@ class StepLoadSignature final : public ILoadingStep, public ISignatureProvider
 public:
     explicit StepLoadSignature(size_t signatureSize);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
     void GetSignature(const uint8_t** pSignature, size_t* pSize) override;
 
 private:

src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp

@@ -1,6 +1,6 @@
 #include "StepLoadZoneContent.h"
 
-#include "Zone/Stream/Impl/XBlockInputStream.h"
+#include "Zone/Stream/ZoneInputStream.h"
 
 StepLoadZoneContent::StepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint,
                                          Zone* zone,
@@ -13,9 +13,9 @@ StepLoadZoneContent::StepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoi
 {
 }
 
-void StepLoadZoneContent::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepLoadZoneContent::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    const auto inputStream = std::make_unique<XBlockInputStream>(zoneLoader->m_blocks, stream, m_offset_block_bit_count, m_insert_block);
+    const auto inputStream = ZoneInputStream::Create(zoneLoader.m_blocks, stream, m_offset_block_bit_count, m_insert_block);
 
-    m_content_loader->Load(inputStream.get());
+    m_content_loader->Load(*inputStream);
 }

src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h

@@ -10,7 +10,7 @@ class StepLoadZoneContent final : public ILoadingStep
 public:
     StepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint, Zone* zone, int offsetBlockBitCount, block_t insertBlock);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     std::unique_ptr<IContentLoadingEntryPoint> m_content_loader;

src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.cpp

@@ -6,10 +6,10 @@ StepLoadZoneSizes::StepLoadZoneSizes()
 {
 }
 
-void StepLoadZoneSizes::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepLoadZoneSizes::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    stream->Load(&m_size, sizeof(m_size));
-    stream->Load(&m_external_size, sizeof(m_external_size));
+    stream.Load(&m_size, sizeof(m_size));
+    stream.Load(&m_external_size, sizeof(m_external_size));
 }
 
 size_t StepLoadZoneSizes::GetSize() const

src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.h

@@ -9,7 +9,7 @@ class StepLoadZoneSizes final : public ILoadingStep
 public:
     StepLoadZoneSizes();
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
     [[nodiscard]] size_t GetSize() const;
     [[nodiscard]] size_t GetExternalSize() const;

src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp

@@ -7,10 +7,9 @@ StepRemoveProcessor::StepRemoveProcessor(StreamProcessor* streamProcessor)
 {
 }
 
-void StepRemoveProcessor::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepRemoveProcessor::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
-    assert(zoneLoader != nullptr);
     assert(m_stream_processor != nullptr);
 
-    zoneLoader->RemoveStreamProcessor(m_stream_processor);
+    zoneLoader.RemoveStreamProcessor(m_stream_processor);
 }

src/ZoneLoading/Loading/Steps/StepRemoveProcessor.h

@@ -7,7 +7,7 @@ class StepRemoveProcessor final : public ILoadingStep
 public:
     explicit StepRemoveProcessor(StreamProcessor* streamProcessor);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     StreamProcessor* m_stream_processor;

src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp

@@ -5,7 +5,7 @@ StepSkipBytes::StepSkipBytes(const size_t skipCount)
 {
 }
 
-void StepSkipBytes::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepSkipBytes::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
     uint8_t tempBuffer[128];
     auto skippedBytes = 0uz;
@@ -23,7 +23,7 @@ void StepSkipBytes::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
             toSkip = sizeof(tempBuffer);
         }
 
-        stream->Load(tempBuffer, toSkip);
+        stream.Load(tempBuffer, toSkip);
 
         skippedBytes += toSkip;
     }

src/ZoneLoading/Loading/Steps/StepSkipBytes.h

@@ -7,7 +7,7 @@ class StepSkipBytes final : public ILoadingStep
 public:
     explicit StepSkipBytes(size_t skipCount);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     size_t m_skip_count;

src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp

@@ -12,7 +12,7 @@ StepVerifyFileName::StepVerifyFileName(std::string fileName, const size_t fileNa
         m_expected_file_name.erase(m_file_name_buffer_size - 1);
 }
 
-void StepVerifyFileName::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepVerifyFileName::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
     std::stringstream originalFilenameStream;
     unsigned bufferOffset = 0;
@@ -20,8 +20,7 @@ void StepVerifyFileName::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* str
 
     for (; bufferOffset < m_file_name_buffer_size; bufferOffset++)
     {
-
-        stream->Load(&c, sizeof(char));
+        stream.Load(&c, sizeof(char));
 
         if (c == '\00')
         {
@@ -35,7 +34,7 @@ void StepVerifyFileName::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* str
     // Skip the rest of the buffer which should be null bytes
     while (bufferOffset < m_file_name_buffer_size)
     {
-        stream->Load(&c, sizeof(char));
+        stream.Load(&c, sizeof(char));
         bufferOffset++;
     }
 

src/ZoneLoading/Loading/Steps/StepVerifyFileName.h

@@ -7,7 +7,7 @@ class StepVerifyFileName final : public ILoadingStep
 public:
     explicit StepVerifyFileName(std::string fileName, size_t fileNameBufferSize);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     std::string m_expected_file_name;

src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp

@@ -16,7 +16,7 @@ StepVerifyHash::StepVerifyHash(std::unique_ptr<cryptography::IHashFunction> hash
 {
 }
 
-void StepVerifyHash::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepVerifyHash::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
     const uint8_t* dataToHash = nullptr;
     size_t dataToHashSize = 0;

src/ZoneLoading/Loading/Steps/StepVerifyHash.h

@@ -15,7 +15,7 @@ public:
                    IHashProvider* hashProvider,
                    ICapturedDataProvider* dataProvider);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     std::unique_ptr<cryptography::IHashFunction> m_hash_function;

src/ZoneLoading/Loading/Steps/StepVerifyMagic.cpp

@@ -10,13 +10,13 @@ StepVerifyMagic::StepVerifyMagic(const char* magic)
     m_magic_len = strlen(m_magic);
 }
 
-void StepVerifyMagic::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepVerifyMagic::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
     char currentCharacter;
 
     for (unsigned i = 0; i < m_magic_len; i++)
     {
-        stream->Load(&currentCharacter, sizeof(char));
+        stream.Load(&currentCharacter, sizeof(char));
 
         if (currentCharacter != m_magic[i])
             throw InvalidMagicException(m_magic);

src/ZoneLoading/Loading/Steps/StepVerifyMagic.h

@@ -7,7 +7,7 @@ class StepVerifyMagic final : public ILoadingStep
 public:
     explicit StepVerifyMagic(const char* magic);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     const char* m_magic;

src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp

@@ -13,7 +13,7 @@ StepVerifySignature::StepVerifySignature(std::unique_ptr<cryptography::IPublicKe
 {
 }
 
-void StepVerifySignature::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+void StepVerifySignature::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
 {
     assert(m_algorithm != nullptr);
     assert(m_signature_provider != nullptr);

src/ZoneLoading/Loading/Steps/StepVerifySignature.h

@@ -12,7 +12,7 @@ public:
                         ISignatureProvider* signatureProvider,
                         ICapturedDataProvider* signatureDataProvider);
 
-    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
 
 private:
     std::unique_ptr<cryptography::IPublicKeyAlgorithm> m_algorithm;

src/ZoneLoading/Loading/ZoneLoader.cpp

@@ -4,6 +4,9 @@
 #include "LoadingFileStream.h"
 
 #include <algorithm>
+#include <cassert>
+#include <format>
+#include <iostream>
 
 ZoneLoader::ZoneLoader(std::unique_ptr<Zone> zone)
     : m_processor_chain_dirty(false),
@@ -31,7 +34,7 @@ void ZoneLoader::AddXBlock(std::unique_ptr<XBlock> block)
     m_blocks.push_back(block.get());
 
     std::ranges::sort(m_blocks,
-                      [](XBlock* b1, XBlock* b2) -> bool
+                      [](const XBlock* b1, const XBlock* b2) -> bool
                       {
                           return b1->m_index < b2->m_index;
                       });
@@ -50,7 +53,7 @@ void ZoneLoader::AddStreamProcessor(std::unique_ptr<StreamProcessor> streamProce
     m_processor_chain_dirty = true;
 }
 
-void ZoneLoader::RemoveStreamProcessor(StreamProcessor* streamProcessor)
+void ZoneLoader::RemoveStreamProcessor(const StreamProcessor* streamProcessor)
 {
     for (auto i = m_processors.begin(); i < m_processors.end(); ++i)
     {
@@ -67,23 +70,24 @@ std::unique_ptr<Zone> ZoneLoader::LoadZone(std::istream& stream)
 {
     LoadingFileStream fileStream(stream);
     auto* endStream = BuildLoadingChain(&fileStream);
+    assert(endStream);
 
     try
     {
         for (const auto& step : m_steps)
         {
-            step->PerformStep(this, endStream);
+            step->PerformStep(*this, *endStream);
 
             if (m_processor_chain_dirty)
             {
                 endStream = BuildLoadingChain(&fileStream);
+                assert(endStream);
             }
         }
     }
     catch (LoadingException& e)
     {
-        const auto detailedMessage = e.DetailedMessage();
-        printf("Loading fastfile failed: %s\n", detailedMessage.c_str());
+        std::cerr << std::format("Loading fastfile failed: {}\n", e.DetailedMessage());
 
         return nullptr;
     }

src/ZoneLoading/Loading/ZoneLoader.h

@@ -20,7 +20,7 @@ public:
     void AddLoadingStep(std::unique_ptr<ILoadingStep> step);
     void AddStreamProcessor(std::unique_ptr<StreamProcessor> streamProcessor);
 
-    void RemoveStreamProcessor(StreamProcessor* streamProcessor);
+    void RemoveStreamProcessor(const StreamProcessor* streamProcessor);
 
     std::unique_ptr<Zone> LoadZone(std::istream& stream);