Introduction

• The operations described in this article report progress using callback objects. For more information about using callback objects, see Progress Notifications: Using Callback Objects.
• To read about preventing archive corruption in some cases, see Compressing Data.
• To access a file inside an archive, request its information using methods described here: Requesting Information, Predicting Names and Sizes.

Replacing

• To replace an existing file in an archive with a new file, use the
  CZipArchive::AddNewFile(CZipAddNewFileInfo&) method and specify the index of the file to be replaced in CZipAddNewFileInfo::m_uReplaceIndex.
• The operation replaces the file physically and no information from the file being replaced is retained (such as attributes, modification time, encryption method, etc.).
• If CZipAddNewFileInfo::m_iComprLevel is not 0 then a file to be added is first compressed to a temporary archive which is created in:
  • the temporary directory (see the CZipArchive::SetTempPath() method)
  • or in the memory, if you specify CZipArchive::zipsmMemoryFlag in CZipAddNewFileInfo::m_iSmartLevel.

    CZipArchive zip;
    zip.Open(_T("C:\\Temp\\test.zip"));
    CZipAddNewFileInfo info(_T("C:\\Temp\\file.dat"), _T("replacement.dat"));
    // replace the first file in the archive
    info.m_uReplaceIndex = 0;
    zip.AddNewFile(info);
    zip.Close();

Callbacks Called

• If a temporary archive is used (see above), then the CZipActionCallback::cbAdd callback is called while compressing a file to a temporary archive.
• If you have additionally specified CZipArchive::zipsmCheckForEff in CZipAddNewFileInfo::m_iSmartLevel and the compression to the temporary archive proved to be inefficient, then the file is stored instead in a temporary archive and this process calls the CZipActionCallback::cbAddStore callback.
• If the space size taken by the old file is different from the space size needed by the new file, the space needs to be adjusted for the new file to fit and this operation calls the CZipActionCallback::cbMoveData callback.

Deleting

You can delete files in an archive by specifying either of:

• an index of the file to delete with the method
  CZipArchive::RemoveFile,
• an array of indexes of files to delete with the method
  CZipArchive::RemoveFiles(CZipIndexesArray&),
• an array of names of files to delete with the method
  CZipArchive::RemoveFiles(const CZipStringArray&).

If you plan to delete more files at once, use the methods that take arrays as arguments - they are optimized for multiple file deletion.

If you don't want to physically remove the file from the archive, but only from the central directory (e.g. to save the processing time or for safer archive modifications), use the CZipArchive::RemoveFile method and set the bRemoveData parameter to false.

    CZipArchive zip;
    zip.Open(_T("C:\\Temp\\test.zip"));
    // delete the first file
    zip.RemoveFile(0);
    // delete two first files
    CZipIndexesArray indexes;
    indexes.Add(0);
    indexes.Add(1);
    zip.RemoveFiles(indexes);
    // delete files by their names
    CZipStringArray names;
    names.Add(_T("Temp\\file1.dat"));
    names.Add(_T("file4.dat"));
    zip.RemoveFiles(names);
    zip.Close();

Callbacks Called

• When a map of areas of data to be moved inside an archive is being calculated, the CZipActionCallback::cbDeleteCnt callback is called.
• When the space inside the archive needs to be adjusted, this operation notifies about the progress using the CZipActionCallback::cbDelete callback.

Committing Modification Changes

• Commit changes functionality currently concerns only renaming of files.
• The ZipArchive Library allows grouping multiple operations and writing the necessary changes to an archive at once, which is more efficient than modifying files separately.
• To examine, if a file has been modified, call the CZipFileHeader::IsModified() method.
• To examine, if there are any pending modification in an archive, call the CZipArchive::IsModified() method.

Commit Mode

• The commit mode can be set with the CZipArchive::SetCommitMode() method to one of CZipArchive::CommitMode values.
• Regardless of the mode, all uncommitted changes will committed when closing an archive.
• When using CZipArchive::cmManual mode, you can commit the changes manually with the CZipArchive::CommitChanges() method.

Callback Called

