(Go) Unzip One File to a Stream

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

Chilkat Go Downloads Go Package for Windows, MacOS, Linux, Alpine Linux, Solaris

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

    zip := chilkat.NewZip()

    // First open a .zip.
    success := zip.OpenZip("qa_data/hamlet.zip")
    if success != true {
        fmt.Println(zip.LastErrorText())
        zip.DisposeZip()
        return
    }

    // Find the entry to be unzipped to a stream..
    entry := zip.FirstMatchingEntry("*hamlet.xml")
    if zip.LastMethodSuccess() != true {
        fmt.Println(zip.LastErrorText())
        zip.DisposeZip()
        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.
    streamA := chilkat.NewStream()
    streamA.SetSinkFile("qa_output/hamletA.xml")

    success = entry.UnzipToStream(streamA)
    if success != true {
        fmt.Println(entry.LastErrorText())
        entry.DisposeZipEntry()
        zip.DisposeZip()
        streamA.DisposeStream()
        return
    }

    // Close the stream to close the output file.
    success = streamA.WriteClose()

    // ----------------------------------------------------------------
    // Case 2a: Uzip to a stream asynchronously. 
    streamB := chilkat.NewStream()

    c := make(chan *chilkat.Task)
    go entry.UnzipToStreamAsync(streamB,c)
    unzipTask := <-c
    if entry.LastMethodSuccess() != true {
        fmt.Println(entry.LastErrorText())
        entry.DisposeZipEntry()
        zip.DisposeZip()
        streamA.DisposeStream()
        streamB.DisposeStream()
        unzipTask.DisposeTask()
        return
    }

    // Start the background unzip thread.

    // Read the stream.  (this is reading the unzipped file data)
    sb := chilkat.NewStringBuilder()
    for streamB.EndOfStream() != true {
        // Each call to ReadSb appends to the contents of sb.
        streamB.ReadSb(sb)
    }

    sb.WriteFile("qa_output/hamletB.xml","utf-8",false)

    unzipTask.DisposeTask()
    fmt.Println("Success.")

    // ----------------------------------------------------------------
    // Case 2b: Uzip to a stream asynchronously and emit output while reading. 
    streamC := chilkat.NewStream()

    c := make(chan *chilkat.Task)
    go entry.UnzipToStreamAsync(streamC,c)
    unzipTask := <-c
    if entry.LastMethodSuccess() != true {
        fmt.Println(entry.LastErrorText())
        entry.DisposeZipEntry()
        zip.DisposeZip()
        streamA.DisposeStream()
        streamB.DisposeStream()
        unzipTask.DisposeTask()
        sb.DisposeStringBuilder()
        streamC.DisposeStream()
        unzipTask.DisposeTask()
        return
    }

    for streamC.EndOfStream() != true {
        s := streamC.ReadString()
        fmt.Println(*s)
    }

    entry.DisposeZipEntry()
    unzipTask.DisposeTask()
    fmt.Println("Success.")

    zip.DisposeZip()
    streamA.DisposeStream()
    streamB.DisposeStream()
    unzipTask.DisposeTask()
    sb.DisposeStringBuilder()
    streamC.DisposeStream()
    unzipTask.DisposeTask()