bitinputarchive.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 BITINPUTARCHIVE_HPP
#define BITINPUTARCHIVE_HPP
 
#include "bit7zlibrary.hpp"
#include "bitabstractarchivehandler.hpp"
#include "bitarchiveitemoffset.hpp"
#include "bitdefines.hpp"
#include "bitformat.hpp"
#include "bitfs.hpp"
#include "bitindicesview.hpp"
#include "bitpropvariant.hpp"
#include "bittypes.hpp"
#include "bitwindows.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <istream>
#include <map>
#include <ostream>
#include <vector>
 
struct IInStream;
struct IInArchive;
struct IOutArchive;
struct ISequentialInStream;
 
namespace bit7z {
 
class BufferQueue;
class ExtractCallback;
class OpenCallback;

enum struct ArchiveStartOffset : std::uint8_t {
    None,   
    FileStart 
};

enum struct FolderPathPolicy : std::uint8_t {
    Strip,      
    KeepName,   
    KeepPath,   
};

class BitInputArchive {
    public:
        BitInputArchive(
            const BitAbstractArchiveHandler& handler,
            const tstring& inFile,
            ArchiveStartOffset startOffset = ArchiveStartOffset::None
        );

        BitInputArchive(
            const BitAbstractArchiveHandler& handler,
            const bit7zfs::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( std::uint32_t index, BitProperty property ) const -> BitPropVariant;

        BIT7Z_NODISCARD auto itemHasProperty( std::uint32_t index, BitProperty property ) const -> bool;

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

        BIT7Z_NODISCARD auto isItemFolder( std::uint32_t index ) const -> bool;

        BIT7Z_NODISCARD auto isItemEncrypted( std::uint32_t index ) const -> bool;

        BIT7Z_NODISCARD auto archivePath() const noexcept -> const tstring&;

        BIT7Z_NODISCARD auto archiveHasPath() const noexcept -> bool;

        BIT7Z_NODISCARD auto rootFolder() 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." )
        void extract( const tstring& outDir, const IndicesVector& indices = {} ) const {
            extractTo( outDir, indices );
        }

        void extractTo( const tstring& outDir, BitIndicesView indices = {} ) const;

        void extractMatchingTo(
            const tstring& outDir,
            const tstring& itemFilter,
            FilterPolicy policy = FilterPolicy::Include
        ) const;
 
#ifdef BIT7Z_REGEX_MATCHING
        void extractMatchingRegexTo(
            const tstring& outDir,
            const tstring& regex,
            FilterPolicy policy = FilterPolicy::Include
        ) const;

        void extractMatchingTo(
            const tstring& outDir,
            const tregex& regex,
            FilterPolicy policy = FilterPolicy::Include
        ) const;
#endif

        void extractTo( const tstring& outDir, FilterCallback filterCallback ) const;

        void extractTo( const tstring& outDir, RenameCallback renameCallback ) const;
 
        BIT7Z_DEPRECATED_MSG(
            "Since v4.1; the RenameCallback now receives the BitArchiveItem being extracted. "
            "The (index, path) form will be removed in v4.2."
        )
        void extractTo( const tstring& outDir, LegacyRenameCallback renameCallback ) const;

        void extractFolderTo(
            const tstring& outDir,
            const tstring& folderPath,
            FolderPathPolicy policy = FolderPathPolicy::Strip
        ) const;

        void extractRootFolderContentTo(
            const tstring& outDir
        ) const;
 
        BIT7Z_DEPRECATED_MSG( "Since v4.0; please, use the extractTo method." )
        void extract( buffer_t& outBuffer, std::uint32_t index = 0 ) const {
            extractTo( outBuffer, index );
        }

        void extractTo( buffer_t& outBuffer, std::uint32_t index = 0 ) const;

        void extractMatchingTo(
            buffer_t& outBuffer,
            const tstring& itemFilter,
            FilterPolicy policy = FilterPolicy::Include
        ) const;
 
#ifdef BIT7Z_REGEX_MATCHING
        void extractMatchingRegexTo(
            buffer_t& outBuffer,
            const tstring& regex,
            FilterPolicy policy = FilterPolicy::Include
        ) const;

        void extractMatchingTo(
            buffer_t& outBuffer,
            const tregex& regex,
            FilterPolicy policy = FilterPolicy::Include
        ) const;
#endif

        void extractTo( buffer_t& outBuffer, FilterCallback filterCallback ) 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, std::uint32_t index = 0 ) const {
            extractTo( buffer.data(), buffer.size(), index );
        }

        template< std::size_t N >
        void extractTo( std::array< byte_t, N >& outBuffer, std::uint32_t index = 0 ) const {
            extractTo( outBuffer.data(), outBuffer.size(), index );
        }
 
