Expose ZlibCompressor/Decompressor (#10)

* Expose ZlibCompressor and make it non-Copyable

* Use latest swift image in api-breakage.yml

* Make ZlibAlgorithm sendable

* Update package.swift

* Revert ZlibCompressor/Decompressor back to a class

Also clean up interface so when they are allocated they are active already, instead of having non-initialized state

* Add finishWindowedStream back in and deprecate it

* Update README

Author: adam-fowler

.github/workflows/api-breakage.yml

@@ -8,7 +8,7 @@ jobs:
   linux:
     runs-on: ubuntu-latest
     container:
-      image: swift:5.7
+      image: swift:latest
     steps:
     - name: Checkout
       uses: actions/checkout@v3

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: macOS-latest
     steps: 
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: SPM tests
       run: swift test --enable-code-coverage --parallel
     - name: Convert coverage files
@@ -34,14 +34,14 @@ jobs:
     strategy:
       matrix:
         image:
-          - 'swift:5.7'
-          - 'swift:5.8'
           - 'swift:5.9'
+          - 'swift:5.10'
+          - 'swift:6.0'
     container:
       image: ${{ matrix.image }}
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
     - name: Test
       run: |
         swift --version

Package.swift

@@ -1,8 +1,9 @@
-// swift-tools-version:5.7
+// swift-tools-version:5.9
 import PackageDescription
 
 let package = Package(
     name: "compress-nio",
+    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13)],
     products: [
         .library(name: "CompressNIO", targets: ["CompressNIO"]),
     ],

README.md

@@ -11,13 +11,12 @@ var uncompressedBuffer = buffer.decompress(with: .gzip)
 These methods allocate a new `ByteBuffer` for you. The `decompress` method can allocate multiple `ByteBuffers` while it is uncompressing depending on how well compressed the original `ByteBuffer` is. It is preferable to know in advance the size of buffer you need and allocate it yourself just the once and use the following functions.
 ```swift
 let uncompressedSize = buffer.readableBytes
-let maxCompressedSize = CompressionAlgorithm.deflate.compressor.maxSize(from:buffer)
-var compressedBuffer = ByteBufferAllocator().buffer(capacity: maxCompressedSize)
+var compressedBuffer = ByteBufferAllocator().buffer(capacity: knownCompressedSize)
 try buffer.compress(to: &compressedBuffer, with: .deflate)
 var uncompressedBuffer = ByteBufferAllocator().buffer(capacity: uncompressedSize)
 try compressedBuffer.decompress(to: &uncompressedBuffer, with: .deflate)
 ```
-In the above example there is a call to a function `CompressionAlgorithm.deflate.compressor.maxSize(from:buffer)`. This returns the maximum size of buffer required to write out compressed data for the `deflate` compression algorithm.
+This returns the maximum size of buffer required to write out compressed data for the `deflate` compression algorithm.
 
 If you provide a buffer that is too small a `CompressNIO.bufferOverflow` error is thrown. You will need to provide a larger `ByteBuffer` to complete your operation.
 
@@ -31,29 +30,29 @@ There are three methods for doing stream compressing: window, allocating and raw
 #### Window method
 For the window method you provide a working buffer for the compressor to use. When you call `compressStream` it compresses into this buffer and when the buffer is full it will call a `process` closure you have provided.
 ```swift
-let compressor = CompressionAlgorithm.gzip.compressor
-compressor.window = ByteBufferAllocator().buffer(capacity: 64*1024)
-try compressor.startStream()
+let compressor = ZlibCompressor(algorithm: .gzip)
+var window = ByteBufferAllocator().buffer(capacity: 64*1024)
 while var buffer = getData() {
-    try buffer.compressStream(with: compressor, flush: .finish) { buffer in
+    try buffer.compressStream(with: compressor, window: window, flush: .finish) { buffer in
         // process your compressed data
     }
 }
-try compressor.finishStream()
+try compressor.reset()
 ```
 #### Allocation method
 With the allocating method you leave the compressor to allocate the ByteBuffers for output data. It will calculate the maximum possible size the compressed data could be and allocates that amount of space for each compressed data block. The last compressed block needs to have the `flush` parameter set to `.finish`
 ```swift
-let compressor = CompressionAlgorithm.gzip.compressor
-try compressor.startStream()
+let compressor = ZlibCompressor(algorithm: .gzip)
 while var buffer = getData() {
     let flush: CompressNIOFlush = isThisTheFinalBlock ? .finish : .sync
     let compressedBuffer = try buffer.compressStream(with: compressor, flush: flush, allocator: ByteBufferAllocator())
 }
-try compressor.finishStream()
+try compressor.reset()
 ```
-If you don't know when you are receiving your last data block you can always compress an empty `ByteBuffer` with the `flush` set to `.finish` to get your final block. Also note that the flush parameter is set to `.sync` in the loop. This is required otherwise the next `compressStream` cannot successfully estimate its buffer size as there might be buffered data still waiting to be output.
+If you don't know what is your final data block you can always compress an empty `ByteBuffer` with the `flush` set to `.finish` to get your final block. Also note that the flush parameter is set to `.sync` in the loop. This is required otherwise the next `compressStream` cannot successfully estimate its buffer size as there might be buffered data still waiting to be output.
+
 #### Raw method
+
 With this mehod you call the lowest level function and deal with `.bufferOverflow` errors thrown whenever you run out of space in your output buffer. You will need a loop for receiving data and then you will need an inner loop for compressing that data. You call the `compress` until you have no more data to compress. Everytime you receive a `.bufferOverflow` error you have to provide a new output data. Once you have read all the input data you do the same again but with the `flush` parameter set to `.finish`.
 
 ## Decompressing

Sources/CompressNIO/ByteBuffer+compress.swift

