bittypes.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 BITTYPES_HPP
#define BITTYPES_HPP
 
// Must be included here since the user might have manually enabled a BIT7Z_* compilation option
// by uncommenting the corresponding macro define in bitdefines.hpp.
#include "bitdefines.hpp" // For BIT7Z_* macros.
 
#ifdef BIT7Z_REGEX_MATCHING
#include <regex>
#endif
 
#include <cstddef>
#include <string>
#include <type_traits>
#include <vector>
 
namespace bit7z {

#ifdef BIT7Z_USE_STD_BYTE
#if __cpp_lib_byte
using byte_t = std::byte;
#else
enum class byte_t : unsigned char {}; //same as std::byte_t
#endif
#else
using byte_t = unsigned char;
#endif

using buffer_t = std::vector< byte_t >;
using index_t = std::ptrdiff_t; //like gsl::index (https://github.com/microsoft/GSL)
 
template< class Char >
struct StringTraits;
 
template<>
struct StringTraits< char > {
    template< class T >
    static auto convertToString( T value ) -> std::string {
        return std::to_string( value );
    }
};
 
template<>
struct StringTraits< wchar_t > {
    template< class T >
    static auto convertToString( T value ) -> std::wstring {
        return std::to_wstring( value );
    }
};

using sevenzip_string = std::wstring;

#ifdef _WIN32
using native_string = std::wstring;
#define BIT7Z_NATIVE_STRING_( str ) L##str
#define BIT7Z_NATIVE_STRING( str ) BIT7Z_NATIVE_STRING_( str )
#else
using native_string = std::string;
#define BIT7Z_NATIVE_STRING( str ) str
#endif

using native_char = native_string::value_type;

#if defined( BIT7Z_USE_NATIVE_STRING ) && defined( _WIN32 ) // Windows with native strings
using tchar = wchar_t;
#define BIT7Z_STRING( str ) BIT7Z_NATIVE_STRING_( str )
#else // Unix, and Windows with non-native strings
using tchar = char;
#define BIT7Z_STRING( str ) str
#endif

using tstring = std::basic_string< tchar >;
 
#ifdef BIT7Z_REGEX_MATCHING
using tregex = std::basic_regex< tchar >;
#endif

template< typename T, typename = typename std::enable_if< std::is_arithmetic< T >::value, T >::type >
auto to_tstring( T arg ) -> std::basic_string< tchar > {
    return StringTraits< tchar >::convertToString( arg );
}

#if defined( _WIN32 ) && !defined( BIT7Z_USE_NATIVE_STRING )
BIT7Z_NODISCARD
auto to_tstring( const native_string& str ) -> tstring;
 
BIT7Z_NODISCARD
BIT7Z_ALWAYS_INLINE
auto to_tstring( tstring&& str ) -> tstring {
    return std::move( str );
}
 
BIT7Z_NODISCARD
BIT7Z_ALWAYS_INLINE
auto to_tstring( const tstring& str ) -> const tstring& {
    return str;
}
#else
BIT7Z_NODISCARD
BIT7Z_ALWAYS_INLINE
auto to_tstring( native_string&& str ) -> tstring {
    return std::move( str );
}
 
BIT7Z_NODISCARD
BIT7Z_ALWAYS_INLINE
auto to_tstring( const native_string& str ) -> const tstring& {
    return str;
}
#endif

template< typename T, typename = typename std::enable_if< std::is_arithmetic< T >::value, T >::type >
auto to_native_string( T arg ) -> native_string {
#ifdef _WIN32
    return std::to_wstring( arg );
#else
    return std::to_string( arg );
#endif
}

BIT7Z_NODISCARD
BIT7Z_ALWAYS_INLINE
auto to_native_string( native_string&& str ) -> native_string {
    return std::move( str );
}
 
BIT7Z_NODISCARD
BIT7Z_ALWAYS_INLINE
auto to_native_string( const native_string& str ) -> const native_string& {
    return str;
}
 
#ifndef _WIN32
BIT7Z_NODISCARD
auto to_native_string( const sevenzip_string& str ) -> native_string;
#elif !defined( BIT7Z_USE_NATIVE_STRING )
BIT7Z_NODISCARD
auto to_native_string( const tstring& str ) -> native_string;
#endif

template< typename Enum >
using underlying_type_t = typename std::underlying_type< Enum >::type;

template< typename Enum >
constexpr auto to_underlying( Enum enum_value ) noexcept -> underlying_type_t< Enum > {
    return static_cast< underlying_type_t< Enum > >( enum_value );
}

template< typename From, typename To >
using is_explicitly_convertible = std::integral_constant< bool, std::is_constructible< To, From >::value &&
                                                                !std::is_convertible< From, To >::value >;
 
} // namespace bit7z
 
#endif // BITTYPES_HPP