bitextractor.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 BITEXTRACTOR_HPP
#define BITEXTRACTOR_HPP
 
#include <algorithm>
 
#include "bitabstractarchiveopener.hpp"
#include "biterror.hpp"
#include "bitexception.hpp"
#include "bitinputarchive.hpp"
 
namespace bit7z {
 
namespace filesystem { // NOLINT(modernize-concat-nested-namespaces)
namespace fsutil {
auto wildcard_match( 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 {
            BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outDir );
        }
 
        void extract( Input inArchive, vector< byte_t >& outBuffer, uint32_t index = 0 ) const {
            BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outBuffer, index );
        }
 
        void extract( Input inArchive, std::ostream& outStream, uint32_t index = 0 ) const {
            BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outStream, index );
        }
 
        void extract( Input inArchive, std::map< tstring, vector< byte_t > >& outMap ) const {
            BitInputArchive inputArchive( *this, inArchive );
            inputArchive.extractTo( outMap );
        }
 
        void extractMatching( Input inArchive,
                              const tstring& itemFilter,
                              const tstring& outDir = {},
                              FilterPolicy policy = FilterPolicy::Include ) const {
            using namespace filesystem;
 
            if ( itemFilter.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::FilterNotSpecified ) );
            }
 
            extractMatchingFilter( inArchive, outDir, policy, [ &itemFilter ]( const tstring& itemPath ) -> bool {
                return fsutil::wildcard_match( itemFilter, itemPath );
            } );
        }
 
        void extractMatching( Input inArchive,
                              const tstring& itemFilter,
                              vector< byte_t >& outBuffer,
                              FilterPolicy policy = FilterPolicy::Include ) const {
            using namespace filesystem;
 
            if ( itemFilter.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::FilterNotSpecified ) );
            }
 
            extractMatchingFilter( inArchive, outBuffer, policy,
                                   [ &itemFilter ]( const tstring& itemPath ) -> bool {
                                       return fsutil::wildcard_match( itemFilter, itemPath );
                                   } );
        }
 
        void extractItems( Input inArchive,
                           const std::vector< uint32_t >& indices,
                           const tstring& outDir = {} ) const {
            if ( indices.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::IndicesNotSpecified ) );
            }
 
            BitInputArchive inputArchive( *this, inArchive );
            uint32_t nItems = inputArchive.itemsCount();
            // Find if any index passed by the user is not in the valid range [0, itemsCount() - 1]
            const auto findRes = std::find_if( indices.cbegin(),
                                               indices.cend(),
                                               [ &nItems ]( uint32_t index ) -> bool {
                                                    return index >= nItems;
                                                } );
            if ( findRes != indices.cend() ) {
                throw BitException( "Cannot extract item at the index " + std::to_string( *findRes ),
                                    make_error_code( BitError::InvalidIndex ) );
            }
 
            inputArchive.extractTo( outDir, indices );
        }
 
#ifdef BIT7Z_REGEX_MATCHING
 
        void extractMatchingRegex( Input inArchive,
                                   const tstring& regex,
                                   const tstring& outDir = {},
                                   FilterPolicy policy = FilterPolicy::Include ) const {
            if ( regex.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::FilterNotSpecified ) );
            }
 
            const tregex regexFilter( regex, tregex::ECMAScript | tregex::optimize );
            extractMatchingFilter( inArchive, outDir, policy, [ &regexFilter ]( const tstring& itemPath ) -> bool {
                return std::regex_match( itemPath, regexFilter );
            } );
        }
 
        void extractMatchingRegex( Input inArchive,
                                   const tstring& regex,
                                   vector< byte_t >& outBuffer,
                                   FilterPolicy policy = FilterPolicy::Include ) const {
            if ( regex.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::FilterNotSpecified ) );
            }
 
            const tregex regexFilter( regex, tregex::ECMAScript | tregex::optimize );
            return extractMatchingFilter( inArchive, outBuffer, policy,
                                          [ &regexFilter ]( const tstring& itemPath ) -> bool {
                                              return std::regex_match( itemPath, regexFilter );
                                          } );
        }
 
#endif
 
        void test( Input inArchive ) const {
            BitInputArchive inputArchive( *this, inArchive );
            inputArchive.test();
        }
 
    private:
        void extractMatchingFilter( Input inArchive,
                                    const tstring& outDir,
                                    FilterPolicy policy,
                                    const std::function< bool( const tstring& ) >& filter ) const {
            BitInputArchive inputArchive( *this, inArchive );
 
            vector< uint32_t > matchedIndices;
            const bool shouldExtractMatchedItems = policy == FilterPolicy::Include;
            // Searching for files inside the archive that match the given filter
            for ( const auto& item : inputArchive ) {
                const bool itemMatches = filter( item.path() );
                if ( itemMatches == shouldExtractMatchedItems ) {
                    /* The if-condition is equivalent to an exclusive XNOR (negated XOR) between
                     * itemMatches and shouldExtractMatchedItems.
                     * In other words, it is true only if the current item either:
                     *  - matches the filter, and we must include any matching item; or
                     *  - doesn't match the filter, and we must exclude those that match. */
                    matchedIndices.push_back( item.index() );
                }
            }
 
            if ( matchedIndices.empty() ) {
                throw BitException( "Cannot extract items", make_error_code( BitError::NoMatchingItems ) );
            }
 
            inputArchive.extractTo( outDir, matchedIndices );
        }
 
        void extractMatchingFilter( Input inArchive,
                                    vector< byte_t >& outBuffer,
                                    FilterPolicy policy,
                                    const std::function< bool( const tstring& ) >& filter ) const {
            BitInputArchive inputArchive( *this, inArchive );
 
            const bool shouldExtractMatchedItem = policy == FilterPolicy::Include;
            // Searching for files inside the archive that match the given filter
            for ( const auto& item : inputArchive ) {
                const bool itemMatches = filter( item.path() );
                if ( itemMatches == shouldExtractMatchedItem ) {
                    /* The if-condition is equivalent to an exclusive NOR (negated XOR) between
                     *  itemMatches and shouldExtractMatchedItem. */
                    inputArchive.extractTo( outBuffer, item.index() );
                    return;
                }
            }
 
            throw BitException( "Failed to extract items", make_error_code( BitError::NoMatchingItems ) );
        }
};
 
}  // namespace bit7z
 
#endif //BITEXTRACTOR_HPP