@@ -25,8 +25,9 @@ extension ByteBuffer {
         allocator: ByteBufferAllocator = ByteBufferAllocator()
     ) throws -> ByteBuffer {
         let compressor = algorithm.compressor
+        try compressor.startStream()
         var buffer = allocator.buffer(capacity: compressor.maxSize(from: self))
-        try compressor.deflate(from: &self, to: &buffer)
+        try compressor.streamDeflate(from: &self, to: &buffer, flush: .finish)
         return buffer
     }
 

Sources/CompressNIO/CompressionAlgorithm.swift

@@ -23,14 +23,12 @@ public struct CompressionAlgorithm: CustomStringConvertible, Sendable {
     /// - Parameter windowSize: Window size to use in compressor. Window size is 2^windowSize
     public var compressor: NIOCompressor {
         switch self.algorithm {
-        case .gzip(var configuration):
-            configuration.windowSize = 16 + configuration.windowSize
-            return ZlibCompressor(configuration: configuration)
+        case .gzip(let configuration):
+            return ZlibCompressorWrapper(configuration: configuration, algorithm: .gzip)
         case .zlib(let configuration):
-            return ZlibCompressor(configuration: configuration)
-        case .deflate(var configuration):
-            configuration.windowSize = -configuration.windowSize
-            return ZlibCompressor(configuration: configuration)
+            return ZlibCompressorWrapper(configuration: configuration, algorithm: .zlib)
+        case .deflate(let configuration):
+            return ZlibCompressorWrapper(configuration: configuration, algorithm: .deflate)
         }
     }
 
@@ -40,11 +38,11 @@ public struct CompressionAlgorithm: CustomStringConvertible, Sendable {
     public var decompressor: NIODecompressor {
         switch self.algorithm {
         case .gzip(let configuration):
-            return ZlibDecompressor(windowSize: 16 + configuration.windowSize)
+            return ZlibDecompressorWrapper(windowSize: configuration.windowSize, algorithm: .gzip)
         case .zlib(let configuration):
-            return ZlibDecompressor(windowSize: configuration.windowSize)
+            return ZlibDecompressorWrapper(windowSize: configuration.windowSize, algorithm: .zlib)
         case .deflate(let configuration):
-            return ZlibDecompressor(windowSize: -configuration.windowSize)
+            return ZlibDecompressorWrapper(windowSize: configuration.windowSize, algorithm: .deflate)
         }
     }
 

Sources/CompressNIO/Compressor.swift

@@ -8,22 +8,22 @@ public protocol NIODecompressor: AnyObject {
     ///   - from: source byte buffer
     ///   - to: destination byte buffer
     func inflate(from: inout ByteBuffer, to: inout ByteBuffer) throws
-    
+
     /// Working buffer for window based compression
     var window: ByteBuffer? { get set }
-    
+
     /// Setup decompressor for stream decompression
     func startStream() throws
-    
+
     /// Decompress block as part of a stream to another ByteBuffer
     /// - Parameters:
     ///   - from: source byte buffer
     ///   - to: destination byte buffer
     func streamInflate(from: inout ByteBuffer, to: inout ByteBuffer) throws
-    
+
     /// Finished using thie decompressor for stream decompression
     func finishStream() throws
-    
+
     /// equivalent of calling `finishStream` followed by `startStream`.
     func resetStream() throws
 }
@@ -60,13 +60,13 @@ public protocol NIOCompressor: AnyObject {
     ///   - from: source byte buffer
     ///   - to: destination byte buffer
     func deflate(from: inout ByteBuffer, to: inout ByteBuffer) throws
-    
+
     /// Working buffer for window based compression
     var window: ByteBuffer? { get set }
-    
+
     /// Setup compressor for stream compression
     func startStream() throws
-    
+
     /// Compress block as part of a stream compression
     /// - Parameters:
     ///   - from: source byte buffer
@@ -81,9 +81,6 @@ public protocol NIOCompressor: AnyObject {
     /// Finish using this compressor for stream compression
     func finishStream() throws
 
-    /// Finish using this compressor for stream compression
-    func finishWindowedStream(process: (ByteBuffer)->()) throws
-
     /// equivalent of calling `finishStream` followed by `startStream`. There maybe implementation of this that are more optimal
     func resetStream() throws
 
@@ -99,13 +96,14 @@ extension NIOCompressor {
         try streamDeflate(from: &from, to: &to, flush: .finish)
         try finishStream()
     }
-    
+
     /// Default implementation of `reset`.
     public func resetStream() throws {
         try finishStream()
         try startStream()
     }
 
+    @available(*, deprecated, message: "This function isn't used anymore")
     public func finishWindowedStream(process: (ByteBuffer)->()) throws {
         guard var window = self.window else { preconditionFailure("finishWindowedStream requires your compressor has a window buffer") }
         while true {
@@ -124,4 +122,3 @@ extension NIOCompressor {
         }
     }
 }
-

Sources/CompressNIO/Error.swift

@@ -10,6 +10,7 @@ public struct CompressNIOError: Swift.Error, CustomStringConvertible, Equatable
         case noMoreMemory
         case unfinished
         case internalError
+        case uninitializedStream
     }
 
     fileprivate let error: ErrorEnum
@@ -27,6 +28,8 @@ public struct CompressNIOError: Swift.Error, CustomStringConvertible, Equatable
     public static let noMoreMemory = CompressNIOError(error: .noMoreMemory)
     /// called `streamFinish`while there is still data to process
     public static let unfinished = CompressNIOError(error: .unfinished)
+    /// called stream function while stream was unintialised
+    public static let uninitializedStream = CompressNIOError(error: .uninitializedStream)
     /// error internal to system
     public static let internalError = CompressNIOError(error: .internalError)
 }