bitpropvariant.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 BITPROPVARIANT_HPP
#define BITPROPVARIANT_HPP
 
#include <chrono>
#include <cstdint>
 
#include "bitdefines.hpp"
#include "bittypes.hpp"
#include "bitwindows.hpp"
 
namespace bit7z {
 
using time_type = std::chrono::time_point< std::chrono::system_clock >;
 
enum struct BitProperty : PROPID {
    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                
};
 
enum struct BitPropVariantType : uint32_t {
    Empty,      
    Bool,       
    String,     
    UInt8,      
    UInt16,     
    UInt32,     
    UInt64,     
    Int8,       
    Int16,      
    Int32,      
    Int64,      
    FileTime    
};
 
struct BitPropVariant final : public PROPVARIANT {
        BitPropVariant();
 
        BitPropVariant( const BitPropVariant& other );
 
        BitPropVariant( BitPropVariant&& other ) noexcept;
 
        explicit BitPropVariant( bool value ) noexcept;
 
        explicit BitPropVariant( const wchar_t* value );
 
        explicit BitPropVariant( const std::wstring& value );
 
        explicit BitPropVariant( uint8_t value ) noexcept;
 
        explicit BitPropVariant( uint16_t value ) noexcept;
 
        explicit BitPropVariant( uint32_t value ) noexcept;
 
        explicit BitPropVariant( uint64_t value ) noexcept;
 
        explicit BitPropVariant( int8_t value ) noexcept;
 
        explicit BitPropVariant( int16_t value ) noexcept;
 
        explicit BitPropVariant( int32_t value ) noexcept;
 
        explicit BitPropVariant( 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 getUInt8() const -> uint8_t;
 
        BIT7Z_NODISCARD auto getUInt16() const -> uint16_t;
 
        BIT7Z_NODISCARD auto getUInt32() const -> uint32_t;
 
        BIT7Z_NODISCARD auto getUInt64() const -> uint64_t;
 
        BIT7Z_NODISCARD auto getInt8() const -> int8_t;
 
        BIT7Z_NODISCARD auto getInt16() const -> int16_t;
 
        BIT7Z_NODISCARD auto getInt32() const -> int32_t;
 
        BIT7Z_NODISCARD auto getInt64() const -> 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;
 
        friend auto operator==( const BitPropVariant& lhs, const BitPropVariant& rhs ) noexcept -> bool;
 
        friend auto operator!=( const BitPropVariant& lhs, const BitPropVariant& rhs ) noexcept -> bool;
};
 
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