(Swift 3,4,5...) Unzip One File to a Stream

Demonstrates how to unzip a particular file contained within a .zip archive to a Chilkat stream.

Chilkat Downloads for the Swift Programming Language MAC OS X (Cocoa) Objective-C/Swift Libs iOS Objective-C/Swift Libs

func chilkatTest() {
    // This example requires the Chilkat API to have been previously unlocked.
    // See Global Unlock Sample for sample code.

    let zip = CkoZip()!

    // First open a .zip.
    var success: Bool = zip.open("qa_data/hamlet.zip")
    if success != true {
        print("\(zip.lastErrorText!)")
        return
    }

    // Find the entry to be unzipped to a stream..
    var entry: CkoZipEntry? = zip.first(matchingEntry: "*hamlet.xml")
    if zip.lastMethodSuccess != true {
        print("\(zip.lastErrorText!)")
        return
    }

    // There are three ways we can unzip (inflate) to a stream.
    // 
    // 1) Set a sink file on the stream object and call UnzipToStream synchronously.
    //    This unzips to the stream's sink (which is to simply unzip to a file in the filesystem).
    // 
    // 2) Create a stream object and call UnzipToStreamAsync.  This starts the unzip in a background
    //    thread (after Task.Run is called).  Your application can then read the unzipped (inflated) file
    //    directly from the stream.
    // 
    // 3) (not shown in this example) Unzip to a stream object that is the source of something else.
    //    

    // ----------------------------------------------------------------
    // Case 1: Unzip to a file by setting the sink of streamA to a file.
    let streamA = CkoStream()!
    streamA.sinkFile = "qa_output/hamletA.xml"

    success = entry!.unzip(to: streamA)
    if success != true {
        print("\(entry!.lastErrorText!)")
        entry = nil
        return
    }

    // Close the stream to close the output file.
    success = streamA.writeClose()

    // ----------------------------------------------------------------
    // Case 2a: Uzip to a stream asynchronously. 
    let streamB = CkoStream()!

    var unzipTask: CkoTask? = entry!.unzip(toStreamAsync: streamB)
    if entry!.lastMethodSuccess != true {
        print("\(entry!.lastErrorText!)")
        entry = nil
        return
    }

    // Start the background unzip thread.
    unzipTask!.run()

    // Read the stream.  (this is reading the unzipped file data)
    let sb = CkoStringBuilder()!
    while streamB.endOfStream != true {
        // Each call to ReadSb appends to the contents of sb.
        streamB.readSb(sb)
    }

    sb.writeFile("qa_output/hamletB.xml", charset: "utf-8", emitBom: false)

    unzipTask = nil
    print("Success.")

    // ----------------------------------------------------------------
    // Case 2b: Uzip to a stream asynchronously and emit output while reading. 
    let streamC = CkoStream()!

    unzipTask = entry!.unzip(toStreamAsync: streamC)
    if entry!.lastMethodSuccess != true {
        print("\(entry!.lastErrorText!)")
        entry = nil
        return
    }

    unzipTask!.run()

    while streamC.endOfStream != true {
        var s: String? = streamC.readString()
        print("\(s!)")
    }

    entry = nil
    unzipTask = nil
    print("Success.")

}