Swift Requires Chilkat v11.0.0+

Unzip One File to a Stream

See more Zip Examples

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

func chilkatTest() {
    var success: Bool = false

    //  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.
    success = zip.open(zipPath: "qa_data/hamlet.zip")
    if success == false {
        print("\(zip.lastErrorText!)")
        return
    }

    //  Find the entry to be unzipped to a stream..
    let entry = CkoZipEntry()!
    success = zip.entry(matching: "*hamlet.xml", entry: entry)
    if success == false {
        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(toStream: streamA)
    if success != true {
        print("\(entry.lastErrorText!)")
        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!)")
        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)
    }

    sb.writeFile(path: "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!)")
        return
    }

    unzipTask!.run()

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

    unzipTask = nil
    print("Success.")

}