(Tcl) Unzip One File to a Stream

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

Chilkat Tcl Extension Downloads Chilkat Tcl Extension Downloads

load ./chilkat.dll

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

set zip [new_CkZip]

# First open a .zip.
set success [CkZip_OpenZip $zip "qa_data/hamlet.zip"]
if {$success != 1} then {
    puts [CkZip_lastErrorText $zip]
    delete_CkZip $zip
    exit
}

# Find the entry to be unzipped to a stream..
# entry is a CkZipEntry
set entry [CkZip_FirstMatchingEntry $zip "*hamlet.xml"]
if {[CkZip_get_LastMethodSuccess $zip] != 1} then {
    puts [CkZip_lastErrorText $zip]
    delete_CkZip $zip
    exit
}

# 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.
set streamA [new_CkStream]

CkStream_put_SinkFile $streamA "qa_output/hamletA.xml"

set success [CkZipEntry_UnzipToStream $entry $streamA]
if {$success != 1} then {
    puts [CkZipEntry_lastErrorText $entry]
    delete_CkZipEntry $entry

    delete_CkZip $zip
    delete_CkStream $streamA
    exit
}

# Close the stream to close the output file.
set success [CkStream_WriteClose $streamA]

# ----------------------------------------------------------------
# Case 2a: Uzip to a stream asynchronously. 
set streamB [new_CkStream]

# unzipTask is a CkTask
set unzipTask [CkZipEntry_UnzipToStreamAsync $entry $streamB]
if {[CkZipEntry_get_LastMethodSuccess $entry] != 1} then {
    puts [CkZipEntry_lastErrorText $entry]
    delete_CkZipEntry $entry

    delete_CkZip $zip
    delete_CkStream $streamA
    delete_CkStream $streamB
    exit
}

# Start the background unzip thread.
CkTask_Run $unzipTask

# Read the stream.  (this is reading the unzipped file data)
set sb [new_CkStringBuilder]

while {[CkStream_get_EndOfStream $streamB] != 1} {
    # Each call to ReadSb appends to the contents of sb.
    CkStream_ReadSb $streamB $sb
}
CkStringBuilder_WriteFile $sb "qa_output/hamletB.xml" "utf-8" 0

delete_CkTask $unzipTask

puts "Success."

# ----------------------------------------------------------------
# Case 2b: Uzip to a stream asynchronously and emit output while reading. 
set streamC [new_CkStream]

set unzipTask [CkZipEntry_UnzipToStreamAsync $entry $streamC]
if {[CkZipEntry_get_LastMethodSuccess $entry] != 1} then {
    puts [CkZipEntry_lastErrorText $entry]
    delete_CkZipEntry $entry

    delete_CkZip $zip
    delete_CkStream $streamA
    delete_CkStream $streamB
    delete_CkStringBuilder $sb
    delete_CkStream $streamC
    exit
}

CkTask_Run $unzipTask

while {[CkStream_get_EndOfStream $streamC] != 1} {
    set s [CkStream_readString $streamC]
    puts "$s"
}

delete_CkZipEntry $entry

delete_CkTask $unzipTask

puts "Success."

delete_CkZip $zip
delete_CkStream $streamA
delete_CkStream $streamB
delete_CkStringBuilder $sb
delete_CkStream $streamC