Delphi DLL Requires Chilkat v11.0.0+

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

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);