Swift

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.")

}