Delphi DLL

Unzip One File to a Stream

See more Zip Examples

Demonstrates how to unzip a particular file contained within a .zip archive to a Chilkat stream. Delphi 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
success: Boolean;
zip: HCkZip;
entry: HCkZipEntry;
streamA: HCkStream;
streamB: HCkStream;
unzipTask: HCkTask;
sb: HCkStringBuilder;
streamC: HCkStream;
s: PWideChar;

begin
success := False;

// 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 = False) then
  begin
    Memo1.Lines.Add(CkZip__lastErrorText(zip));
    Exit;
  end;

// Find the entry to be unzipped to a stream..
entry := CkZipEntry_Create();
success := CkZip_EntryMatching(zip,'*hamlet.xml',entry);
if (success = False) 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));
    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));
    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));
    Exit;
  end;

CkTask_Run(unzipTask);

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

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

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

end;