AuroraRuntime/Source/Compression/CompressionInterceptor.cpp

/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: CompressionInterceptor.cpp
    Date: 2022-9-14
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "Compression.hpp"
#include "BaseStream.hpp"
#include "CompressionInterceptor.hpp"

namespace Aurora::Compression
{
    CompressionInterceptor::CompressionInterceptor()
    {
        
    }

    void CompressionInterceptor::Init(const AuSPtr<ICompressionStream> &pStream,
                                      const AuSPtr<BaseStream> &pBaseStream)
    {
        this->pBaseStream_ = pBaseStream;
        this->pStream_ = pStream;
    }
    
    IO::EStreamError CompressionInterceptor::IsOpen()
    {
        return IO::EStreamError::eErrorNone;
    }

    IO::EStreamError CompressionInterceptor::Read(const Memory::MemoryViewStreamWrite &parameters)
    {
        auto uRemainingBytes = AuMin(this->uCount_ + parameters.length,
                                     this->uCountMax_);

        parameters.outVariable = pLastBuffer_->Read(parameters.ptr, uRemainingBytes);
        this->uCount_ += parameters.outVariable;
        return parameters.outVariable == 0 ? IO::EStreamError::eErrorEndOfStream : IO::EStreamError::eErrorNone;
    }

    void CompressionInterceptor::Close()
    {
    }

    bool CompressionInterceptor::HasFailed()
    {
        return this->bErrorFlag_;
    }

    bool CompressionInterceptor::OnDataAvailable(const AuSPtr<Memory::ByteBuffer> &pReadInByteBuffer,
                                                 const AuSPtr<Memory::ByteBuffer> &pWriteOutByteBuffer)
    {
        this->pLastBuffer_ = pReadInByteBuffer;
        this->pBaseStream_->SetBuffer(pWriteOutByteBuffer);

        bool bSuccess { true };
        do
        {
            auto uReadable = pReadInByteBuffer->RemainingBytes();
            if (!uReadable)
            {
                break;
            }

            auto [a, b] = this->pBaseStream_->Ingest(uReadable);
            bSuccess = a != 0;
        }
        while (bSuccess);

        if (this->LimitHasHit())
        {
            return pWriteOutByteBuffer->WriteFromEx(*pReadInByteBuffer, AuNumericLimits<AuUInt>::max()); // intentionally non-ex.
        }

        if (!bSuccess)
        {
            this->bErrorFlag_ = true;
        }

        this->pBaseStream_->SetBuffer({});
        return true;
    }

    bool CompressionInterceptor::LimitHasHit()
    {
        return this->uCount_ >= this->uCountMax_;
    }

    void CompressionInterceptor::LimitReset()
    {
        this->uCount_ = 0;
        this->uCountMax_ = 0;
    }

    AuUInt CompressionInterceptor::LimitGetIndex()
    {
        return this->uCount_;
    }

    void CompressionInterceptor::LimitSet(AuUInt uLength)
    {
        this->uCountMax_ = uLength;
    }

    AUKN_SYM AuSPtr<ICompressionInterceptor> NewDecompressionInterceptor(const DecompressInfo &info)
    {
        auto pInterceptor = AuMakeShared<CompressionInterceptor>();
        if (!pInterceptor)
        {
            SysPushErrorMemory();
            return {};
        }

        auto pDecompressor = DecompressorShared(AuUnsafeRaiiToShared(pInterceptor.get()),
                                                info);
        if (!pDecompressor)
        {
            SysPushErrorMemory();
            return {};
        }

        pInterceptor->Init(pDecompressor,
                           AuStaticCast<Compression::BaseStream>(pDecompressor));

        return pInterceptor;
    }
    
    AUKN_SYM AuSPtr<ICompressionInterceptor> NewCompressionInterceptor(const CompressInfo &info)
    {
        auto pInterceptor = AuMakeShared<CompressionInterceptor>();
        if (!pInterceptor)
        {
            SysPushErrorMemory();
            return {};
        }

        auto pCompressor = CompressorShared(AuUnsafeRaiiToShared(pInterceptor.get()),
                                            info);
        if (!pCompressor)
        {
            SysPushErrorMemory();
            return {};
        }
        
        pInterceptor->Init(pCompressor,
                           AuStaticCast<Compression::BaseStream>(pCompressor));

        return pInterceptor;
    }
}