bitpropvariant.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 BITPROPVARIANT_HPP
#define BITPROPVARIANT_HPP
 
#include "bitdefines.hpp"
#include "bittypes.hpp"
#include "bitwindows.hpp"
 
#include <chrono>
#include <cstdint>
#include <string>
#include <type_traits>
 
namespace bit7z {

using time_type = std::chrono::time_point< std::chrono::system_clock >;

enum struct BitProperty : PROPID { // NOLINT(*-enum-size)
    NoProperty = 0,         
    MainSubfile,            
    HandlerItemIndex,       
    Path,                   
    Name,                   
    Extension,              
    IsDir,                  
    Size,                   
    PackSize,               
    Attrib,                 
    CTime,                  
    ATime,                  
    MTime,                  
    Solid,                  
    Commented,              
    Encrypted,              
    SplitBefore,            
    SplitAfter,             
    DictionarySize,         
    CRC,                    
    Type,                   
    IsAnti,                 
    Method,                 
    HostOS,                 
    FileSystem,             
    User,                   
    Group,                  
    Block,                  
    Comment,                
    Position,               
    Prefix,                 
    NumSubDirs,             
    NumSubFiles,            
    UnpackVer,              
    Volume,                 
    IsVolume,               
    Offset,                 
    Links,                  
    NumBlocks,              
    NumVolumes,             
    TimeType,               
    Bit64,                  
    BigEndian,              
    Cpu,                    
    PhySize,                
    HeadersSize,            
    Checksum,               
    Characts,               
    Va,                     
    Id,                     
    ShortName,              
    CreatorApp,             
    SectorSize,             
    PosixAttrib,            
    SymLink,                
    Error,                  
    TotalSize,              
    FreeSpace,              
    ClusterSize,            
    VolumeName,             
    LocalName,              
    Provider,               
    NtSecure,               
    IsAltStream,            
    IsAux,                  
    IsDeleted,              
    IsTree,                 
    Sha1,                   
    Sha256,                 
    ErrorType,              
    NumErrors,              
    ErrorFlags,             
    WarningFlags,           
    Warning,                
    NumStreams,             
    NumAltStreams,          
    AltStreamsSize,         
    VirtualSize,            
    UnpackSize,             
    TotalPhySize,           
    VolumeIndex,            
    SubType,                
    ShortComment,           
    CodePage,               
    IsNotArcType,           
    PhySizeCantBeDetected,  
    ZerosTailIsAllowed,     
    TailSize,               
    EmbeddedStubSize,       
    NtReparse,              
    HardLink,               
    INode,                  
    StreamId,               
    ReadOnly,               
    OutName,                
    CopyLink                
};

auto to_string( BitProperty property ) -> std::string;

enum struct BitPropVariantType : std::uint8_t {
    Empty,      
    Bool,       
    String,     
    UInt8,      
    UInt16,     
    UInt32,     
    UInt64,     
    Int8,       
    Int16,      
    Int32,      
    Int64,      
    FileTime    
};

struct BitPropVariant final : PROPVARIANT {
        BitPropVariant() noexcept;

        BitPropVariant( const BitPropVariant& other );

        BitPropVariant( BitPropVariant&& other ) noexcept;

        explicit BitPropVariant( bool value ) noexcept;

        explicit BitPropVariant( const sevenzip_string::value_type* value );

        explicit BitPropVariant( const sevenzip_string& value );

        explicit BitPropVariant( std::uint8_t value ) noexcept;

        explicit BitPropVariant( std::uint16_t value ) noexcept;

        explicit BitPropVariant( std::uint32_t value ) noexcept;

        explicit BitPropVariant( std::uint64_t value ) noexcept;

        explicit BitPropVariant( std::int8_t value ) noexcept;

        explicit BitPropVariant( std::int16_t value ) noexcept;

        explicit BitPropVariant( std::int32_t value ) noexcept;

        explicit BitPropVariant( std::int64_t value ) noexcept;

        explicit BitPropVariant( FILETIME value ) noexcept;

        ~BitPropVariant();

        auto operator=( const BitPropVariant& other ) -> BitPropVariant&;

        auto operator=( BitPropVariant&& other ) noexcept -> BitPropVariant&;

        template< typename T >
        auto operator=( const T& value ) noexcept( std::is_integral< T >::value ) -> BitPropVariant& {
            *this = BitPropVariant{ value };
            return *this;
        }

        BIT7Z_NODISCARD auto getBool() const -> bool;

        BIT7Z_NODISCARD auto getString() const -> tstring;

        BIT7Z_NODISCARD auto getNativeString() const -> native_string;

        BIT7Z_NODISCARD auto getRawString() const -> sevenzip_string;

        BIT7Z_NODISCARD auto getUInt8() const -> std::uint8_t;

        BIT7Z_NODISCARD auto getUInt16() const -> std::uint16_t;

        BIT7Z_NODISCARD auto getUInt32() const -> std::uint32_t;

        BIT7Z_NODISCARD auto getUInt64() const -> std::uint64_t;

        BIT7Z_NODISCARD auto getInt8() const -> std::int8_t;

        BIT7Z_NODISCARD auto getInt16() const -> std::int16_t;

        BIT7Z_NODISCARD auto getInt32() const -> std::int32_t;

        BIT7Z_NODISCARD auto getInt64() const -> std::int64_t;

        BIT7Z_NODISCARD auto getFileTime() const -> FILETIME;

        BIT7Z_NODISCARD auto getTimePoint() const -> time_type;

        BIT7Z_NODISCARD auto toString() const -> tstring;

        BIT7Z_NODISCARD auto isEmpty() const noexcept -> bool;

        BIT7Z_NODISCARD auto isBool() const noexcept -> bool;

        BIT7Z_NODISCARD auto isString() const noexcept -> bool;

        BIT7Z_NODISCARD auto isUInt8() const noexcept -> bool;

        BIT7Z_NODISCARD auto isUInt16() const noexcept -> bool;

        BIT7Z_NODISCARD auto isUInt32() const noexcept -> bool;

        BIT7Z_NODISCARD auto isUInt64() const noexcept -> bool;

        BIT7Z_NODISCARD auto isInt8() const noexcept -> bool;

        BIT7Z_NODISCARD auto isInt16() const noexcept -> bool;

        BIT7Z_NODISCARD auto isInt32() const noexcept -> bool;

        BIT7Z_NODISCARD auto isInt64() const noexcept -> bool;

        BIT7Z_NODISCARD auto isFileTime() const noexcept -> bool;

        BIT7Z_NODISCARD auto type() const -> BitPropVariantType;

        void clear() noexcept;
 
    private:
        void internalClear() noexcept;
};

auto operator==( const BitPropVariant& lhs, const BitPropVariant& rhs ) noexcept -> bool;

auto operator!=( const BitPropVariant& lhs, const BitPropVariant& rhs ) noexcept -> bool;
 
} // namespace bit7z
 
#endif // BITPROPVARIANT_HPP