MRStringConvert.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshFwd.h"
#include <filesystem>
#include <string>
#include <string_view>
#include "MRExpected.h"
#include "MRPch/MRBindingMacros.h"
 
namespace MR
{


[[nodiscard]] MR_BIND_IGNORE MRMESH_API std::wstring utf8ToWide( const char* utf8 );

[[nodiscard]] MRMESH_API std::string systemToUtf8( const std::string & system );

[[nodiscard]] MRMESH_API std::string utf8ToSystem( const std::string & utf8 );

[[nodiscard]] MR_BIND_IGNORE MRMESH_API std::string wideToUtf8( const wchar_t * wide );
 
#ifdef _WIN32
[[nodiscard]] MR_BIND_IGNORE MRMESH_API std::string Utf16ToUtf8( const std::wstring_view & utf16 );
#endif
 
#if defined __cpp_lib_char8_t
 
[[nodiscard]] MR_BIND_IGNORE inline std::string asString( const std::u8string & s ) { return { s.begin(), s.end() }; }
[[nodiscard]] MR_BIND_IGNORE inline std::u8string asU8String( const std::string & s ) { return { s.begin(), s.end() }; }
 
#if defined( _LIBCPP_VERSION ) && _LIBCPP_VERSION < 12000
[[nodiscard]] MR_BIND_IGNORE inline std::filesystem::path pathFromUtf8( const std::string & s ) { return std::filesystem::path( s ); }
[[nodiscard]] MR_BIND_IGNORE inline std::filesystem::path pathFromUtf8( const char * s ) { return std::filesystem::path( std::string( s ) ); }
#else
[[nodiscard]] MR_BIND_IGNORE inline std::filesystem::path pathFromUtf8( const std::string & s ) { return std::filesystem::path( asU8String( s ) ); }
[[nodiscard]] MR_BIND_IGNORE inline std::filesystem::path pathFromUtf8( const char * s ) { return std::filesystem::path( asU8String( std::string( s ) ) ); }
#endif
 
#else 
 
[[nodiscard]] MR_BIND_IGNORE inline const std::string & asString( const std::string & s ) { return s; }
[[nodiscard]] MR_BIND_IGNORE inline const std::string & asU8String( const std::string & s ) { return s; }
 
[[nodiscard]] MR_BIND_IGNORE inline std::string asString( std::string && s ) { return std::move( s ); }
[[nodiscard]] MR_BIND_IGNORE inline std::string asU8String( std::string && s ) { return std::move( s ); }
 
[[nodiscard]] MR_BIND_IGNORE inline std::filesystem::path pathFromUtf8( const std::string & s ) { return std::filesystem::u8path( s ); }
[[nodiscard]] MR_BIND_IGNORE inline std::filesystem::path pathFromUtf8( const char * s ) { return std::filesystem::u8path( s ); }
 
#endif

#if defined( _LIBCPP_VERSION ) && _LIBCPP_VERSION < 12000
[[nodiscard]] inline std::string utf8string( const std::filesystem::path & path )
    { return path.u8string(); }
#else
[[nodiscard]] inline std::string utf8string( const std::filesystem::path & path )
    { return asString( path.u8string() ); }
#endif

std::string utf8string( const std::string & ) = delete;

[[nodiscard]] MRMESH_API std::string utf8substr( const char * s, size_t pos, size_t count );

[[nodiscard]] MR_BIND_IGNORE MRMESH_API std::pair<char32_t, size_t> utf8ToCodepoint( const char* s, size_t size );

[[nodiscard]] MR_BIND_IGNORE MRMESH_API std::u32string utf8ToUtf32( std::string_view str );

MR_BIND_IGNORE MRMESH_API void appendUtf8( std::string& str, char32_t cp );

[[nodiscard]] MR_BIND_IGNORE MRMESH_API std::string utf32ToUtf8( std::u32string_view str );

[[nodiscard]] MRMESH_API std::string bytesString( size_t size );

[[nodiscard]] inline bool isProhibitedChar( char c )
    { return c == '?' || c == '*' || c == '/' || c == '\\' || c == '"' || c == '<' || c == '>' || c == ':' || c == '|' || (unsigned)c < 32; }

[[nodiscard]] MRMESH_API bool hasProhibitedChars( const std::string& line );

[[nodiscard]] MRMESH_API std::string replaceProhibitedChars( const std::string& line, char replacement = '_' );

template<typename T>
[[nodiscard]] inline Expected<T> addFileNameInError( Expected<T> v, const std::filesystem::path & file )
{
    if ( !v.has_value() )
        v = unexpected( v.error() + ": " + utf8string( file ) );
    return v;
}

[[nodiscard]] MRMESH_API std::string commonFilesName( const std::vector<std::filesystem::path> & files );

[[deprecated("Use `valueToString()` from `MRViewer/MRUnits.h` instead!")]]
MRMESH_API MR_BIND_IGNORE char * formatNoTrailingZeros( char * fmt, double v, int digitsAfterPoint, int precision = 6 );

[[nodiscard]] MRMESH_API double roundToPrecision( double v, int precision );

[[nodiscard]] inline float roundToPrecision( float v, int precision ) { return (float)roundToPrecision( double(v), precision ); }

[[nodiscard]] inline std::string getCancelMessage( const std::filesystem::path& path )
{
    return "Loading canceled: " + utf8string( path );
}

[[nodiscard]] MR_BIND_IGNORE inline char toLower( char ch )
{
    return ( ch >= 'A' && ch <= 'Z' ) ? ch + ( 'a' - 'A' ) : ch;
}

[[nodiscard]] MR_BIND_IGNORE inline char32_t toLower( char32_t ch )
{
    return ( ch >= U'A' && ch <= U'Z' ) ? ch + ( U'a' - U'A' ) : ch;
}

[[nodiscard]] MRMESH_API std::string toLower( std::string str );

 
}