Movatterモバイル変換


[0]ホーム

URL:


Skip to content

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

Sign up

A C++ static library offering a clean and simple interface to the 7-zip shared libraries.

License

NotificationsYou must be signed in to change notification settings

rikyoz/bit7z

Repository files navigation

A C++ static library offering a clean and simple interface to the 7-Zip shared libraries.

Supported FeaturesGetting StartedDownloadRequirementsInstallationConfigurationDonateLicense

GitHub releaseC++14WindowsLinuxmacOSBSDx86, x64, arm, arm64donatedocsBuild status
MSVC 2015+GCC 4.9+Clang 3.6+CodeFactor GradeLicense

⚡️ Introduction

bit7z is across-platform C++ static library that allows thecompression/extraction of archive files through aclean andsimple wrapper interface to the dynamic libraries from the7-Zip project.
It supports compression and extraction to and from the filesystem or the memory, reading archives metadata, updating existing ones, creating multi-volume archives, operation progress callbacks, and many other functionalities.

🎯 Supported Features

  • Compression using the following archive formats:7z, XZ,BZIP2,GZIP, TAR,ZIP, and WIM.
  • Extraction of many archive formats:7z, AR, ARJ,BZIP2, CAB, CHM, CPIO, CramFS, DEB, DMG, EXT, FAT, GPT,GZIP, HFS, HXS, IHEX, ISO, LZH, LZMA, MBR, MSI, NSIS, NTFS, QCOW2,RAR,RAR5, RPM, SquashFS, TAR, UDF, UEFI, VDI, VHD, VMDK, WIM, XAR, XZ, Z, andZIP.
  • Reading metadata of archives and their content.
  • Testing archives for errors.
  • Updating existing file archives with new files.
  • Renaming,updating, ordeleting old items in existing file archives.
  • Compression and extractionto and from memory andC++ standard streams.
  • Compression usingcustom path aliases for the items in the output archives.
  • Selective extraction of only specified files/foldersusing wildcards andregular expressions.
  • Creation ofencrypted archives (strong AES-256 encryption; only for 7z and ZIP formats).
  • Archive header encryption (only for 7z format).
  • Possibility to choose thecompression level (if supported by the archive format), thecompression method (supported methods), thedictionary size, and theword size.
  • Automatic input archive format detection.
  • Solid archives (only for 7z).
  • Multi-volume archives.
  • Operation callbacks for obtaining real-time information about ongoing operations.
  • Canceling orpausing the current operation.

Note

The presence or not of some of the above features depends on the specific 7-Zip shared library used.

For example, 7z.dll should support all these features, 7za.dll should work only with the 7z file format, and 7zxa.dll can only extract 7z files.

For more information about the 7-Zip DLLs, please check thiswiki page.

Note

Some features (e.g.,automatic format detection andselective extraction using regular expressions) are disabled by default, and macro definitions must be used during compilation to have them available (wiki).

🔥 Getting Started (Library Usage)

Below are a few examples that show how to use some of the main features of bit7z.

📂 Extracting Files from an Archive

#include<bit7z/bitfileextractor.hpp>try {// bit7z classes can throw BitException objectsusingnamespacebit7z;    Bit7zLibrary lib{"7za.dll" };    BitFileExtractor extractor{ lib, BitFormat::SevenZip };// Extracting a simple archive    extractor.extract("path/to/archive.7z","out/dir/" );// Extracting a specific file inside an archive    extractor.extractMatching("path/to/archive.7z","file.pdf","out/dir/" );// Extracting the first file of an archive to a buffer    std::vector<byte_t > buffer;    extractor.extract("path/to/archive.7z", buffer );// Extracting an encrypted archive    extractor.setPassword("password" );    extractor.extract("path/to/another/archive.7z","out/dir/" );}catch (const bit7z::BitException& ex ) {/* Do something with ex.what()...*/ }

Alternatively, if you only need to work on a single archive:

#include<bit7z/bitarchivereader.hpp>try {// bit7z classes can throw BitException objectsusingnamespacebit7z;    Bit7zLibrary lib{"7z.dll" };// Opening the archive    BitArchiveReader archive{ lib,"path/to/archive.gz", BitFormat::GZip };// Testing the archive    archive.test();// Extracting the archive    archive.extractTo("out/dir/" );}catch (const bit7z::BitException& ex ) {/* Do something with ex.what()...*/ }

💼 Compressing Files into an Archive

