bitabstractarchivecreator.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 BITABSTRACTARCHIVECREATOR_HPP
#define BITABSTRACTARCHIVECREATOR_HPP
 
#include "bit7zlibrary.hpp"
#include "bitabstractarchivehandler.hpp"
#include "bitcompressionlevel.hpp"
#include "bitcompressionmethod.hpp"
#include "bitdefines.hpp"
#include "bitformat.hpp"
#include "bitinputarchive.hpp"
#include "bitpropvariant.hpp"
#include "bittypes.hpp"
 
#include <cstddef>
#include <cstdint>
#include <map>
#include <string>
#include <type_traits>
 
struct IOutStream;
struct ISequentialOutStream;
 
namespace bit7z {
 
class ArchiveProperties;

enum struct UpdateMode : std::uint8_t {
    None,   
    Append, 
    Update, 
    BIT7Z_DEPRECATED_ENUMERATOR( Overwrite, Update, "Since v4.0. Please use the UpdateMode::Update enumerator." ) 
};

enum struct EncryptionScope : std::uint8_t {
    DataOnly,      
    DataAndHeaders 
};

class BitAbstractArchiveCreator : public BitAbstractArchiveHandler {
    public:
        BitAbstractArchiveCreator( const BitAbstractArchiveCreator& ) = delete;
 
        BitAbstractArchiveCreator( BitAbstractArchiveCreator&& ) = delete;
 
        auto operator=( const BitAbstractArchiveCreator& ) -> BitAbstractArchiveCreator& = delete;
 
        auto operator=( BitAbstractArchiveCreator&& ) -> BitAbstractArchiveCreator& = delete;
 
        ~BitAbstractArchiveCreator() override = default;

        BIT7Z_NODISCARD auto format() const noexcept -> const BitInFormat& override;

        BIT7Z_NODISCARD auto compressionFormat() const noexcept -> const BitInOutFormat&;

        BIT7Z_NODISCARD auto cryptHeaders() const noexcept -> bool;

        BIT7Z_NODISCARD auto compressionLevel() const noexcept -> BitCompressionLevel;

        BIT7Z_NODISCARD auto compressionMethod() const noexcept -> BitCompressionMethod;

        BIT7Z_NODISCARD auto dictionarySize() const noexcept -> std::uint32_t;

        BIT7Z_NODISCARD auto wordSize() const noexcept -> std::uint32_t;

        BIT7Z_NODISCARD auto solidMode() const noexcept -> bool;

        BIT7Z_NODISCARD auto updateMode() const noexcept -> UpdateMode;

        BIT7Z_NODISCARD auto volumeSize() const noexcept -> std::uint64_t;

        BIT7Z_NODISCARD auto threadsCount() const noexcept -> std::uint32_t;

        BIT7Z_NODISCARD auto storeSymbolicLinks() const noexcept -> bool;

        BIT7Z_NODISCARD auto storeLastWriteTime() const noexcept -> bool;

        BIT7Z_NODISCARD auto storeCreationTime() const noexcept -> bool;

        BIT7Z_NODISCARD auto storeLastAccessTime() const noexcept -> bool;

        BIT7Z_NODISCARD auto storeOpenFiles() const noexcept -> bool;

        void setPassword( const tstring& password ) override;

        void setPassword( const tstring& password, EncryptionScope scope );

        BIT7Z_DEPRECATED_MSG( "Since v4.1. Please use the setPassword overload taking an EncryptionScope enumerator." )
        void setPassword( const tstring& password, bool cryptHeaders );

        void setCompressionLevel( BitCompressionLevel level ) noexcept;

        void setCompressionMethod( BitCompressionMethod method );

        void setDictionarySize( std::uint32_t dictionarySize );

        void setWordSize( std::uint32_t wordSize );

        void setSolidMode( bool solidMode ) noexcept;

        virtual void setUpdateMode( UpdateMode mode );

        BIT7Z_DEPRECATED_MSG( "Since v4.0. Please use the overloaded function that takes an UpdateMode enumerator." )
        void setUpdateMode( bool canUpdate );

        void setVolumeSize( std::uint64_t volumeSize ) noexcept;

        void setThreadsCount( std::uint32_t threadsCount ) noexcept;

        void setStoreSymbolicLinks( bool storeSymlinks ) noexcept;

        void setStoreLastWriteTime( bool storeLastWriteTime ) noexcept;

        void setStoreCreationTime( bool storeCreationTime ) noexcept;

        void setStoreLastAccessTime( bool storeLastAccessTime ) noexcept;

        void setStoreOpenFiles( bool storeOpenFiles ) noexcept;

        template< std::size_t N, typename T, typename = typename std::enable_if< std::is_integral< T >::value >::type >
        void setFormatProperty( const wchar_t (&name)[ N ], T value ) noexcept { // NOLINT(*-avoid-c-arrays)
            mExtraProperties[ name ] = value;
        }

        template< std::size_t N, typename T, typename = typename std::enable_if< !std::is_integral< T >::value >::type >
        void setFormatProperty( const wchar_t (&name)[ N ], const T& value ) noexcept { // NOLINT(*-avoid-c-arrays)
            mExtraProperties[ name ] = value;
        }
 
    protected:
        BitAbstractArchiveCreator(
            const Bit7zLibrary& lib,
            const BitInOutFormat& format,
            tstring password = {},
            UpdateMode updateMode = UpdateMode::None
        );
 
        BIT7Z_NODISCARD auto archiveProperties() const -> ArchiveProperties;
 
        friend class BitOutputArchive;
 
    private:
        const BitInOutFormat& mFormat;
 
        UpdateMode mUpdateMode;
        BitCompressionLevel mCompressionLevel;
        BitCompressionMethod mCompressionMethod;
        std::uint32_t mDictionarySize;
        std::uint32_t mWordSize;
        bool mCryptHeaders;
        bool mSolidMode;
        std::uint64_t mVolumeSize;
        std::uint32_t mThreadsCount;
        bool mStoreSymbolicLinks;
        bool mStoreOpenFiles;
        std::map< std::wstring, BitPropVariant > mExtraProperties;
};
 
} // namespace bit7z
 
#endif // BITABSTRACTARCHIVECREATOR_HPP