bitoutputarchive.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 BITOUTPUTARCHIVE_HPP
#define BITOUTPUTARCHIVE_HPP
 
#include "bitabstractarchivecreator.hpp"
#include "bitabstractarchivehandler.hpp"
#include "bitexception.hpp" //for FailedFiles
#include "bitinputarchive.hpp"
#include "bititemsvector.hpp"
#include "bitpropvariant.hpp"
#include "bittypes.hpp"
 
#include <cstdint>
#include <istream>
#include <map>
#include <memory>
#include <ostream>
#include <set>
#include <utility>
#include <vector>

struct ISequentialInStream;
 
template< typename T >
class CMyComPtr;
 
namespace bit7z {
 
using DeletedItems = std::set< std::uint32_t >;
 
/* We introduce a strong index type to differentiate between indices in the output
 * archive (std::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 {}; // NOLINT(*-enum-size)
 
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,
            buffer_t&& inBuffer,
            ArchiveStartOffset startOffset = ArchiveStartOffset::None
        ) = delete;

        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::vector< std::pair< tstring, tstring > >& inPaths );

        void addItems( const std::map< tstring, tstring >& inPaths );

        auto addFile( const tstring& inFile, const tstring& name = {} ) -> BitInputItem&;

        auto addFile( const buffer_t& inBuffer, const tstring& name ) -> BitInputItem&;

        auto addFile( buffer_t&& inBuffer, const tstring& name ) -> BitInputItem& = delete;

        auto addFile( std::istream& inStream, const tstring& name ) -> BitInputItem&;

        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( buffer_t& outBuffer );

        void compressTo( std::ostream& outStream );

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

        auto handler() const noexcept -> const BitAbstractArchiveHandler&;

        auto creator() const noexcept -> const BitAbstractArchiveCreator&;

        virtual ~BitOutputArchive();
 
    protected:
        virtual auto itemProperty( InputIndex index, BitProperty property ) const -> BitPropVariant;
 
        virtual auto itemStream( InputIndex index, ISequentialInStream** inStream ) const -> HRESULT;
 
        virtual auto hasNewData( std::uint32_t index ) const noexcept -> bool;
 
        virtual auto hasNewProperties( std::uint32_t index ) const noexcept -> bool;
 
        auto itemInputIndex( std::uint32_t newIndex ) const noexcept -> InputIndex;
 
        auto outputItemProperty( std::uint32_t index, BitProperty property ) const -> BitPropVariant;
 
        auto outputItemStream( std::uint32_t index, ISequentialInStream** inStream ) const -> HRESULT;
 
        auto indexInArchive( std::uint32_t index ) const noexcept -> std::uint32_t;
 
        auto inputArchive() const -> BitInputArchive* {
            return mInputArchive.get();
        }
 
        void setInputArchive( std::unique_ptr< BitInputArchive >&& inputArchive ) {
            mInputArchive = std::move( inputArchive );
        }
 
        auto inputArchiveItemsCount() const -> std::uint32_t {
            return mInputArchiveItemsCount;
        }
 
        void setDeletedIndex( std::uint32_t index ) {
            mDeletedItems.insert( index );
        }
 
        auto isDeletedIndex( std::uint32_t index ) const -> bool {
            return mDeletedItems.find( index ) != mDeletedItems.cend();
        }
 
        auto hasDeletedIndexes() const -> bool {
            return !mDeletedItems.empty();
        }
 
        auto hasNewItems() const -> bool {
            return !mNewItems.empty();
        }
 
        friend class UpdateCallback;
 
    private:
        const BitAbstractArchiveCreator& mArchiveCreator;
 
        std::unique_ptr< BitInputArchive > mInputArchive;
        std::uint32_t mInputArchiveItemsCount;
 
        BitItemsVector mNewItems;
        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' is not equal to 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 bit7zfs::path& outArchive ) const -> CMyComPtr< IOutStream >;
 
        BitOutputArchive(
            const BitAbstractArchiveCreator& creator,
            const bit7zfs::path& inArc,
            ArchiveStartOffset archiveStart
        );
 
        void compressToFile( const bit7zfs::path& outFile, UpdateCallback* updateCallback );
 
        void compressOut( IOutArchive* outArc, IOutStream* outStream, UpdateCallback* updateCallback );
 
        void setArchiveProperties( IOutArchive* outArchive ) const;
 
        void updateInputIndices();
};
 
} // namespace bit7z
 
#endif //BITOUTPUTARCHIVE_HPP