bittypes.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 BITTYPES_HPP
#define BITTYPES_HPP
 
#include <string>
#include <vector>
 
// 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"
 
#ifdef BIT7Z_REGEX_MATCHING
#include <regex>
#endif
 
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 inline auto convertToString( T value ) -> std::string {
        return std::to_string( value );
    }
};
 
template<>
struct StringTraits< wchar_t > {
    template< class T >
    static inline auto convertToString( T value ) -> std::wstring {
        return std::to_wstring( value );
    }
};
#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
 
#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 >
inline auto to_tstring( T arg ) -> std::basic_string< tchar > {
    return StringTraits< tchar >::convertToString( arg );
}
 
#if defined( _WIN32 ) && !defined( BIT7Z_USE_NATIVE_STRING )
auto to_tstring( const native_string& str ) -> tstring;
#else
auto to_tstring( const native_string& str ) -> const tstring&;
#endif
 
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