zlib_base_stream.h

 
#pragma once
 
#include <system/io/stream.h>
#include <system/io/seekorigin.h>
#include <array>
 
#include <system/io/compression/details/zlib_codec.h>
#include <system/io/compression/details/zlib_constants.h>
#include <system/io/compression/details/crc32.h>
 
namespace Aspose { namespace Zip {
 
class ASPOSECPP_SHARED_CLASS ZlibBaseStream : public System::IO::Stream
{
    RTTI_INFO(Aspose::Zip::ZlibBaseStream, ::System::BaseTypesInfo<System::IO::Stream>);
 
public:
    typedef System::SharedPtr<ZlibBaseStream> Ptr;
 
    ZlibBaseStream() = delete;
    ZlibBaseStream(const ZlibBaseStream&) = delete;
 
    ASPOSECPP_SHARED_API ZlibBaseStream(const System::IO::Stream::Ptr& stream, CompressionMode mode,
                                        CompressionLevel level, ZlibStreamFlavor flavor, bool leaveOpen,
                                        bool initNow = true);
 
    virtual ASPOSECPP_SHARED_API ~ZlibBaseStream();
 
    virtual ASPOSECPP_SHARED_API FlushType get_FlushMode() const;
    virtual ASPOSECPP_SHARED_API void set_FlushMode(FlushType value);
 
    virtual ASPOSECPP_SHARED_API int get_BufferSize();
    virtual ASPOSECPP_SHARED_API void set_BufferSize(int value);
 
    virtual ASPOSECPP_SHARED_API CompressionStrategy get_Strategy() const;
    virtual ASPOSECPP_SHARED_API void set_Strategy(CompressionStrategy value);
 
    virtual ASPOSECPP_SHARED_API int64_t get_TotalIn();
    virtual ASPOSECPP_SHARED_API int64_t get_TotalOut();
 
    ASPOSECPP_SHARED_API bool get_CanRead() const override;
    ASPOSECPP_SHARED_API bool get_CanSeek() const override;
    ASPOSECPP_SHARED_API bool get_CanWrite() const override;
    ASPOSECPP_SHARED_API int64_t get_Length() const override;
    ASPOSECPP_SHARED_API int64_t get_Position() const override;
    ASPOSECPP_SHARED_API void set_Position(int64_t value) override;
    ASPOSECPP_SHARED_API void Close() override;
    ASPOSECPP_SHARED_API void Flush() override;
    ASPOSECPP_SHARED_API int32_t Read(const System::ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API int64_t Seek(int64_t offset, System::IO::SeekOrigin origin) override;
    ASPOSECPP_SHARED_API void SetLength(int64_t value) override;
    ASPOSECPP_SHARED_API void Write(const System::ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
 
    static ASPOSECPP_SHARED_API int FlavorToWinBits(ZlibStreamFlavor flavor);
 
protected:
   
    ZlibCodec::Ptr m_codec;
    Stream::Ptr m_stream;
    CompressionMode m_mode;
    CompressionLevel m_level;
    ZlibStreamFlavor m_flavor;
    bool m_leaveOpen;
    FlushType m_flushType;
    CompressionStrategy m_strategy;
    CRC32::Ptr m_crc32;
    int m_bufferSize;
    System::ByteArrayPtr m_buffer;
 
    ASPOSECPP_SHARED_API bool IsCompress() const;
    static ASPOSECPP_SHARED_API System::ByteArrayPtr CompressString(const System::String& str, ZlibStreamFlavor flavor);
    static ASPOSECPP_SHARED_API System::ByteArrayPtr CompressBuffer(const System::ByteArrayPtr& buffer, ZlibStreamFlavor flavor);
    static ASPOSECPP_SHARED_API System::String UncompressString(const System::ByteArrayPtr& compressed, ZlibStreamFlavor flavor);
    static ASPOSECPP_SHARED_API System::ByteArrayPtr UncompressBuffer(const System::ByteArrayPtr& compressed, ZlibStreamFlavor flavor);
    virtual void OnUpdateCodec(const ZlibCodec::Ptr& current_codec, const ZlibCodec::Ptr& new_codec)
    {
        ASPOSE_UNUSED(current_codec);
        ASPOSE_UNUSED(new_codec);
    }
 
private:
    void UpdateCodec();
    void Init();
    void SoftFinish() const /*noexcept*/;
 
};
 
}} // namespace Aspose::Zip