(PowerBuilder) Streaming Compression

Compress and decompress using a stream.

Chilkat ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

integer li_rc
oleobject loo_Fac
oleobject loo_Compress
oleobject loo_StreamC
integer li_Success
oleobject loo_StreamD
integer li_BFilesEqual
oleobject loo_StreamA
oleobject loo_Task
string ls_DecompressedText

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

loo_Fac = create oleobject
// Use "Chilkat_9_5_0.FileAccess" for versions of Chilkat < 10.0.0
li_rc = loo_Fac.ConnectToNewObject("Chilkat.FileAccess")
if li_rc < 0 then
    destroy loo_Fac
    MessageBox("Error","Connecting to COM object failed")
    return
end if
loo_Compress = create oleobject
// Use "Chilkat_9_5_0.Compression" for versions of Chilkat < 10.0.0
li_rc = loo_Compress.ConnectToNewObject("Chilkat.Compression")

loo_Compress.Algorithm = "deflate"

loo_StreamC = create oleobject
// Use "Chilkat_9_5_0.Stream" for versions of Chilkat < 10.0.0
li_rc = loo_StreamC.ConnectToNewObject("Chilkat.Stream")

// This example sets the source and sink of the stream to files.
// A stream can have use other streams as a source or sink,
// or the application can itself be the source/sink by directly
// reading or writing a stream.  (See below for an example of this..)
loo_StreamC.SourceFile = "qa_data/hamlet.xml"
loo_StreamC.SinkFile = "qa_output/hamlet_compressed.dat"

// Compress from source to sink.
li_Success = loo_Compress.CompressStream(loo_StreamC)
if li_Success <> 1 then
    Write-Debug loo_Compress.LastErrorText
    destroy loo_Fac
    destroy loo_Compress
    destroy loo_StreamC
    return
end if

Write-Debug "File-to-file deflate compression successful."
// Note: The FileSize method returns a signed 32-bit integer.  If the file is potentially larger than 2GB, call FileSizeStr instead to return
// the size of the file as a string, then convert to an integer value.
Write-Debug "Original size = " + string(loo_Fac.FileSize(loo_StreamC.SourceFile))
Write-Debug "Compressed size = " + string(loo_Fac.FileSize(loo_StreamC.SinkFile))

// Now do file-to-file decompression
loo_StreamD = create oleobject
// Use "Chilkat_9_5_0.Stream" for versions of Chilkat < 10.0.0
li_rc = loo_StreamD.ConnectToNewObject("Chilkat.Stream")

loo_StreamD.SourceFile = "qa_output/hamlet_compressed.dat"
loo_StreamD.SinkFile = "qa_output/hamlet_restored.xml"

// Decompress from source to sink.
li_Success = loo_Compress.DecompressStream(loo_StreamD)
if li_Success <> 1 then
    Write-Debug loo_Compress.LastErrorText
    destroy loo_Fac
    destroy loo_Compress
    destroy loo_StreamC
    destroy loo_StreamD
    return
end if

Write-Debug "File-to-file deflate decompression successful."

// Let's double-check to see that the files are equal in size and content:

li_BFilesEqual = loo_Fac.FileContentsEqual(loo_StreamC.SourceFile,loo_StreamD.SinkFile)
if li_BFilesEqual <> 1 then
    Write-Debug "The output file is not equal to the input file!"
else
    Write-Debug "The file was successfully compressed and decompressed."
end if

// ---------------------------------------------------------------------
// Now let's decompress again, but this time w/ the application reading
// the decompressed data directly from a stream.
loo_StreamA = create oleobject
// Use "Chilkat_9_5_0.Stream" for versions of Chilkat < 10.0.0
li_rc = loo_StreamA.ConnectToNewObject("Chilkat.Stream")

loo_StreamA.SourceFile = "qa_output/hamlet_compressed.dat"

// Start decompressing in a background thread.
loo_Task = loo_Compress.DecompressStreamAsync(loo_StreamA)
li_Success = loo_Task.Run()

// Read decompressed data from streamA:

do while (loo_StreamA.EndOfStream <> 1)
    if loo_StreamA.DataAvailable = 1 then
        ls_DecompressedText = loo_StreamA.ReadString()
        Write-Debug ls_DecompressedText
    end if

loop

// Let's make sure the background task finished and that the decompress was successful.
// It should already be the case that the task is finished.
do while (loo_Task.Finished <> 1)
    loo_Task.SleepMs(20)
loop

// The decompressor may have finished, but it is possible that data
// remains to be flushed.  
if loo_StreamA.DataAvailable = 1 then
    ls_DecompressedText = loo_StreamA.ReadString()
    Write-Debug ls_DecompressedText
end if

// Did streamA succeed in reading the entire file?
if loo_Task.TaskSuccess <> 1 then
    Write-Debug "async decompress failed:"
    Write-Debug loo_Task.ResultErrorText
    li_Success = 0
end if

Write-Debug "The async decompress was successful."


destroy loo_Fac
destroy loo_Compress
destroy loo_StreamC
destroy loo_StreamD
destroy loo_StreamA