bit7z
v4.0.8
Fonctionnalités prises
Bit7Z est une bibliothèque statique C ++ multiplateforme qui permet la compression / extraction des fichiers d'archives via une interface de wrapper propre et simple aux bibliothèques dynamiques du projet 7-Zip.
Il prend en charge la compression et l'extraction vers et depuis le système de fichiers ou la mémoire, en lisant les métadonnées des archives, en mettant à jour ceux existants, en créant des archives multi-volumes, des rappels de progression de l'opération et de nombreuses autres fonctionnalités.
La présence ou non de certaines des fonctionnalités ci-dessus dépend de la bibliothèque partagée particulière utilisée avec Bit7Z.
Par exemple, 7Z.dll devrait prendre en charge toutes ces fonctionnalités, 7ZA.DLL ne devrait fonctionner qu'avec le format de fichier 7Z, et 7Zxa.dll ne peut que extraire les fichiers 7Z. Pour plus d'informations sur les DLL 7-zip, veuillez consulter cette page wiki.
En fin de compte, certaines autres fonctionnalités (par exemple, détection de format automatique et extraction sélective à l'aide d'expressions régulières ) sont désactivées par défaut, et les définitions de macro doivent être utilisées pendant la compilation pour les avoir disponibles (wiki).
Voici quelques exemples qui montrent comment utiliser certaines des principales caractéristiques de Bit7Z.
# include < bit7z/bitfileextractor.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
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()... */ }Alternativement, si vous n'avez besoin que de travailler sur une seule archive:
# include < bit7z/bitarchivereader.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
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()... */ }# include < bit7z/bitfilecompressor.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
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()... */ }Alternativement, si vous n'avez besoin que de travailler sur une seule archive:
# include < bit7z/bitarchivewriter.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
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()... */ }# include < bit7z/bitarchivereader.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
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 () << " nn " ;
// Printing the metadata of the archived items
std::cout << " Archived items " ;
for ( const auto & 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()... */ }Une référence API complète est disponible dans la section Wiki.
Le plus récent Bit7Z V4 a introduit des changements de rupture significatifs à l'API de la bibliothèque.
std::string (au lieu de std::wstring ), afin que les utilisateurs puissent utiliser la bibliothèque dans des projets multiplateformes plus facilement (V4 a également introduit le support Linux / MacOS).std::string S sera considérée comme UTF-8 encodée.-DBIT7Z_USE_NATIVE_STRING cmake.BitExtractor est maintenant appelée BitFileExtractor .BitExtractor est juste le nom d'une classe de modèle pour toutes les classes d'extraction.BitCompressor s'appelle maintenant BitFileCompressor .BitCompressor n'est que le nom d'une classe de modèle pour toutes les classes de compression.ProgressCallback doit désormais renvoyer une valeur bool indiquant si l'opération actuelle peut continuer ( true ) ou non ( false ).include/ to to to the include/bit7z/ , donc #include les directives doivent désormais représenter bit7z/ au nom d'en-tête inclus (par exemple, #include <bit7z/bitfileextractor.hpp> ).lib/<architecture>/ ; Si le générateur CMake est multi-config (par exemple, Générateurs Visual Studio), le dossier de sortie par défaut est lib/<architecture>/<build type>/ .BIT7Z_VS_LIBNAME_OUTDIR_STYLE Cmake.Chaque package publié contient:
Des forfaits sont disponibles pour les architectures x86 et x64 .
Vous pouvez également cloner / télécharger ce référentiel et créer vous-même la bibliothèque (s'il vous plaît, lisez le wiki).
.dll sur Windows, une bibliothèque 7-zip / p7zip .so sur Unix 3 . Pour construire la bibliothèque:
cd < bit7z folder >
mkdir build && cd build
cmake ../ -DCMAKE_BUILD_TYPE=Release
cmake --build . -j --config ReleaseUn guide plus détaillé sur la façon de créer cette bibliothèque est disponible ici.
Vous pouvez également intégrer directement la bibliothèque dans votre projet via Cmake:
third_party ), ou ajoutez-le comme un sous-module Git de votre référentiel.add_subdirectory() dans votre CMakeLists.txt pour inclure Bit7z.bit7z à l'aide de la commande target_link_libraries() .Par exemple:
add_subdirectory ( ${CMAKE_SOURCE_DIR} /third_party/bit7z )
target_link_libraries ( ${YOUR_TARGET} PRIVATE bit7z )La bibliothèque est hautement personnalisable: pour une liste détaillée des options de construction disponibles, veuillez vous référer au wiki.
Lors de la configuration de Bit7Z via CMake, il télécharge automatiquement la dernière version de 7-zip prise en charge par la bibliothèque.
Facultativement, vous pouvez spécifier une version différente de 7-Zip via l'option CMake BIT7Z_7ZIP_VERSION (par exemple, -DBIT7Z_7ZIP_VERSION="22.01" ).
Alternativement, vous pouvez spécifier un chemin personnalisé contenant le code source 7-zip via l'option BIT7Z_CUSTOM_7ZIP_PATH .
Veuillez noter que, en général, il est préférable d'utiliser la même version de 7-Zip des bibliothèques partagées que vous utiliserez lors de l'exécution.
Par défaut, Bit7Z est compatible avec le 7z.so de 7-zip v23.01 et ultérieurement.
Si vous prévoyez d'utiliser le 7z.so de P7ZIP ou 7-ZIP V22.01 et plus tôt à la place, vous avez deux façons de rendre Bit7Z compatible:
-DBIT7Z_USE_LEGACY_IUNKNOWN=ON ; ou-DBIT7Z_7ZIP_VERSION="22.01" ).Sur Linux et MacOS , 7-Zip V23.01 a introduit des modifications de rupture de l'interface iunknown. En conséquence, si vous créez Bit7Z pour une telle version de 7-Zip (la valeur par défaut), elle ne prendra pas en charge l'utilisation des bibliothèques partagées des versions précédentes de 7-Zip (ou de P7ZIP). À l'inverse, Bit7Z a fait des versions antérieures de 7-Zip ou pour P7ZIP est incompatible avec les bibliothèques partagées du 7-ZIP V23.01 et plus tard.
Vous pouvez construire les bibliothèques partagées de 7-Zip V23.01 dans un mode compatible en arrière en définissant la macro Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN . Si tel est votre cas, vous devrez activer le BIT7Z_USE_LEGACY_IUNKNOWN pour que Bit7z fonctionne (dans ce cas, Bit7Z sera également compatible avec les versions précédentes de 7-Zip / P7Zip).
Par défaut, Bit7z suit le manifeste UTF-8 Everywhere pour simplifier l'utilisation de la bibliothèque dans des projets multiplateformes. Bref, cela signifie que:
std::string .std::string s est considéré comme UTF-8 encodé; SORTIE std::string S est encodé UTF-8. Sur les systèmes POSIX, std::string S est généralement déjà encodé UTF-8 et aucune configuration n'est nécessaire.
La situation est un peu plus complexe sur Windows car, par défaut, Windows traite std::string S comme encodé à l'aide de la page du code système, qui ne peut pas nécessairement être UTF-8, comme, par exemple, Windows-1252.
Si votre programme traite exclusivement avec les chaînes ASCII uniquement, vous devriez être bien avec les paramètres Bit7Z par défaut (car les caractères ASCII sont également UTF-8).
Cependant, si vous devez gérer les caractères non ASCII / UNICODE, comme il est probable, vous avez les options suivantes:
Appliquer l'utilisation de la page de code UTF-8 pour l'ensemble de votre application, comme expliqué par Microsoft ici:
Assurer manuellement le codage de la std::string S à Bit7z:
ReadConsoleW ), et convertissez-la en UTF-8 (Bit7Z fournit une fonction utilitaire pour cela, bit7z::to_tstring ).SetConsoleOutputCP(CP_UTF8) avant. Configuration de Bit7Z pour utiliser UTF-16 encodées larges codées (c'est-à-dire, std::wstring ) en activant l'option BIT7Z_USE_NATIVE_STRING via cmake.
Si votre programme est uniquement Windows ou si vous utilisez déjà de larges chaînes sur Windows, cela pourrait être le meilleur choix car il évitera toute conversion de chaîne interne (7-Zip utilise toujours des chaînes larges).
Cette option rend le développement des applications multiplateforme légèrement gênantes car vous devrez toujours utiliser std::string sur les systèmes POSIX.
La bibliothèque fournit un type alias bit7z::tstring et une fonction macro BIT7Z_STRING pour définir des variables de chaîne larges et des littéraux sur les fenêtres et des plates-formes étroites sur d'autres plates-formes.
Vous devez définir par programme le codage standard des entrées et de la sortie sur UTF-16 pour lire et imprimer correctement les caractères Unicode:
# 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 Configuration de Bit7Z Pour utiliser le codage de la page du code système pour std::string en activant l'option BIT7Z_USE_SYSTEM_CODEPAGE via Cmake.
Si vous avez trouvé ce projet utile, veuillez envisager de me soutenir avec un petit don afin que je puisse continuer à l'améliorer! Merci!
Ce projet est concédé sous licence de la licence publique de Mozilla v2.0.
Pour plus de détails, veuillez vérifier:
Les versions anciennes (v3.x et antérieure) de Bit7z ont été libérées sous la licence publique générale GNU v2.
Sur Windows, vous devez également lier votre programme à Oleaut32 (par exemple, -lbit7z -loleaut32 ).
Sur Linux et MacOS, vous devez également lier votre programme avec DL (par exemple, -lbit7z -ldl ).
Si vous utilisez la bibliothèque via CMake, ces dépendances seront automatiquement liées à votre projet. ↩
MSVC 2010 a été pris en charge jusqu'à V2.x, MSVC 2012/2013 jusqu'à V3.x. ↩
Bit7z n'en est pas expédié avec les bibliothèques partagées 7-zip. Vous pouvez les construire à partir du code source disponible sur 7-zip.org. ↩
