bitarchivereader.hpp

/*
 * bit7z - A C++ static library to interface with the 7-zip shared libraries.
 * Copyright (c) 2014-2023 Riccardo Ostani - All Rights Reserved.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#ifndef BITARCHIVEREADER_HPP
#define BITARCHIVEREADER_HPP
 
#include "bitabstractarchiveopener.hpp"
#include "bitarchiveiteminfo.hpp"
#include "bitexception.hpp"
#include "bitinputarchive.hpp"
 
struct IInArchive;
struct IOutArchive;
struct IArchiveExtractCallback;
 
namespace bit7z {
 
class BitArchiveReader final : public BitAbstractArchiveOpener, public BitInputArchive {
    public:
        BitArchiveReader( const Bit7zLibrary& lib,
                          const tstring& inArchive,
                          ArchiveStartOffset archiveStart,
                          const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
                          const tstring& password = {} );
 
        BitArchiveReader( const Bit7zLibrary& lib,
                          const tstring& inArchive,
                          const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
                          const tstring& password = {} );
 
        BitArchiveReader( const Bit7zLibrary& lib,
                          const buffer_t& inArchive,
                          ArchiveStartOffset archiveStart,
                          const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
                          const tstring& password = {} );
 
        BitArchiveReader( const Bit7zLibrary& lib,
                          const std::vector< byte_t >& inArchive,
                          const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
                          const tstring& password = {} );
 
        BitArchiveReader( const Bit7zLibrary& lib,
                          std::istream& inArchive,
                          ArchiveStartOffset archiveStart,
                          const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
                          const tstring& password = {} );
 
        BitArchiveReader( const Bit7zLibrary& lib,
                          std::istream& inArchive,
                          const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
                          const tstring& password = {} );
 
        BitArchiveReader( const BitArchiveReader& ) = delete;
 
        BitArchiveReader( BitArchiveReader&& ) = delete;
 
        auto operator=( const BitArchiveReader& ) -> BitArchiveReader& = delete;
 
        auto operator=( BitArchiveReader&& ) -> BitArchiveReader& = delete;
 
        ~BitArchiveReader() override = default;
 
        BIT7Z_NODISCARD auto archiveProperties() const -> map< BitProperty, BitPropVariant >;
 
        BIT7Z_NODISCARD auto items() const -> vector< BitArchiveItemInfo >;
 
        BIT7Z_NODISCARD auto foldersCount() const -> uint32_t;
 
        BIT7Z_NODISCARD auto filesCount() const -> uint32_t;
 
        BIT7Z_NODISCARD auto size() const -> uint64_t;
 
        BIT7Z_NODISCARD auto packSize() const -> uint64_t;
 
        BIT7Z_NODISCARD auto hasEncryptedItems() const -> bool;
 
        BIT7Z_NODISCARD auto isEncrypted() const -> bool;
 
        BIT7Z_NODISCARD auto volumesCount() const -> uint32_t;
 
        BIT7Z_NODISCARD auto isMultiVolume() const -> bool;
 
        BIT7Z_NODISCARD auto isSolid() const -> bool;
 
        template< typename T >
        BIT7Z_NODISCARD
        static auto isHeaderEncrypted( const Bit7zLibrary& lib,
                                       T&& inArchive,
                                       const BitInFormat& format BIT7Z_DEFAULT_FORMAT ) -> bool {
            try {
                const BitArchiveReader reader{ lib, std::forward< T >( inArchive ), format };
                return false;
            } catch ( const BitException& ex ) {
                return isOpenEncryptedError( ex.code() );
            }
        }
 
        template< typename T >
        BIT7Z_NODISCARD
        static auto isEncrypted( const Bit7zLibrary& lib,
                                 T&& inArchive,
                                 const BitInFormat& format BIT7Z_DEFAULT_FORMAT ) -> bool {
            try {
                const BitArchiveReader reader{ lib, std::forward< T >( inArchive ), format };
                return reader.isEncrypted();
            } catch ( const BitException& ex ) {
                return isOpenEncryptedError( ex.code() );
            }
        }
 
    private:
        static auto isOpenEncryptedError( std::error_code error ) -> bool;
};
 
BIT7Z_DEPRECATED_TYPEDEF( BitArchiveInfo, BitArchiveReader, "Since v4.0; please use BitArchiveReader." );
 
}  // namespace bit7z
 
#endif // BITARCHIVEREADER_HPP