bitoutputarchive.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 BITOUTPUTARCHIVE_HPP
#define BITOUTPUTARCHIVE_HPP
 
#include <istream>
#include <set>
 
#include "bitabstractarchivecreator.hpp"
#include "bititemsvector.hpp"
#include "bitexception.hpp" //for FailedFiles
#include "bitpropvariant.hpp"
 
struct ISequentialInStream;
 
template< typename T >
class CMyComPtr;
 
namespace bit7z {
 
using std::istream;
 
using DeletedItems = std::set< uint32_t >;
 
/* General note: I tried my best to explain how indices work here, but it is a bit complex. */
 
/* We introduce a strong index type to differentiate between indices in the output
 * archive (uint32_t, as used by the UpdateCallback), and the corresponding indexes
 * in the input archive (InputIndex). In this way, we avoid implicit conversions
 * between the two kinds of indices.
 *
 * UpdateCallback uses indices in the range [0, BitOutputArchive::itemsCount() - 1]
 *
 * Now, if the user doesn't delete any item in the input archive, itemsCount()
 * is just equal to <n° of items in the input archive> + <n° of newly added items>.
 * In this case, an InputIndex value is just equal to the index used by UpdateCallback.
 *
 * On the contrary, if the user wants to delete an item in the input archive, the value
 * of an InputIndex may differ from the corresponding UpdateCallback's index.
 *
 * Note: given an InputIndex i:
 *         if i < mInputArchiveItemsCount, the item is old (old item in the input archive);
 *         if i >= mInputArchiveItemsCount, the item is new (added by the user); */
enum class InputIndex : std::uint32_t {};
 
class UpdateCallback;
 
class BitOutputArchive {
    public:
        explicit BitOutputArchive( const BitAbstractArchiveCreator& creator );
 
        explicit BitOutputArchive( const BitAbstractArchiveCreator& creator,
                                   const tstring& inFile,
                                   ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitOutputArchive( const BitAbstractArchiveCreator& creator,
                          const buffer_t& inBuffer,
                          ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitOutputArchive( const BitAbstractArchiveCreator& creator,
                          std::istream& inStream,
                          ArchiveStartOffset startOffset = ArchiveStartOffset::None );
 
        BitOutputArchive( const BitOutputArchive& ) = delete;
 
        BitOutputArchive( BitOutputArchive&& ) = delete;
 
        auto operator=( const BitOutputArchive& ) -> BitOutputArchive& = delete;
 
        auto operator=( BitOutputArchive&& ) -> BitOutputArchive& = delete;
 
        void addItems( const std::vector< tstring >& inPaths );
 
        void addItems( const std::map< tstring, tstring >& inPaths );
 
        void addFile( const tstring& inFile, const tstring& name = {} );
 
        void addFile( const std::vector< byte_t >& inBuffer, const tstring& name );
 
        void addFile( std::istream& inStream, const tstring& name );
 
        void addFiles( const std::vector< tstring >& inFiles );
 
        void addFiles( const tstring& inDir, const tstring& filter, bool recursive );
 
        void addFiles( const tstring& inDir,
                       const tstring& filter = BIT7Z_STRING( "*" ),
                       FilterPolicy policy = FilterPolicy::Include,
                       bool recursive = true );
 
        void addDirectory( const tstring& inDir );
 
        void addDirectoryContents( const tstring& inDir, const tstring& filter, bool recursive );
 
        void addDirectoryContents( const tstring& inDir,
                                   const tstring& filter = BIT7Z_STRING( "*" ),
                                   FilterPolicy policy = FilterPolicy::Include,
                                   bool recursive = true );
 
        void compressTo( const tstring& outFile );
 
        void compressTo( std::vector< byte_t >& outBuffer );
 
        void compressTo( std::ostream& outStream );
 
        auto itemsCount() const -> uint32_t;
 
        auto handler() const noexcept -> const BitAbstractArchiveHandler&;
 
        auto creator() const noexcept -> const BitAbstractArchiveCreator&;
 
        virtual ~BitOutputArchive() = default;
 
    protected:
        virtual auto itemProperty( InputIndex index, BitProperty property ) const -> BitPropVariant;
 
        virtual auto itemStream( InputIndex index, ISequentialInStream** inStream ) const -> HRESULT;
 
        virtual auto hasNewData( uint32_t index ) const noexcept -> bool;
 
        virtual auto hasNewProperties( uint32_t index ) const noexcept -> bool;
 
        auto itemInputIndex( uint32_t newIndex ) const noexcept -> InputIndex;
 
        auto outputItemProperty( uint32_t index, BitProperty property ) const -> BitPropVariant;
 
        auto outputItemStream( uint32_t index, ISequentialInStream** inStream ) const -> HRESULT;
 
        auto indexInArchive( uint32_t index ) const noexcept -> uint32_t;
 
        inline auto inputArchive() const -> BitInputArchive* {
            return mInputArchive.get();
        }
 
        inline void setInputArchive( std::unique_ptr< BitInputArchive >&& inputArchive ) {
            mInputArchive = std::move( inputArchive );
        }
 
        inline auto inputArchiveItemsCount() const -> uint32_t {
            return mInputArchiveItemsCount;
        }
 
        inline void setDeletedIndex( uint32_t index ) {
            mDeletedItems.insert( index );
        }
 
        inline auto isDeletedIndex( uint32_t index ) const -> bool {
            return mDeletedItems.find( index ) != mDeletedItems.cend();
        }
 
        inline auto hasDeletedIndexes() const -> bool {
            return !mDeletedItems.empty();
        }
 
        inline auto hasNewItems() const -> bool {
            return mNewItemsVector.size() > 0;
        }
 
        friend class UpdateCallback;
 
    private:
        const BitAbstractArchiveCreator& mArchiveCreator;
 
        unique_ptr< BitInputArchive > mInputArchive;
        uint32_t mInputArchiveItemsCount;
 
        BitItemsVector mNewItemsVector;
        DeletedItems mDeletedItems;
 
        mutable FailedFiles mFailedFiles;
 
        /* mInputIndices:
         *  - Position i = index in range [0, itemsCount() - 1] used by UpdateCallback.
         *  - Value at position i = corresponding index in the input archive (type InputIndex).
         *
         * If there are some deleted items, then i != mInputIndices[i]
         * (at least for values of i greater than the index of the first deleted item).
         *
         * Otherwise, if there are no deleted items, the vector is empty, and itemInputIndex(i)
         * will return InputIndex with value i.
         *
         * This vector is either empty, or it has size equal to itemsCount() (thanks to updateInputIndices()). */
        std::vector< InputIndex > mInputIndices;
 
        auto initOutArchive() const -> CMyComPtr< IOutArchive >;
 
        auto initOutFileStream( const fs::path& outArchive, bool updatingArchive ) const -> CMyComPtr< IOutStream >;
 
        BitOutputArchive( const BitAbstractArchiveCreator& creator,
                          const fs::path& inArc,
                          ArchiveStartOffset archiveStart );
 
        void compressToFile( const fs::path& outFile, UpdateCallback* updateCallback );
 
        void compressOut( IOutArchive* outArc, IOutStream* outStream, UpdateCallback* updateCallback );
 
        void setArchiveProperties( IOutArchive* outArchive ) const;
 
        void updateInputIndices();
};
 
}  // namespace bit7z
 
#endif //BITOUTPUTARCHIVE_HPP