bitarchivereader.hpp

/*
 * bit7z - A C++ static library to interface with the 7-zip shared libraries.
 * Copyright (c) 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 "bit7zlibrary.hpp"
#include "bitabstractarchiveopener.hpp"
#include "bitarchiveiteminfo.hpp"
#include "bitdefines.hpp"
#include "bitexception.hpp"
#include "bitformat.hpp"
#include "bitinputarchive.hpp"
#include "bitpropvariant.hpp"
#include "bittypes.hpp"
 
#include <cstdint>
#include <istream>
#include <map>
#include <system_error>
#include <vector>
 
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,
            buffer_t&& inArchive,
            ArchiveStartOffset archiveStart,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
            const tstring& password = {}
        ) = delete;

        BitArchiveReader(
            const Bit7zLibrary& lib,
            const buffer_t& inArchive,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
            const tstring& password = {}
        );

        BitArchiveReader(
            const Bit7zLibrary& lib,
            buffer_t&& inArchive,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
            const tstring& password = {}
        ) = delete;

        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 Bit7zLibrary& lib,
            const BitInputArchive& inArchive,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
            const tstring& password = {}
        );

        BitArchiveReader(
            const Bit7zLibrary& lib,
            const BitInputArchive& inArchive,
            ArchiveStartOffset archiveStart,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
            const tstring& password = {}
        );

        BitArchiveReader(
            const Bit7zLibrary& lib,
            const BitInputArchive& inArchive,
            std::uint32_t subfileIndex,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
            const tstring& password = {}
        );

        BitArchiveReader(
            const Bit7zLibrary& lib,
            const BitInputArchive& inArchive,
            std::uint32_t subfileIndex,
            ArchiveStartOffset archiveStart,
            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 -> std::map< BitProperty, BitPropVariant >;

        BIT7Z_NODISCARD auto items() const -> std::vector< BitArchiveItemInfo >;

        BIT7Z_NODISCARD auto itemsMatching( const tstring& pattern ) const -> std::vector< BitArchiveItemInfo >;

        BIT7Z_NODISCARD auto foldersCount() const -> std::uint32_t;

        BIT7Z_NODISCARD auto filesCount() const -> std::uint32_t;

        BIT7Z_NODISCARD auto size() const -> std::uint64_t;

        BIT7Z_NODISCARD auto packSize() const -> std::uint64_t;

        BIT7Z_NODISCARD auto hasEncryptedItems() const -> bool;

        BIT7Z_NODISCARD auto isEncrypted() const -> bool;

        BIT7Z_NODISCARD auto volumesCount() const -> std::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
        ) noexcept -> bool {
            try {
                const BitArchiveReader reader{ lib, std::forward< T >( inArchive ), format };
                return false;
            } catch ( const BitException& exception ) {
                return isOpenEncryptedError( exception.code() );
            }
        }

        template< typename T >
        BIT7Z_NODISCARD
        static auto isEncrypted(
            const Bit7zLibrary& lib,
            T&& inArchive,
            const BitInFormat& format BIT7Z_DEFAULT_FORMAT
        ) noexcept -> bool {
            try {
                const BitArchiveReader reader{ lib, std::forward< T >( inArchive ), format };
                return reader.isEncrypted();
            } catch ( const BitException& exception ) {
                return isOpenEncryptedError( exception.code() );
            }
        }
 
    private:
        static auto isOpenEncryptedError( std::error_code error ) noexcept -> bool;
};
 
BIT7Z_DEPRECATED_TYPEDEF( BitArchiveInfo, BitArchiveReader, "Since v4.0. Please use BitArchiveReader." );
 
} // namespace bit7z
 
#endif // BITARCHIVEREADER_HPP