#include<bit7z/bitfilecompressor.hpp>try {// bit7z classes can throw BitException objectsusingnamespacebit7z;    Bit7zLibrary lib{"7z.dll" };    BitFileCompressor compressor{ lib, BitFormat::Zip };    std::vector< std::string > files = {"path/to/file1.jpg","path/to/file2.pdf" };// Creating a simple zip archive    compressor.compress( files,"output_archive.zip" );// Creating a zip archive with a custom directory structure    std::map< std::string, std::string > files_map = {        {"path/to/file1.jpg","alias/path/file1.jpg" },        {"path/to/file2.pdf","alias/path/file2.pdf" }    };    compressor.compress( files_map,"output_archive2.zip" );// Compressing a directory    compressor.compressDirectory("dir/path/","dir_archive.zip" );// Creating an encrypted zip archive of two files    compressor.setPassword("password" );    compressor.compressFiles( files,"protected_archive.zip" );// Updating an existing zip archive    compressor.setUpdateMode( UpdateMode::Append );    compressor.compressFiles( files,"existing_archive.zip" );// Compressing a single file into a buffer    std::vector< bit7z::byte_t > buffer;    BitFileCompressor compressor2{ lib, BitFormat::BZip2 };    compressor2.compressFile( files[0], buffer );}catch (const bit7z::BitException& ex ) {/* Do something with ex.what()...*/ }

Alternatively, if you only need to work on a single archive:

#include<bit7z/bitarchivewriter.hpp>try {// bit7z classes can throw BitException objectsusingnamespacebit7z;    Bit7zLibrary lib{"7z.dll" };    BitArchiveWriter archive{ lib, BitFormat::SevenZip };// Adding the items to be compressed (no compression is performed here)    archive.addFile("path/to/file.txt" );    archive.addDirectory("path/to/dir/" );// Compressing the added items to the output archive    archive.compressTo("output.7z" );}catch (const bit7z::BitException& ex ) {/* Do something with ex.what()...*/ }

📑 Reading Archive Metadata

#include<bit7z/bitarchivereader.hpp>try {// bit7z classes can throw BitException objectsusingnamespacebit7z;    Bit7zLibrary lib{"7za.dll" };    BitArchiveReader arc{ lib,"archive.7z", BitFormat::SevenZip };// Printing archive metadata    std::cout <<"Archive properties\n";    std::cout <<"  Items count:"   << arc.itemsCount() <<'\n';    std::cout <<"  Folders count:" << arc.foldersCount() <<'\n';    std::cout <<"  Files count:"   << arc.filesCount() <<'\n';    std::cout <<"  Size:"          << arc.size() <<'\n';    std::cout <<"  Packed size:"   << arc.packSize() <<"\n\n";// Printing the metadata of the archived items    std::cout <<"Archived items";for (constauto& item : arc ) {        std::cout <<'\n';        std::cout <<"  Item index:"    << item.index() <<'\n';        std::cout <<"    Name:"        << item.name() <<'\n';        std::cout <<"    Extension:"   << item.extension() <<'\n';        std::cout <<"    Path:"        << item.path() <<'\n';        std::cout <<"    IsDir:"       << item.isDir() <<'\n';        std::cout <<"    Size:"        << item.size() <<'\n';        std::cout <<"    Packed size:" << item.packSize() <<'\n';        std::cout <<"    CRC:" << std::hex << item.crc() << std::dec <<'\n';    }    std::cout.flush();}catch (const bit7z::BitException& ex ) {/* Do something with ex.what()...*/ }

A completeAPI reference is available in thewiki section.

🚀 Upgrading from bit7z v3 to v4

The newest bit7z v4 introduced some significant breaking changes to the library's API.