If data sizes of modified files differ after modifications, then the space inside the archive needs to be adjusted and the CZipArchive::CommitChanges() method notifies about the progress using the CZipActionCallback::cbModify callback.

    CZipArchive zip;
    zip.Open(_T("C:\\Temp\\test.zip"));
    zip.SetCommitMode(CZipArchive::cmManual);
    // rename the first file in the archive
    zip[0]->SetFileName(_T("renamed.dat"));    
    zip[2]->SetFileName(_T("renamed2.dat"));
    zip.CommitChanges();
    // perform possibly some other operations
    zip.Close();

Renaming

• To rename files, use the CZipFileHeader::SetFileName() method.
• When calling this method, the current Unicode mode will be used (see Unicode Support: Using Non-English Characters in Filenames, Comments and Passwords for more information) - this may result in changing a Unicode mode for the file being renamed.
• To rename multiple files at once, you may want to use the CZipArchive::cmManual commit changes mode.

    CZipArchive zip;
    zip.Open(_T("C:\\Temp\\test.zip"));
    zip.SetCommitMode(CZipArchive::cmManual);
    // rename the first file in the archive
    zip[0]->SetFileName(_T("renamed.dat"));    
    zip[2]->SetFileName(_T("renamed2.dat"));
    // this will call CommitChanges
    zip.Close();

Changing the Modification Time of Files Inside an Archive

The modification time of the file is written in both local and central headers. To modify it, you need to update the time stamp in these both locations to keep the archive consistent. Follow the steps below to do it:

• Be sure that the existing local header information was already read from the archive. It happens when a file is opened for extraction. Otherwise, you can also update it by calling the CZipArchive::ReadLocalHeader() method.
• Request the CZipFileHeader object for the file which time stamp you want to change. Use the CZipArchive::GetFileInfo(ZIP_INDEX_TYPE) or CZipArchive::operator[]() methods.
• Change the time by calling the CZipFileHeader::SetTime() method.
• Write the local information back to the archive by calling the CZipArchive::OverwriteLocalHeader() method.
• To update the central directory, it first needs to be removed from the archive. The central directory is removed from an archive, when a modification such as adding, deleting, renaming, encrypting or other takes place. However, if you have not performed such a modification on the archive, you can call the CZipArchive::RemoveCentralDirectoryFromArchive() method to force the central directory removal.
  • You can check, if the central directory is currently in the archive by requesting the central directory information with the CZipArchive::GetCentralDirInfo() method and then examining the CZipCentralDir::CInfo::m_bInArchive value.
• The central directory is written to the archive when the archive is closed, but you can also force this by calling the CZipArchive::Finalize() method.

    CZipArchive zip;
    zip.Open(_T("C:\\Temp\\test.zip"));
    int iIndexOfFile = 1;
    // read the local header information
    zip.ReadLocalHeader(iIndexOfFile);
    CZipFileHeader* pHeader = zip.GetFileInfo(iIndexOfFile);
    // set the time
    pHeader->SetTime(time(0));
    // write the local header information
    zip.OverwriteLocalHeader(iIndexOfFile);
    zip.RemoveCentralDirectoryFromArchive();
    // the central directory will be written back to the archive
    // during closing
    zip.Close();

Writing and Reading File and Archive Comments

The ZipArchive Library provides the following methods to write and read comments.

• To write a comment for a single file in an archive, use the CZipFileHeader::SetComment() method.
• To read a file comment from an existing archive, use the CZipFileHeader::GetComment() method.
• To write a comment for the whole archive, use the
  CZipArchive::SetGlobalComment() method.
• To read a global comment from an existing archive, use the
  CZipArchive::GetGlobalComment() method.
• The Unicode mode used will be the same as the Unicode mode for the filename (see Unicode Support: Using Non-English Characters in Filenames, Comments and Passwords for more information).

Controlling Windows System File Cache

When performing extensive file operations (especially on large files under a 64-bit system) you may notice that large amount of memory is being used. This is may be related to the growing size of Windows System File Cache. Resolving of the issue is beyond the scope of the ZipArchive Library, but here are possible solutions:

• Use SetSystemFileCacheSize Windows API function in your software (only Windows Server 2003 SP1 and newer).
• Use Microsoft Windows Dynamic Cache Service under 64-bit systems.
• Use NT Cache Setter by Uwe Sieber.

Some more information can be also found for example in these articles:

• Too Much Cache?
• Configure the file system cache in Windows NT