Xbase++ Requires Chilkat v11.0.0+

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.

Xbase++

LOCAL nSuccess
LOCAL oZip
LOCAL cZipPath
LOCAL nRecurse
LOCAL nSaveExtraPath
LOCAL nArchiveOnly
LOCAL nIncludeHidden
LOCAL nIncludeSystem
LOCAL oEntry
LOCAL nCount
LOCAL i

nSuccess := 0

nSuccess := 0

oZip := CreateObject("Chilkat.Zip")

cZipPath := "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.
oZip:NewZip(cZipPath)

//  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.
nRecurse := 1
nSaveExtraPath := 0
nArchiveOnly := 0
nIncludeHidden := 1
nIncludeSystem := 0
nSuccess := oZip:AppendFilesEx("c:/temp/files_to_zip", nRecurse, nSaveExtraPath, nArchiveOnly, nIncludeHidden, nIncludeSystem)
IF (nSuccess == 0)
    ? oZip:LastErrorText
    oZip:destroy()
    RETURN
ENDIF

//  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.
oEntry := CreateObject("Chilkat.ZipEntry")
nCount := oZip:NumEntries
i := 0
DO WHILE i < nCount
    oZip:EntryAt(i, oEntry)
    ? oEntry:FileName + " entryType = " + Str(oEntry:EntryType)
    i := i + 1
ENDDO
? "----"

//  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.
oZip:AddString("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.
nCount := oZip:NumEntries
i := 0
DO WHILE i < nCount
    oZip:EntryAt(i, oEntry)
    ? oEntry:FileName + " entryType = " + Str(oEntry:EntryType)
    i := i + 1
ENDDO
? "----"

//  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.
oZip:FileName := cZipPath
nSuccess := oZip:WriteZip()
IF (nSuccess == 0)
    ? oZip:LastErrorText
    oZip:destroy()
    oEntry:destroy()
    RETURN
ENDIF

//  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.
nCount := oZip:NumEntries
i := 0
DO WHILE i < nCount
    oZip:EntryAt(i, oEntry)
    ? oEntry:FileName + " entryType = " + Str(oEntry:EntryType)
    i := i + 1
ENDDO
? "----"

//  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.
oZip:AddString("helloWorld2.txt", "Hello World 2", "utf-8")

//  Write the .zip again to include the newly added entry.
nSuccess := oZip:WriteZip()
IF (nSuccess == 0)
    ? oZip:LastErrorText
    oZip:destroy()
    oEntry:destroy()
    RETURN
ENDIF

//  Inspect the entries one final time.
//  After the second WriteZip, the new entry is also mapped to the open .zip file.
nCount := oZip:NumEntries
i := 0
DO WHILE i < nCount
    oZip:EntryAt(i, oEntry)
    ? oEntry:FileName + " entryType = " + Str(oEntry:EntryType)
    i := i + 1
ENDDO
? "----"

//  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.
oZip:CloseZip()

? "Success"

oZip:destroy()
oEntry:destroy()