Expand for more details!
  • By default, the project now follows theUTF-8 Everywhere Manifesto:

    • The default string type isstd::string (instead ofstd::wstring), so users can use the library in cross-platform projects more easily (v4 introduced Linux/macOS support too).
    • Inputstd::strings will be considered as UTF-8 encoded.
    • You can still achieve the old behavior on Windows using the-DBIT7Z_USE_NATIVE_STRING CMake option.
  • The oldBitExtractor class is now calledBitFileExtractor.

    • NowBitExtractor is just the name of a template class for all the extraction classes.
  • The oldBitCompressor class is now calledBitFileCompressor.

    • NowBitCompressor is just the name of a template class for all the compression classes.
  • The oldBitArchiveInfo class is now calledBitArchiveReader, and it allows to extract single archives.

  • TheProgressCallback now must return abool value indicating whether the current operation can continue (true) or not (false).

  • TheBitException class now inherits fromstd::system_error rather thanstd::runtime_error.

    • The methodBitException::getErrorCode() was renamedBitException::hresultCode().
  • The project structure changed:

    • Public API headers moved frominclude/ to theinclude/bit7z/ folder, so#include directives now need to prependbit7z/ to the included header name (e.g.,#include <bit7z/bitfileextractor.hpp>).
      • Even though it is a bit verbose, it is a typical structure for C and C++ libraries, and it makes explicit which third-party library a header file belongs to.
    • By default, the output folder of bit7z is nowlib/<architecture>/; if the CMake generator is multi-config (e.g., Visual Studio generators), the default output folder islib/<architecture>/<build type>/.
      • Optionally, you can force using the "Visual Studio style" output path by enabling theBIT7Z_VS_LIBNAME_OUTDIR_STYLE CMake option.
    • Third-party dependencies are no longer handled using git submodules but are automatically downloaded usingCPM.cmake when configuring/using the library via CMake.

💾 Download

GitHub Latest Release
GitHub All Releases

Each released package contains:

  • Apre-compiled version of bit7z (both indebug andrelease mode);
  • Thepublic API headers needed to use the library in your program;

Packages are available for bothx86 andx64 architectures.

You can also clone/download this repository and build the library yourself (please, read thewiki).

🧰 Requirements

  • Operating System: Windows, Linux, macOS, Android.
  • Architecture: x86, x86_64, arm, arm64.
  • Language Standard: C++11 (for using the library), C++14 (for building the library).
  • Compiler: MSVC 2015 or later1, MinGW v6.4 or later, GCC v4.9 or later, Clang 3.6 or later.
  • Shared Library: a 7-Zip.dll library on Windows, a 7-Zip/p7zip.so library on Unix.

Note

  • RAR Archive Support: The library supports RAR archivesonly when using 7-Zip's7z.dll/7z.so. It doesn't support p7zip's unrar plugin. For RAR extraction on Unix-based systems, you need to build the 7-Zip7z.so library.
  • 7-Zip Libraries: Bit7z doesnot ship with the 7-Zip shared libraries. You can download the precompiled binaries or build them from the source at7-zip.org.

🔗 Installation

The library can be installed as a dependency of your project in a number of different ways:

Using CMake'sadd_subdirectory

You can directly integrate the library into your CMake project:

  • Either download bit7z's sources to a sub-directory of your project (e.g.,third_party), or add this repository as a git submodule of yours.
  • Then, use the commandadd_subdirectory() in yourCMakeLists.txt to include bit7z.
  • Finally, link thebit7z library using thetarget_link_libraries() command.

For example:

add_subdirectory(${CMAKE_SOURCE_DIR}/third_party/bit7z)# Path to bit7z's repository# Here you can enable/disable bit7z's build options, e.g.:# set(BIT7Z_USE_NATIVE_STRING ON CACHE BOOL "enable using native OS strings" FORCE)target_link_libraries(${YOUR_TARGET}PRIVATE bit7z)
CPMAddPackage("gh:rikyoz/bit7z@<version>")# Replace <version> with the desired one.# Here you can enable/disable bit7z's build options, e.g.:# set(BIT7Z_AUTO_FORMAT ON CACHE BOOL "enable auto format support" FORCE)target_link_libraries(${YOUR_TARGET}PRIVATE bit7z)

Usingvcpkg

First, you need to install the library:

vcpkg install bit7z

Then, you add bit7z as a dependency in your project'sCMakeLists.txt:

find_package(unofficial-bit7z CONFIG REQUIRED)target_link_libraries(${YOUR_TARGET}PRIVATE unofficial::bit7z::bit7z64)

Building from source and manually linking

The wiki provides instructions on how tobuild the library from the source code andmanually link it into your project.

🛠️ Configuration

The library is highly customizable: for a detailed list of the available build options, please refer to thewiki.

📌 7-Zip Version

While configuring bit7z via CMake, it automatically downloads the latest version of 7-Zip supported by the library.

Optionally, you can specify a different version of 7-Zip via the CMake optionBIT7Z_7ZIP_VERSION (e.g.,-DBIT7Z_7ZIP_VERSION="22.01").

Alternatively, you can specify a custom path containing the 7-Zip source code via the optionBIT7Z_CUSTOM_7ZIP_PATH.

Note

In general, it is best to use the same version of 7-Zip of the shared libraries that you will use at runtime.

Using 7-Zip v23.01 on Linux and macOS

By default, bit7z is compatible with the7z.so from 7-Zip v23.01 and later.