        template< std::size_t N >
        BIT7Z_DEPRECATED_MSG( "Since v4.0; please, use the extractTo method." )
        void extract( byte_t (&buffer)[ N ], std::uint32_t index = 0 ) const { // NOLINT(*-avoid-c-arrays)
            extractTo( buffer, N, index );
        }

        template< std::size_t N >
        void extractTo( byte_t (&outBuffer)[ N ], std::uint32_t index = 0 ) const { // NOLINT(*-avoid-c-arrays)
            extractTo( outBuffer, N, index );
        }
 
        BIT7Z_DEPRECATED_MSG( "Since v4.0; please, use the extractTo method." )
        void extract( byte_t* buffer, std::size_t size, std::uint32_t index = 0 ) const {
            extractTo( buffer, size, index );
        }

        void extractTo( byte_t* outBuffer, std::size_t size, std::uint32_t index = 0 ) const;
 
        BIT7Z_DEPRECATED_MSG( "Since v4.0; please, use the extractTo method." )
        void extract( std::ostream& outStream, std::uint32_t index = 0 ) const {
            extractTo( outStream, index );
        }

        void extractTo( std::ostream& outStream, std::uint32_t index = 0 ) const;
 
        BIT7Z_DEPRECATED_MSG( "Since v4.0; please, use the extractTo method." )
        void extract( std::map< tstring, buffer_t >& outMap ) const {
            extractTo( outMap );
        }

        void extractTo( std::map< tstring, buffer_t >& outMap ) const;

        void extractTo( BufferCallback callback, BitIndicesView indices = {} ) const;

        void extractTo( RawDataCallback callback, BitIndicesView indices = {} ) const;

        void test( BitIndicesView indices = {} ) const;

        void testItem( std::uint32_t index ) const;

        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 = std::uint32_t; //so that count_if returns an std::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( std::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 findByName( const tstring& name ) const noexcept -> BitInputArchive::ConstIterator;

        BIT7Z_NODISCARD auto contains( const tstring& path ) const noexcept -> bool;

        BIT7Z_NODISCARD auto itemAt( std::uint32_t index ) const -> BitArchiveItemOffset;

        BIT7Z_NODISCARD auto mainSubfileIndex() const -> std::uint32_t;
 
    protected:
        explicit BitInputArchive(
            const BitAbstractArchiveHandler& handler,
            const BitInputArchive& parentArchive,
            std::uint32_t subfileIndex,
            ArchiveStartOffset archiveStart
        );
 
        BIT7Z_NODISCARD
        auto initUpdatableArchive( IOutArchive** newArc ) const -> HRESULT;
 
        void openArchiveSeqStream( ISequentialInStream* inStream ) const;
 
        BIT7Z_NODISCARD
        auto getSubfileStream( std::uint32_t index ) const -> CMyComPtr< IInStream >;
 
        void extractSequentially( BufferQueue& queue, std::uint32_t index ) const;
 
        void extractArchive( ExtractCallback* callback, std::int32_t mode, BitIndicesView indices = {} ) const;
 
        BIT7Z_NODISCARD
        auto isInvalidIndex( std::uint32_t index ) const -> bool;
 
        BIT7Z_NODISCARD
        auto findInvalidIndex( BitIndicesView indices ) const -> BitIndicesView::const_iterator;
 
        BIT7Z_NODISCARD
        auto close() const noexcept -> HRESULT;
 
    private:
        IInArchive* mInArchive;
        const BitInFormat* mDetectedFormat;
        const BitAbstractArchiveHandler& mArchiveHandler;
        tstring mArchivePath;
 
        explicit BitInputArchive( const BitAbstractArchiveHandler& handler, const BitArchiveItemOffset& nestedItem );
 
        BIT7Z_NODISCARD
        auto openArchiveStream(
            const bit7zfs::path& name,
            IInStream* inStream,
            ArchiveStartOffset startOffset
        ) -> IInArchive*;
 
#ifdef BIT7Z_AUTO_FORMAT
        BIT7Z_NODISCARD
        auto tryOpenSfxArchive(
            IInStream* inStream,
            OpenCallback* openCallback,
            const bit7zfs::path& name
        ) -> IInArchive*;
#endif
 
        void testArchive( BitIndicesView indices ) const;

        BIT7Z_NODISCARD auto itemAtUnchecked( std::uint32_t index ) const -> BitArchiveItemOffset;
 
        friend class ExtractCallback;
 
        friend class BitAbstractArchiveOpener;
 
        friend class BitAbstractArchiveCreator;
 
        friend class BitNestedArchiveReader;
 
        friend class BitOutputArchive;
 
        friend class CSynchronizedInStream;
};
 
} // namespace bit7z
 
#endif //BITINPUTARCHIVE_HPP