(PureBasic) Unzip One File to a Stream

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

Chilkat PureBasic Module Download Chilkat PureBasic Module

IncludeFile "CkZipEntry.pb"
IncludeFile "CkZip.pb"
IncludeFile "CkStringBuilder.pb"
IncludeFile "CkTask.pb"
IncludeFile "CkStream.pb"

Procedure ChilkatExample()

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

    zip.i = CkZip::ckCreate()
    If zip.i = 0
        Debug "Failed to create object."
        ProcedureReturn
    EndIf

    ; First open a .zip.
    success.i = CkZip::ckOpenZip(zip,"qa_data/hamlet.zip")
    If success <> 1
        Debug CkZip::ckLastErrorText(zip)
        CkZip::ckDispose(zip)
        ProcedureReturn
    EndIf

    ; Find the entry to be unzipped to a stream..
    entry.i = CkZip::ckFirstMatchingEntry(zip,"*hamlet.xml")
    If CkZip::ckLastMethodSuccess(zip) <> 1
        Debug CkZip::ckLastErrorText(zip)
        CkZip::ckDispose(zip)
        ProcedureReturn
    EndIf

    ; 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.
    streamA.i = CkStream::ckCreate()
    If streamA.i = 0
        Debug "Failed to create object."
        ProcedureReturn
    EndIf

    CkStream::setCkSinkFile(streamA, "qa_output/hamletA.xml")

    success = CkZipEntry::ckUnzipToStream(entry,streamA)
    If success <> 1
        Debug CkZipEntry::ckLastErrorText(entry)
        CkZipEntry::ckDispose(entry)

        CkZip::ckDispose(zip)
        CkStream::ckDispose(streamA)
        ProcedureReturn
    EndIf

    ; Close the stream to close the output file.
    success = CkStream::ckWriteClose(streamA)

    ; ----------------------------------------------------------------
    ; Case 2a: Uzip to a stream asynchronously. 
    streamB.i = CkStream::ckCreate()
    If streamB.i = 0
        Debug "Failed to create object."
        ProcedureReturn
    EndIf

    unzipTask.i = CkZipEntry::ckUnzipToStreamAsync(entry,streamB)
    If CkZipEntry::ckLastMethodSuccess(entry) <> 1
        Debug CkZipEntry::ckLastErrorText(entry)
        CkZipEntry::ckDispose(entry)

        CkZip::ckDispose(zip)
        CkStream::ckDispose(streamA)
        CkStream::ckDispose(streamB)
        ProcedureReturn
    EndIf

    ; Start the background unzip thread.
    CkTask::ckRun(unzipTask)

    ; Read the stream.  (this is reading the unzipped file data)
    sb.i = CkStringBuilder::ckCreate()
    If sb.i = 0
        Debug "Failed to create object."
        ProcedureReturn
    EndIf

    While CkStream::ckEndOfStream(streamB) <> 1
        ; Each call to ReadSb appends to the contents of sb.
        CkStream::ckReadSb(streamB,sb)
    Wend
    CkStringBuilder::ckWriteFile(sb,"qa_output/hamletB.xml","utf-8",0)

    CkTask::ckDispose(unzipTask)

    Debug "Success."

    ; ----------------------------------------------------------------
    ; Case 2b: Uzip to a stream asynchronously and emit output while reading. 
    streamC.i = CkStream::ckCreate()
    If streamC.i = 0
        Debug "Failed to create object."
        ProcedureReturn
    EndIf

    unzipTask = CkZipEntry::ckUnzipToStreamAsync(entry,streamC)
    If CkZipEntry::ckLastMethodSuccess(entry) <> 1
        Debug CkZipEntry::ckLastErrorText(entry)
        CkZipEntry::ckDispose(entry)

        CkZip::ckDispose(zip)
        CkStream::ckDispose(streamA)
        CkStream::ckDispose(streamB)
        CkStringBuilder::ckDispose(sb)
        CkStream::ckDispose(streamC)
        ProcedureReturn
    EndIf

    CkTask::ckRun(unzipTask)

    While CkStream::ckEndOfStream(streamC) <> 1
        s.s = CkStream::ckReadString(streamC)
        Debug s
    Wend

    CkZipEntry::ckDispose(entry)

    CkTask::ckDispose(unzipTask)

    Debug "Success."


    CkZip::ckDispose(zip)
    CkStream::ckDispose(streamA)
    CkStream::ckDispose(streamB)
    CkStringBuilder::ckDispose(sb)
    CkStream::ckDispose(streamC)


    ProcedureReturn
EndProcedure