If you plan to use the7z.so from p7zip or 7-Zip v22.01 and earlier instead, you have two ways to make bit7z compatible:

  • Configure bit7z with the CMake option-DBIT7Z_USE_LEGACY_IUNKNOWN=ON;or
  • Configure bit7z for 7-Zip v22.01 (i.e.,-DBIT7Z_7ZIP_VERSION="22.01").
Expand for more details_On Linux and macOS_, 7-Zip v23.01 introduced breaking changes to the IUnknown interface.As a result, if you build bit7z for such a version of 7-Zip (the default), it will not support using the shared libraries from previous versions of 7-Zip (or from p7zip).Conversely, bit7z made for earlier versions of 7-Zip or for p7zip is incompatible with the shared libraries from 7-Zip v23.01 and later.

You can build the shared libraries of 7-Zip v23.01 in a backward-compatible mode by defining the macroZ7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN.If this is your case, you'll need to enable theBIT7Z_USE_LEGACY_IUNKNOWN to make bit7z work (in this case, bit7z will be compatible also with previous versions of 7-Zip/p7zip).

🗺️ String Encoding

By default, bit7z follows theUTF-8 Everywhere Manifesto to simplify the use of the library within cross-platform projects.In short, this means that:

  • The default path string type isstd::string.
  • Inputstd::strings are considered as UTF-8 encoded; outputstd::strings are UTF-8 encoded.
Expand for more details and for other string encoding options!

On POSIX systems,std::strings are usually already UTF-8 encoded, and no configuration is needed.

The situation is a bit more complex on Windows since, by default, Windows treatsstd::strings as encoded using the system code page, which may not necessarily be UTF-8, like, for example,Windows-1252.

If your program deals exclusively with ASCII-only strings, you should be fine with the default bit7z settings (as ASCII characters are also UTF-8).

However, if you need to handle non-ASCII/Unicode characters, as it is likely, you have the following options:

  • Enforcing using the UTF-8 code page for your whole application, as explained by Microsofthere:

    • Recommended, but supported only since Windows 10 1903 and later.
  • Manually ensuring the encoding of thestd::strings passed to bit7z:

    • You can use some string encoding library or C++11's UTF-8 string literals for input strings.
    • User-input strings (e.g., the password of an archive) can be handled as explainedhere; in short: read the input as an UTF-16 wide string (e.g., viaReadConsoleW), and convert it to UTF-8 (bit7z provides a utility function for this,bit7z::to_tstring).
    • You can correctly print the UTF-8 output strings from bit7z (e.g., the path/name metadata of a file in an archive) to the console by callingSetConsoleOutputCP(CP_UTF8) before.
  • Configuring bit7z to use UTF-16 encoded wide strings (i.e.,std::wstring) by enabling theBIT7Z_USE_NATIVE_STRING option via CMake.

    • If your program is Windows-only, or you already use wide strings on Windows, this might be the best choice since it will avoid any internal string conversions (7-Zip always uses wide strings).

    • This option makes developing cross-platform applications slightly inconvenient since you'll still have to usestd::string on POSIX systems.

    • The library provides a type aliasbit7z::tstring and a macro functionBIT7Z_STRING for defining wide string variables and literals on Windows and narrow ones on other platforms.

    • You must programmatically set the standard input and output encoding to UTF-16 to correctly read and print Unicode characters:

      #include<fcntl.h>//for _O_U16TEXT#include<io.h>//for _setmode_setmode(_fileno(stdout), _O_U16TEXT);// setting the stdout encoding to UTF16_setmode(_fileno(stdin), _O_U16TEXT);// setting the stdin encoding to UTF16
  • Configuring bit7z to use the system code page encoding forstd::string by enabling theBIT7Z_USE_SYSTEM_CODEPAGE option via CMake.

    • Not recommended: using this option, your program will be limited in the set of characters it can pass to and read from bit7z.

☕️ Donate

If you have found this project helpful, please consider supporting me with a small donation so that I can keep improving it!Thank you! 🙏

Sponsor me on GitHubBuy Me a Coffee at ko-fi.comDonations

📜 License

This project is licensed under the terms of theMozilla Public License v2.0.
For more details, please check:

Older versions (v3.x and earlier) of bit7z were released under theGNU General Public License v2.


Copyright © 2014 - 2024 Riccardo Ostani (@rikyoz)

Footnotes

  1. MSVC 2010 was supported until v2.x, MSVC 2012/2013 until v3.x.


[8]ページ先頭

©2009-2025 Movatter.jp