(Swift 2) 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.OpenZip("qa_data/hamlet.zip")
    if success != true {
        print("\(zip.LastErrorText)")
        return
    }

    // Find the entry to be unzipped to a stream..
    var entry: CkoZipEntry? = zip.FirstMatchingEntry("*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!.UnzipToStream(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!.UnzipToStreamAsync(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!.UnzipToStreamAsync(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.")

}