Visual FoxPro

Streaming Compression

See more Compression Examples

Compress and decompress using a stream. Visual FoxPro

LOCAL lnSuccess
LOCAL loFac
LOCAL loCompress
LOCAL loStreamC
LOCAL loStreamD
LOCAL lnBFilesEqual
LOCAL loStreamA
LOCAL loTask
LOCAL lcDecompressedText

lnSuccess = 0

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

loFac = CreateObject('Chilkat.FileAccess')
loCompress = CreateObject('Chilkat.Compression')
loCompress.Algorithm = "deflate"

loStreamC = CreateObject('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..)
loStreamC.SourceFile = "qa_data/hamlet.xml"
loStreamC.SinkFile = "qa_output/hamlet_compressed.dat"

* Compress from source to sink.
lnSuccess = loCompress.CompressStream(loStreamC)
IF (lnSuccess <> 1) THEN
    ? loCompress.LastErrorText
    RELEASE loFac
    RELEASE loCompress
    RELEASE loStreamC
    CANCEL
ENDIF

? "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.
? "Original size = " + STR(loFac.FileSize(loStreamC.SourceFile))
? "Compressed size = " + STR(loFac.FileSize(loStreamC.SinkFile))

* Now do file-to-file decompression
loStreamD = CreateObject('Chilkat.Stream')
loStreamD.SourceFile = "qa_output/hamlet_compressed.dat"
loStreamD.SinkFile = "qa_output/hamlet_restored.xml"

* Decompress from source to sink.
lnSuccess = loCompress.DecompressStream(loStreamD)
IF (lnSuccess <> 1) THEN
    ? loCompress.LastErrorText
    RELEASE loFac
    RELEASE loCompress
    RELEASE loStreamC
    RELEASE loStreamD
    CANCEL
ENDIF

? "File-to-file deflate decompression successful."

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

lnBFilesEqual = loFac.FileContentsEqual(loStreamC.SourceFile,loStreamD.SinkFile)
IF (lnBFilesEqual <> 1) THEN
    ? "The output file is not equal to the input file!"
ELSE
    ? "The file was successfully compressed and decompressed."
ENDIF

* ---------------------------------------------------------------------
* Now let's decompress again, but this time w/ the application reading
* the decompressed data directly from a stream.
loStreamA = CreateObject('Chilkat.Stream')

loStreamA.SourceFile = "qa_output/hamlet_compressed.dat"

* Start decompressing in a background thread.
loTask = loCompress.DecompressStreamAsync(loStreamA)
lnSuccess = loTask.Run()

* Read decompressed data from streamA:

DO WHILE (loStreamA.EndOfStream <> 1)
    IF (loStreamA.DataAvailable = 1) THEN
        lcDecompressedText = loStreamA.ReadString()
        ? lcDecompressedText
    ENDIF

ENDDO

* 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 (loTask.Finished <> 1)
    loTask.SleepMs(20)
ENDDO

* The decompressor may have finished, but it is possible that data
* remains to be flushed.  
IF (loStreamA.DataAvailable = 1) THEN
    lcDecompressedText = loStreamA.ReadString()
    ? lcDecompressedText
ENDIF

* Did streamA succeed in reading the entire file?
IF (loTask.TaskSuccess <> 1) THEN
    ? "async decompress failed:"
    ? loTask.ResultErrorText
    lnSuccess = 0
ENDIF

? "The async decompress was successful."

RELEASE loFac
RELEASE loCompress
RELEASE loStreamC
RELEASE loStreamD
RELEASE loStreamA