(AutoIt) 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 ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

Local $bSuccess = False

$bSuccess = False

$oZip = ObjCreate("Chilkat.Zip")

Local $sZipPath = "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($sZipPath)

; 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.
Local $bRecurse = True
Local $bSaveExtraPath = False
Local $bArchiveOnly = False
Local $bIncludeHidden = True
Local $bIncludeSystem = False
$bSuccess = $oZip.AppendFilesEx("c:/temp/files_to_zip",$bRecurse,$bSaveExtraPath,$bArchiveOnly,$bIncludeHidden,$bIncludeSystem)
If ($bSuccess = False) Then
    ConsoleWrite($oZip.LastErrorText & @CRLF)
    Exit
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 = ObjCreate("Chilkat.ZipEntry")
Local $iCount = $oZip.NumEntries
Local $i = 0
While $i < $iCount
    $oZip.EntryAt($i,$oEntry)
    ConsoleWrite($oEntry.FileName & " entryType = " & $oEntry.EntryType & @CRLF)
    $i = $i + 1
Wend
ConsoleWrite("----" & @CRLF)

; 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.
$iCount = $oZip.NumEntries
$i = 0
While $i < $iCount
    $oZip.EntryAt($i,$oEntry)
    ConsoleWrite($oEntry.FileName & " entryType = " & $oEntry.EntryType & @CRLF)
    $i = $i + 1
Wend
ConsoleWrite("----" & @CRLF)

; 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 = $sZipPath
$bSuccess = $oZip.WriteZip()
If ($bSuccess = False) Then
    ConsoleWrite($oZip.LastErrorText & @CRLF)
    Exit
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.
$iCount = $oZip.NumEntries
$i = 0
While $i < $iCount
    $oZip.EntryAt($i,$oEntry)
    ConsoleWrite($oEntry.FileName & " entryType = " & $oEntry.EntryType & @CRLF)
    $i = $i + 1
Wend
ConsoleWrite("----" & @CRLF)

; 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.
$bSuccess = $oZip.WriteZip()
If ($bSuccess = False) Then
    ConsoleWrite($oZip.LastErrorText & @CRLF)
    Exit
EndIf

; Inspect the entries one final time.
; After the second WriteZip, the new entry is also mapped to the open .zip file.
$iCount = $oZip.NumEntries
$i = 0
While $i < $iCount
    $oZip.EntryAt($i,$oEntry)
    ConsoleWrite($oEntry.FileName & " entryType = " & $oEntry.EntryType & @CRLF)
    $i = $i + 1
Wend
ConsoleWrite("----" & @CRLF)

; 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 

ConsoleWrite("Success" & @CRLF)