bitinputarchive.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 BITINPUTARCHIVE_HPP
#define BITINPUTARCHIVE_HPP
 
#include <array>
#include <map>
 
#include "bitabstractarchivehandler.hpp"
#include "bitarchiveitemoffset.hpp"
#include "bitformat.hpp"
#include "bitfs.hpp"
 
struct IInStream;
struct IInArchive;
struct IOutArchive;
 
namespace bit7z {
 
using std::vector;
 
enum struct ArchiveStartOffset : std::uint8_t {
    None, 
    FileStart 
};
 
class BitInputArchive {
    public:
        BitInputArchive( const BitAbstractArchiveHandler& handler,
                         const tstring& inFile,
                         ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitInputArchive( const BitAbstractArchiveHandler& handler,
                         const fs::path& arcPath,
                         ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitInputArchive( const BitAbstractArchiveHandler& handler,
                         const buffer_t& inBuffer,
                         ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitInputArchive( const BitAbstractArchiveHandler& handler,
                         std::istream& inStream,
                         ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitInputArchive( const BitInputArchive& ) = delete;
 
        BitInputArchive( BitInputArchive&& ) = delete;
 
        auto operator=( const BitInputArchive& ) -> BitInputArchive& = delete;
 
        auto operator=( BitInputArchive&& ) -> BitInputArchive& = delete;
 
        virtual ~BitInputArchive();
 
        BIT7Z_NODISCARD auto detectedFormat() const noexcept -> const BitInFormat&;
 
        BIT7Z_NODISCARD auto archiveProperty( BitProperty property ) const -> BitPropVariant;
 
        BIT7Z_NODISCARD auto itemProperty( uint32_t index, BitProperty property ) const -> BitPropVariant;
 
        BIT7Z_NODISCARD auto itemsCount() const -> uint32_t;
 
        BIT7Z_NODISCARD auto isItemFolder( uint32_t index ) const -> bool;
 
        BIT7Z_NODISCARD auto isItemEncrypted( uint32_t index ) const -> bool;
 
        BIT7Z_NODISCARD auto archivePath() const noexcept -> const tstring&;
 
        BIT7Z_NODISCARD auto handler() const noexcept -> const BitAbstractArchiveHandler&;
 
        void useFormatProperty( const wchar_t* name, const BitPropVariant& property ) const;
 
        template< typename T,
                  typename = typename std::enable_if< is_explicitly_convertible< T, BitPropVariant >::value >::type >
        void useFormatProperty( const wchar_t* name, T&& value ) const { // NOLINT(*-avoid-c-arrays)
            useFormatProperty( name, BitPropVariant{ std::forward< T >( value ) } );
        }
 
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        inline void extract( const tstring& outDir, const std::vector< uint32_t >& indices = {} ) const {
            extractTo( outDir, indices );
        }
 
        void extractTo( const tstring& outDir ) const;
 
        void extractTo( const tstring& outDir, const std::vector< uint32_t >& indices ) const;
 
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        inline void extract( std::vector< byte_t >& outBuffer, uint32_t index = 0 ) const {
            extractTo( outBuffer, index );
        }
 
        void extractTo( std::vector< byte_t >& outBuffer, uint32_t index = 0 ) const;
 
        template< std::size_t N >
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        void extract( std::array< byte_t, N >& buffer, uint32_t index = 0 ) const {
            extractTo( buffer.data(), buffer.size(), index );
        }
 
        template< std::size_t N >
        void extractTo( std::array< byte_t, N >& buffer, uint32_t index = 0 ) const {
            extractTo( buffer.data(), buffer.size(), index );
        }
 
        template< std::size_t N >
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        void extract( byte_t (& buffer)[N], uint32_t index = 0 ) const { // NOLINT(*-avoid-c-arrays)
            extractTo( buffer, N, index );
        }
 
        template< std::size_t N >
        void extractTo( byte_t (& buffer)[N], uint32_t index = 0 ) const { // NOLINT(*-avoid-c-arrays)
            extractTo( buffer, N, index );
        }
 
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        inline void extract( byte_t* buffer, std::size_t size, uint32_t index = 0 ) const {
            extractTo( buffer, size, index );
        }
 
        void extractTo( byte_t* buffer, std::size_t size, uint32_t index = 0 ) const;
 
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        inline void extract( std::ostream& outStream, uint32_t index = 0 ) const {
            extractTo( outStream, index );
        }
 
        void extractTo( std::ostream& outStream, uint32_t index = 0 ) const;
 
        BIT7Z_DEPRECATED_MSG("Since v4.0; please, use the extractTo method.")
        inline void extract( std::map< tstring, std::vector< byte_t > >& outMap ) const {
            extractTo( outMap );
        }
 
        void extractTo( std::map< tstring, std::vector< byte_t > >& outMap ) const;
 
        void test() const;
 
        void testItem( uint32_t index ) const;
 
    protected:
        auto initUpdatableArchive( IOutArchive** newArc ) const -> HRESULT;
 
        BIT7Z_NODISCARD auto close() const noexcept -> HRESULT;
 
        friend class BitAbstractArchiveOpener;
 
        friend class BitAbstractArchiveCreator;
 
        friend class BitOutputArchive;
 
    private:
        IInArchive* mInArchive;
        const BitInFormat* mDetectedFormat;
        const BitAbstractArchiveHandler& mArchiveHandler;
        tstring mArchivePath;
 
        BIT7Z_NODISCARD
        auto openArchiveStream( const fs::path& name, IInStream* inStream, ArchiveStartOffset startOffset ) -> IInArchive*;
 
    public:
        class ConstIterator {
            public:
                // iterator traits
                using iterator_category BIT7Z_MAYBE_UNUSED = std::input_iterator_tag;
                using value_type BIT7Z_MAYBE_UNUSED = BitArchiveItemOffset;
                using reference = const BitArchiveItemOffset&;
                using pointer = const BitArchiveItemOffset*;
                using difference_type BIT7Z_MAYBE_UNUSED = uint32_t; //so that count_if returns an uint32_t
 
                auto operator++() noexcept -> ConstIterator&;
 
                auto operator++( int ) noexcept -> ConstIterator; // NOLINT(cert-dcl21-cpp)
 
                auto operator==( const ConstIterator& other ) const noexcept -> bool;
 
                auto operator!=( const ConstIterator& other ) const noexcept -> bool;
 
                auto operator*() const noexcept -> reference;
 
                auto operator->() const noexcept -> pointer;
 
            private:
                BitArchiveItemOffset mItemOffset;
 
                ConstIterator( uint32_t itemIndex, const BitInputArchive& itemArchive ) noexcept;
 
                friend class BitInputArchive;
        };
 
        BIT7Z_DEPRECATED_TYPEDEF( const_iterator, ConstIterator, "Use ConstIterator" );
 
        BIT7Z_NODISCARD auto begin() const noexcept -> BitInputArchive::ConstIterator;
 
        BIT7Z_NODISCARD auto end() const noexcept -> BitInputArchive::ConstIterator;
 
        BIT7Z_NODISCARD auto cbegin() const noexcept -> BitInputArchive::ConstIterator;
 
        BIT7Z_NODISCARD auto cend() const noexcept -> BitInputArchive::ConstIterator;
 
        BIT7Z_NODISCARD auto find( const tstring& path ) const noexcept -> BitInputArchive::ConstIterator;
 
        BIT7Z_NODISCARD auto contains( const tstring& path ) const noexcept -> bool;
 
        BIT7Z_NODISCARD auto itemAt( uint32_t index ) const -> BitArchiveItemOffset;
 
};
 
}  // namespace bit7z
 
#endif //BITINPUTARCHIVE_HPP