bitinputitem.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 BITINPUTITEM_HPP
#define BITINPUTITEM_HPP
 
#include "bitfs.hpp"
#include "bitinputarchive.hpp"
 
#include <cstdint>
#include <functional>
 
struct ISequentialInStream;
 
namespace bit7z {

enum struct SymlinkPolicy : std::uint8_t {
    Follow,      
    DoNotFollow  
};

namespace detail {
 
struct FilesystemInputItem final {
    SymlinkPolicy symlinkPolicy = SymlinkPolicy::Follow;
#if defined( _MSC_VER ) && _MSC_VER <= 1900
    explicit FilesystemInputItem( SymlinkPolicy policy ) : symlinkPolicy{ policy } {}
#endif
};
 
using BufferInputItem = std::reference_wrapper< const buffer_t >;
 
using StdInputItem = std::reference_wrapper< std::istream >;
 
struct RenamedInputItemInitTag final {};
 
struct RenamedInputItem final {
    explicit RenamedInputItem( RenamedInputItemInitTag /* initTag */ ) {}
};
 
enum struct InputItemType : std::uint8_t {
    Filesystem, Buffer, StdStream, RenamedItem
};
 
struct InputItemProperties final {
    std::uint64_t size;
    FILETIME lastWriteTime;
    FILETIME lastAccessTime;
    FILETIME creationTime;
    std::uint32_t attributes;
    InputItemType inputType;
};
 
} // namespace detail

class BitInputItem final {
    public:
        explicit BitInputItem( const bit7zfs::path& itemPath, SymlinkPolicy symlinkPolicy = SymlinkPolicy::Follow );
 
        BitInputItem(
            const bit7zfs::path& itemPath,
            const bit7zfs::path& inArchivePath,
            SymlinkPolicy symlinkPolicy = SymlinkPolicy::Follow
        );
 
        BitInputItem( const bit7zfs::path& searchPath, const bit7zfs::directory_entry& entry, SymlinkPolicy symlinkPolicy );
 
        BitInputItem( const buffer_t& buffer, const tstring& path );
 
        BitInputItem( std::istream& stream, const tstring& path );
 
        BitInputItem( const BitInputArchive& inputArchive, std::uint32_t index, const tstring& newPath );

        BIT7Z_NODISCARD
        auto isDir() const noexcept -> bool;

        BIT7Z_NODISCARD
        auto isSymLink() const noexcept -> bool;

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

        BIT7Z_NODISCARD
        auto path() const -> const native_string&;

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

        BIT7Z_NODISCARD
        auto inArchivePath() const -> const sevenzip_string&;

        BIT7Z_NODISCARD
        auto itemProperty( BitProperty property ) const -> BitPropVariant;

        BIT7Z_NODISCARD
        auto hasNewData() const noexcept -> bool;

        void setCreationTime( time_type creationTime ) noexcept;

        void setLastWriteTime( time_type lastWriteTime ) noexcept;

        void setLastAccessTime( time_type lastAccessTime ) noexcept;
 
    private:
        friend class BitOutputArchive;
        friend class BitArchiveEditor;
 
        // For internal use only: provides the input stream for this item to be used during compression.
        // On Windows, storeOpenFiles requests shared read/write access, allowing the compression of files
        // locked by other processes. Returns S_OK on success, or an error HRESULT otherwise.
        BIT7Z_NODISCARD
        auto getStream( ISequentialInStream** inStream, bool storeOpenFiles ) const -> HRESULT;
 
        detail::InputItemProperties mProperties;
        // Note: we need to store paths as strings rather than bit7zfs::path as the public API is in C++14.
        native_string mPath; // std::wstring on Windows, std::string elsewhere.
        sevenzip_string mInArchivePath; // std::wstring on every OS, used by 7-Zip.
 
        // Unfortunately, we cannot use std::variant as we need to support C++11/C++14 in the public API.
        union {
            detail::FilesystemInputItem mFilesystemItem;
            detail::BufferInputItem mBufferItem;
            detail::StdInputItem mStdItem;
            detail::RenamedInputItem mRenamedItem;
        };
};
 
} // namespace bit7z
 
#endif //BITINPUTITEM_HPP