sgilissen/llamaplayer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Sync string_util.cpp

Browse Source
This commit is contained in:
Connor McLaughlin
2022-07-08 19:38:18 +10:00
parent 97730b56c8
commit b3c3d5d954
2 changed files with 213 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
src/common/string_util.cpp
View File

@ -8,9 +8,7 @@
#include "windows_headers.h"
#endif
namespace StringUtil {
std::string StdStringFromFormat(const char* format, ...)
std::string StringUtil::StdStringFromFormat(const char* format, ...)
{
std::va_list ap;
va_start(ap, format);
@ -19,7 +17,7 @@ std::string StdStringFromFormat(const char* format, ...)
return ret;
}
std::string StdStringFromFormatV(const char* format, std::va_list ap)
std::string StringUtil::StdStringFromFormatV(const char* format, std::va_list ap)
{
std::va_list ap_copy;
va_copy(ap_copy, ap);
@ -32,12 +30,18 @@ std::string StdStringFromFormatV(const char* format, std::va_list ap)
va_end(ap_copy);
std::string ret;
ret.resize(len);
std::vsnprintf(ret.data(), ret.size() + 1, format, ap);
// If an encoding error occurs, len is -1. Which we definitely don't want to resize to.
if (len > 0)
{
ret.resize(len);
std::vsnprintf(ret.data(), ret.size() + 1, format, ap);
}
return ret;
}
bool WildcardMatch(const char* subject, const char* mask, bool case_sensitive /*= true*/)
bool StringUtil::WildcardMatch(const char* subject, const char* mask, bool case_sensitive /*= true*/)
{
if (case_sensitive)
{
@ -133,7 +137,7 @@ bool WildcardMatch(const char* subject, const char* mask, bool case_sensitive /*
}
}
std::size_t Strlcpy(char* dst, const char* src, std::size_t size)
std::size_t StringUtil::Strlcpy(char* dst, const char* src, std::size_t size)
{
std::size_t len = std::strlen(src);
if (len < size)
@ -148,7 +152,7 @@ std::size_t Strlcpy(char* dst, const char* src, std::size_t size)
return len;
}
std::size_t Strlcpy(char* dst, const std::string_view& src, std::size_t size)
std::size_t StringUtil::Strlcpy(char* dst, const std::string_view& src, std::size_t size)
{
std::size_t len = src.length();
if (len < size)
@ -164,7 +168,7 @@ std::size_t Strlcpy(char* dst, const std::string_view& src, std::size_t size)
return len;
}
std::optional<std::vector<u8>> DecodeHex(const std::string_view& in)
std::optional<std::vector<u8>> StringUtil::DecodeHex(const std::string_view& in)
{
std::vector<u8> data;
data.reserve(in.size() / 2);
@ -181,18 +185,138 @@ std::optional<std::vector<u8>> DecodeHex(const std::string_view& in)
return {data};
}
std::string EncodeHex(const u8* data, int length)
std::string StringUtil::EncodeHex(const u8* data, int length)
{
std::stringstream ss;
for (int i = 0; i < length; i++)
ss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(data[i]);
return ss.str();
}
std::string_view StringUtil::StripWhitespace(const std::string_view& str)
{
std::string_view::size_type start = 0;
while (start < str.size() && std::isspace(str[start]))
start++;
if (start == str.size())
return {};
std::string_view::size_type end = str.size() - 1;
while (end > start && std::isspace(str[end]))
end--;
return str.substr(start, end - start + 1);
}
void StringUtil::StripWhitespace(std::string* str)
{
{
const char* cstr = str->c_str();
std::string_view::size_type start = 0;
while (start < str->size() && std::isspace(cstr[start]))
start++;
if (start != 0)
str->erase(0, start);
}
{
const char* cstr = str->c_str();
std::string_view::size_type start = str->size();
while (start > 0 && std::isspace(cstr[start - 1]))
start--;
if (start != str->size())
str->erase(start);
}
}
std::vector<std::string_view> StringUtil::SplitString(const std::string_view& str, char delimiter,
bool skip_empty /*= true*/)
{
std::vector<std::string_view> res;
std::string_view::size_type last_pos = 0;
std::string_view::size_type pos;
while (last_pos < str.size() && (pos = str.find(delimiter, last_pos)) != std::string_view::npos)
{
std::string_view part(StripWhitespace(str.substr(last_pos, pos - last_pos)));
if (!skip_empty || !part.empty())
res.push_back(std::move(part));
last_pos = pos + 1;
}
if (last_pos < str.size())
{
std::string_view part(StripWhitespace(str.substr(last_pos)));
if (!skip_empty || !part.empty())
res.push_back(std::move(part));
}
return res;
}
std::string StringUtil::ReplaceAll(const std::string_view& subject, const std::string_view& search,
const std::string_view& replacement)
{
std::string ret(subject);
ReplaceAll(&ret, search, replacement);
return ret;
}
void StringUtil::ReplaceAll(std::string* subject, const std::string_view& search, const std::string_view& replacement)
{
if (!subject->empty())
{
std::string::size_type start_pos = 0;
while ((start_pos = subject->find(search, start_pos)) != std::string::npos)
{
subject->replace(start_pos, search.length(), replacement);
start_pos += replacement.length();
}
}
}
bool StringUtil::ParseAssignmentString(const std::string_view& str, std::string_view* key, std::string_view* value)
{
const std::string_view::size_type pos = str.find('=');
if (pos == std::string_view::npos)
{
*key = std::string_view();
*value = std::string_view();
return false;
}
*key = StripWhitespace(str.substr(0, pos));
if (pos != (str.size() - 1))
*value = StripWhitespace(str.substr(pos + 1));
else
*value = std::string_view();
return true;
}
void StringUtil::AppendUTF16CharacterToUTF8(std::string& s, u16 ch)
{
if (ch & 0xf800)
{
s.push_back(static_cast<char>(static_cast<u8>(0xe0 | static_cast<u8>(ch >> 12))));
s.push_back(static_cast<char>(static_cast<u8>(0x80 | static_cast<u8>(((ch >> 6) & 0x3f)))));
s.push_back(static_cast<char>(static_cast<u8>(0x80 | static_cast<u8>((ch & 0x3f)))));
}
else if (ch & 0xff80)
{
s.push_back(static_cast<char>(static_cast<u8>(0xc0 | static_cast<u8>((ch >> 6)))));
s.push_back(static_cast<char>(static_cast<u8>(0x80 | static_cast<u8>((ch & 0x3f)))));
}
else
{
s.push_back(static_cast<char>(static_cast<u8>(ch)));
}
}
#ifdef _WIN32
std::wstring UTF8StringToWideString(const std::string_view& str)
std::wstring StringUtil::UTF8StringToWideString(const std::string_view& str)
{
std::wstring ret;
if (!UTF8StringToWideString(ret, str))
@ -201,7 +325,7 @@ std::wstring UTF8StringToWideString(const std::string_view& str)
return ret;
}
bool UTF8StringToWideString(std::wstring& dest, const std::string_view& str)
bool StringUtil::UTF8StringToWideString(std::wstring& dest, const std::string_view& str)
{
int wlen = MultiByteToWideChar(CP_UTF8, 0, str.data(), static_cast<int>(str.length()), nullptr, 0);
if (wlen < 0)
@ -214,7 +338,7 @@ bool UTF8StringToWideString(std::wstring& dest, const std::string_view& str)
return true;
}
std::string WideStringToUTF8String(const std::wstring_view& str)
std::string StringUtil::WideStringToUTF8String(const std::wstring_view& str)
{
std::string ret;
if (!WideStringToUTF8String(ret, str))
@ -223,7 +347,7 @@ std::string WideStringToUTF8String(const std::wstring_view& str)
return ret;
}
bool WideStringToUTF8String(std::string& dest, const std::wstring_view& str)
bool StringUtil::WideStringToUTF8String(std::string& dest, const std::wstring_view& str)
{
int mblen = WideCharToMultiByte(CP_UTF8, 0, str.data(), static_cast<int>(str.length()), nullptr, 0, nullptr, nullptr);
if (mblen < 0)
@ -240,5 +364,3 @@ bool WideStringToUTF8String(std::string& dest, const std::wstring_view& str)
}
#endif
} // namespace StringUtil