(Delphi DLL) Unzip One File to a Stream

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

Chilkat for Delphi Downloads Chilkat non-ActiveX DLL for Delphi Chilkat ActiveX DLL for Delphi * The examples here use the non-ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, ZipEntry, Task, StringBuilder, Zip, Stream;

...

procedure TForm1.Button1Click(Sender: TObject);
var
zip: HCkZip;
success: Boolean;
entry: HCkZipEntry;
streamA: HCkStream;
streamB: HCkStream;
unzipTask: HCkTask;
sb: HCkStringBuilder;
streamC: HCkStream;
s: PWideChar;

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

zip := CkZip_Create();

// First open a .zip.
success := CkZip_OpenZip(zip,'qa_data/hamlet.zip');
if (success <> True) then
  begin
    Memo1.Lines.Add(CkZip__lastErrorText(zip));
    Exit;
  end;

// Find the entry to be unzipped to a stream..
entry := CkZip_FirstMatchingEntry(zip,'*hamlet.xml');
if (CkZip_getLastMethodSuccess(zip) <> True) then
  begin
    Memo1.Lines.Add(CkZip__lastErrorText(zip));
    Exit;
  end;

// 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 := CkStream_Create();
CkStream_putSinkFile(streamA,'qa_output/hamletA.xml');

success := CkZipEntry_UnzipToStream(entry,streamA);
if (success <> True) then
  begin
    Memo1.Lines.Add(CkZipEntry__lastErrorText(entry));
    CkZipEntry_Dispose(entry);
    Exit;
  end;

// Close the stream to close the output file.
success := CkStream_WriteClose(streamA);

// ----------------------------------------------------------------
// Case 2a: Uzip to a stream asynchronously. 
streamB := CkStream_Create();

unzipTask := CkZipEntry_UnzipToStreamAsync(entry,streamB);
if (CkZipEntry_getLastMethodSuccess(entry) <> True) then
  begin
    Memo1.Lines.Add(CkZipEntry__lastErrorText(entry));
    CkZipEntry_Dispose(entry);
    Exit;
  end;

// Start the background unzip thread.
CkTask_Run(unzipTask);

// Read the stream.  (this is reading the unzipped file data)
sb := CkStringBuilder_Create();
while CkStream_getEndOfStream(streamB) <> True do
  begin
    // Each call to ReadSb appends to the contents of sb.
    CkStream_ReadSb(streamB,sb);
  end;

CkStringBuilder_WriteFile(sb,'qa_output/hamletB.xml','utf-8',False);

CkTask_Dispose(unzipTask);
Memo1.Lines.Add('Success.');

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

unzipTask := CkZipEntry_UnzipToStreamAsync(entry,streamC);
if (CkZipEntry_getLastMethodSuccess(entry) <> True) then
  begin
    Memo1.Lines.Add(CkZipEntry__lastErrorText(entry));
    CkZipEntry_Dispose(entry);
    Exit;
  end;

CkTask_Run(unzipTask);

while CkStream_getEndOfStream(streamC) <> True do
  begin
    s := CkStream__readString(streamC);
    Memo1.Lines.Add(s);
  end;

CkZipEntry_Dispose(entry);
CkTask_Dispose(unzipTask);
Memo1.Lines.Add('Success.');

CkZip_Dispose(zip);
CkStream_Dispose(streamA);
CkStream_Dispose(streamB);
CkStringBuilder_Dispose(sb);
CkStream_Dispose(streamC);

end;