bitextractor.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 BITEXTRACTOR_HPP
#define BITEXTRACTOR_HPP
 
#include "bit7zlibrary.hpp"
#include "bitabstractarchivehandler.hpp"
#include "bitabstractarchiveopener.hpp"
#include "biterror.hpp"
#include "bitexception.hpp"
#include "bitformat.hpp"
#include "bitinputarchive.hpp"
#include "bittypes.hpp"
 
#include <algorithm>
#include <cstdint>
#include <functional>
#include <map>
#include <ostream>
#include <vector>
 
#ifdef BIT7Z_REGEX_MATCHING
#include <regex>
#endif
 
namespace bit7z {
 
namespace filesystem { // NOLINT(modernize-concat-nested-namespaces)
    namespace fsutil {
    auto wildcardMatch( const tstring& pattern, const tstring& str ) -> bool;
    } // namespace fsutil
} // namespace filesystem

template< typename Input >
class BitExtractor final : public BitAbstractArchiveOpener {
    public:
        explicit BitExtractor( const Bit7zLibrary& lib, const BitInFormat& format BIT7Z_DEFAULT_FORMAT )
            : BitAbstractArchiveOpener( lib, format ) {}

        void extract( Input inArchive, const tstring& outDir = {} ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outDir );
        }

        void extract( Input inArchive, const tstring& outDir, RenameCallback callback ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outDir, std::move( callback ) );
        }
 
        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 extract( Input inArchive, const tstring& outDir, LegacyRenameCallback callback ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo(
                outDir,
                // Init-capture (to move the callback into the lambda) requires C++14;
                // under C++11 we fall back to capturing the (copyable) std::function by copy.
#if BIT7Z_CPP_STANDARD >= 14
                [ callback = std::move( callback ) ]( const BitArchiveItem& item ) -> tstring {
#else
                [ callback ]( const BitArchiveItem& item ) -> tstring {
#endif
                    return callback( item.index(), item.path() );
                }
            );
        }

        void extractFolder(
            Input inArchive,
            const tstring& outDir,
            const tstring& folderPath,
            FolderPathPolicy policy = FolderPathPolicy::Strip
        ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractFolderTo( outDir, folderPath, policy );
        }

        void extractRootFolderContent(
            Input inArchive,
            const tstring& outDir
        ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractRootFolderContentTo( outDir );
        }

        void extract( Input inArchive, buffer_t& outBuffer, std::uint32_t index = 0 ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outBuffer, index );
        }

        template< std::size_t N >
        void extract( Input inArchive, std::array< byte_t, N >& outBuffer, std::uint32_t index = 0 ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outBuffer, index );
        }

        template< std::size_t N > // NOLINTNEXTLINE(*-avoid-c-arrays)
        void extract( Input inArchive, byte_t (&outBuffer)[ N ], std::uint32_t index = 0 ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outBuffer, index );
        }

        void extract( Input inArchive, byte_t* outBuffer, std::size_t size, std::uint32_t index = 0 ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outBuffer, size, index );
        }

        void extract( Input inArchive, std::ostream& outStream, std::uint32_t index = 0 ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outStream, index );
        }

        void extract( Input inArchive, std::map< tstring, buffer_t >& outMap ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outMap );
        }

        void extract( Input inArchive, BufferCallback callback, BitIndicesView indices = {} ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( std::move( callback ), indices );
        }

        void extractTo( Input inArchive, RawDataCallback callback, BitIndicesView indices = {} ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( std::move( callback ), indices );
        }

        void extractMatching(
            Input inArchive,
            const tstring& itemFilter,
            const tstring& outDir = {},
            FilterPolicy policy = FilterPolicy::Include
        ) const {
            const BitInputArchive inputArchive{ *this, inArchive };
            inputArchive.extractMatchingTo( outDir, itemFilter, policy );
        }

        void extractMatching(
            Input inArchive,
            const tstring& itemFilter,
            buffer_t& outBuffer,
            FilterPolicy policy = FilterPolicy::Include
        ) const {
            const BitInputArchive inputArchive{ *this, inArchive };
            inputArchive.extractMatchingTo( outBuffer, itemFilter, policy );
        }

        void extractItems(
            Input inArchive,
            BitIndicesView indices,
            const tstring& outDir = {}
        ) const {
            if ( indices.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::IndicesNotSpecified ) );
            }
 
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outDir, indices );
        }
 
#ifdef BIT7Z_REGEX_MATCHING

        void extractMatchingRegex(
            Input inArchive,
            const tstring& regex,
            const tstring& outDir = {},
            FilterPolicy policy = FilterPolicy::Include
        ) const {
            const BitInputArchive inputArchive{ *this, inArchive };
            inputArchive.extractMatchingRegexTo( outDir, regex, policy );
        }

        void extractMatchingRegex(
            Input inArchive,
            const tstring& regex,
            buffer_t& outBuffer,
            FilterPolicy policy = FilterPolicy::Include
        ) const {
            const BitInputArchive inputArchive{ *this, inArchive };
            inputArchive.extractMatchingRegexTo( outBuffer, regex, policy );
        }
 
#endif

        void extractIf( Input inArchive, const tstring& outDir, FilterCallback callback ) const {
            const BitInputArchive inputArchive{ *this, inArchive };
            inputArchive.extractTo( outDir, std::move( callback ) );
        }

        void extractIf( Input inArchive, buffer_t& outBuffer, FilterCallback callback ) const {
            const BitInputArchive inputArchive{ *this, inArchive };
            inputArchive.extractTo( outBuffer, std::move( callback ) );
        }

        void test( Input inArchive, BitIndicesView indices = {} ) const {
            const BitInputArchive inputArchive( *this, inArchive );
            inputArchive.test( indices );
        }
};
 
} // namespace bit7z
 
#endif //BITEXTRACTOR_HPP