brotli_stream.h

 
#pragma once
 
#include <system/exceptions.h>
#include <system/io/stream.h>
#include <system/io/compression/compression_level.h>
#include <system/io/compression/compression_mode.h>
 
//#include <system/io/compression/details/flush_type.h>
 
namespace Aspose { namespace Brotli {
 
class ASPOSECPP_SHARED_CLASS BrotliStream final : public System::IO::Stream
{
    RTTI_INFO(Aspose::Brotli::BrotliStream, ::System::BaseTypesInfo<System::IO::Stream>);
 
public:
    typedef System::SharedPtr<BrotliStream> Ptr;
 
    static ASPOSECPP_SHARED_API System::ArrayPtr<uint8_t> CompressBuffer(const System::ArrayPtr<uint8_t>& b);
    static ASPOSECPP_SHARED_API size_t UncompressBuffer(const System::ArrayPtr<uint8_t>& compressed,
                                                        System::ArrayPtr<uint8_t>& destination);
    BrotliStream() = delete;
    BrotliStream(const BrotliStream&) = delete;
 
    ASPOSECPP_SHARED_API BrotliStream(const System::IO::Stream::Ptr& stream,
                                      System::IO::Compression::CompressionMode mode);
    ASPOSECPP_SHARED_API BrotliStream(const System::IO::Stream::Ptr& stream,
                                      System::IO::Compression::CompressionMode mode, bool leaveOpen);
    ASPOSECPP_SHARED_API BrotliStream(const System::IO::Stream::Ptr& stream,
                                      System::IO::Compression::CompressionLevel level, bool leaveOpen = false);
    ASPOSECPP_SHARED_API BrotliStream(const System::IO::Stream::Ptr& stream,
                                      System::IO::Compression::CompressionMode mode,
                                      System::IO::Compression::CompressionLevel level, bool leaveOpen = false);
 
    ASPOSECPP_SHARED_API ~BrotliStream();
 
    ASPOSECPP_SHARED_API int32_t Read(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::ArrayPtr<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;
    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 Flush() override;
 
    ASPOSECPP_SHARED_API System::StreamPtr get_BaseStream() const;
    ASPOSECPP_SHARED_API bool get_CanSeek() const override;
    ASPOSECPP_SHARED_API bool get_CanRead() const override;
    ASPOSECPP_SHARED_API bool get_CanWrite() const override;
    ASPOSECPP_SHARED_API void set_Position(int64_t value) override;
    ASPOSECPP_SHARED_API int64_t get_Position() const override;
    ASPOSECPP_SHARED_API int64_t get_Length() const override;
    ASPOSECPP_SHARED_API void SetQuality(int quality);
    ASPOSECPP_SHARED_API void SetMode(int mode);
    ASPOSECPP_SHARED_API void SetWindow(int windowSize);
    ASPOSECPP_SHARED_API void Close() override;
 
private:
    Stream::Ptr m_stream;
    System::IO::Compression::CompressionMode m_mode;
    System::IO::Compression::CompressionLevel m_level;
    System::ByteArrayPtr m_buffer = nullptr;
    int m_bufferOffset = 0;
    int m_bufferCount = 0;
    bool m_leaveOpen;
    bool m_disposed;
    int m_lastDecoderState;
    std::unique_ptr<void, std::function<const void(void*)>> m_encoderState;
    std::unique_ptr<void, std::function<const void(void*)>> m_decoderState;
 
    void Dispose(bool disposing) override;
    void EnsureNotDisposed();
    void ValidateParameters(System::Details::ArrayView<uint8_t> buffer, int offset, int count);
    void FlushCompress(bool finish);
    void WriteCore(const System::ArrayPtr<uint8_t>& buffer, int offset, int count, int operation);
    void WriteCore(System::Details::ArrayView<uint8_t> buffer, int offset, int count, int operation);
    int QualityFromCompressionLevel(System::IO::Compression::CompressionLevel level);
};
 
}} // namespace Aspose::Brotli