(Delphi DLL) Understanding ZIP Entry Types and the ZIP Object Lifecycle

See more Zip Examples

This example demonstrates how the Chilkat.Zip object manages entries before and after a ZIP archive is written.

The example shows:

• How file references are added from the local filesystem using AppendFilesEx
• How in-memory entries are added using AddString
• How ZIP entry types change as the ZIP archive progresses from an in-memory staging object to an actual written .zip file
• How additional entries can continue to be added even after the ZIP archive has already been written

The example also demonstrates the meaning of the different ZipEntry.EntryType values:

• 1 — File references in the local filesystem that have not yet been processed
• 2 — In-memory data entries
• 0 — Entries mapped to an existing open ZIP archive

This example is useful for understanding how the Chilkat.Zip class internally stages entries prior to writing the final ZIP archive.

Note: This example requires Chilkat v11.0.0 or greater.

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, Zip;

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Boolean;
zip: HCkZip;
zipPath: PWideChar;
recurse: Boolean;
saveExtraPath: Boolean;
archiveOnly: Boolean;
includeHidden: Boolean;
includeSystem: Boolean;
entry: HCkZipEntry;
count: Integer;
i: Integer;

begin
success := False;

success := False;

zip := CkZip_Create();

zipPath := 'c:/temp/out.zip';

// Start a new Zip object and set the output path.
// This does not create the .zip file yet.  It only initializes the Zip object
// and records the filename to be used later when WriteZip is called.
CkZip_NewZip(zip,zipPath);

// Add references to files in the local filesystem.
// AppendFilesEx does not read, compress, or store the file contents at this point.
// It only adds file references to the Zip object.  The referenced files are
// read and compressed later, when WriteZip is called.
recurse := True;
saveExtraPath := False;
archiveOnly := False;
includeHidden := True;
includeSystem := False;
success := CkZip_AppendFilesEx(zip,'c:/temp/files_to_zip',recurse,saveExtraPath,archiveOnly,includeHidden,includeSystem);
if (success = False) then
  begin
    Memo1.Lines.Add(CkZip__lastErrorText(zip));
    Exit;
  end;

// We can inspect the entries that have been added to the Zip object.
// At this stage, the entries are still references to files in the local filesystem.
entry := CkZipEntry_Create();
count := CkZip_getNumEntries(zip);
i := 0;
while i < count do
  begin
    CkZip_EntryAt(zip,i,entry);
    Memo1.Lines.Add(CkZipEntry__fileName(entry) + ' entryType = ' + IntToStr(CkZipEntry_getEntryType(entry)));
    i := i + 1;
  end;

Memo1.Lines.Add('----');

// Sample output for the above loop:
// 
// hamlet.xml entryType = 1
// hello.pdf entryType = 1
// ...
// ...
// 
// entryType = 1 means "File Entry".
// A File Entry is a reference to a file in the local filesystem.
// The file data has not yet been read into the Zip object.
// 
// Possible entryType values:
// 
// 0 - Mapped Entry:
//     An entry that already exists in an open .zip file.
// 
// 1 - File Entry:
//     A file in the local filesystem that has been referenced, but not yet
//     read or compressed.  These entries are added by methods such as
//     AppendFiles, AppendFilesEx, and AddFile.
// 
// 2 - Data Entry:
//     An entry containing uncompressed data already held in memory.
//     These entries are added by methods such as AddData, AddString,
//     AddSb, AddBd, and AddEncoded.
// 
// 3 - Null Entry:
//     An entry that no longer exists in the .zip.
// 
// 4 - New Directory Entry:
//     A directory entry added by calling AddEmpty.

// Additional entries can still be added before the .zip is written.
// This entry is created from an in-memory string, so it is a Data Entry
// rather than a File Entry.
CkZip_AddString(zip,'helloWorld.txt','Hello World','utf-8');

// Inspect the Zip object again before writing.
// The file references are still entryType = 1.
// The in-memory string entry is entryType = 2.
count := CkZip_getNumEntries(zip);
i := 0;
while i < count do
  begin
    CkZip_EntryAt(zip,i,entry);
    Memo1.Lines.Add(CkZipEntry__fileName(entry) + ' entryType = ' + IntToStr(CkZipEntry_getEntryType(entry)));
    i := i + 1;
  end;

Memo1.Lines.Add('----');

// Sample output:
// 
// hamlet.xml entryType = 1
// hello.pdf entryType = 1
// ...
// ...
// helloWorld.txt entryType = 2
// 
// helloWorld.txt has entryType = 2 because its contents came from memory.
// It is not a reference to a file in the local filesystem.

// ----------------------------------------------------------------------------
// Write the Zip object to the .zip file.
// 
// During this call, Chilkat reads the referenced files from the local filesystem,
// compresses the data as needed, and writes the final .zip archive.
CkZip_putFileName(zip,zipPath);
success := CkZip_WriteZip(zip);
if (success = False) then
  begin
    Memo1.Lines.Add(CkZip__lastErrorText(zip));
    Exit;
  end;

// After WriteZip returns successfully, the .zip file is written and remains
// open in the Zip object.  The entries now correspond to entries in the
// currently open .zip archive.
count := CkZip_getNumEntries(zip);
i := 0;
while i < count do
  begin
    CkZip_EntryAt(zip,i,entry);
    Memo1.Lines.Add(CkZipEntry__fileName(entry) + ' entryType = ' + IntToStr(CkZipEntry_getEntryType(entry)));
    i := i + 1;
  end;

Memo1.Lines.Add('----');

// Sample output:
// 
// hamlet.xml entryType = 0
// hello.pdf entryType = 0
// ...
// ...
// helloWorld.txt entryType = 0
// 
// entryType = 0 means "Mapped Entry".
// A Mapped Entry is an entry that exists in an open .zip file.

// ----------------------------------------------------------------------------
// The .zip remains open after WriteZip, so additional entries can still be added.
// 
// This adds another in-memory string entry to the currently open Zip object.
CkZip_AddString(zip,'helloWorld2.txt','Hello World 2','utf-8');

// Write the .zip again to include the newly added entry.
success := CkZip_WriteZip(zip);
if (success = False) then
  begin
    Memo1.Lines.Add(CkZip__lastErrorText(zip));
    Exit;
  end;

// Inspect the entries one final time.
// After the second WriteZip, the new entry is also mapped to the open .zip file.
count := CkZip_getNumEntries(zip);
i := 0;
while i < count do
  begin
    CkZip_EntryAt(zip,i,entry);
    Memo1.Lines.Add(CkZipEntry__fileName(entry) + ' entryType = ' + IntToStr(CkZipEntry_getEntryType(entry)));
    i := i + 1;
  end;

Memo1.Lines.Add('----');

// Sample output:
// 
// hamlet.xml entryType = 0
// hello.pdf entryType = 0
// ...
// ...
// helloWorld.txt entryType = 0
// helloWorld2.txt entryType = 0

// Close the open .zip archive and clear the Zip object.
CkZip_CloseZip(zip);

Memo1.Lines.Add('Success');

CkZip_Dispose(zip);
CkZipEntry_Dispose(entry);

end;