forked from bartvdbraak/blender
e12c08e8d1
Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
257 lines
5.8 KiB
C++
257 lines
5.8 KiB
C++
/*
|
|
* Copyright 2011-2013 Blender Foundation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
|
|
#include "util/util_foreach.h"
|
|
#include "util/util_string.h"
|
|
#include "util/util_windows.h"
|
|
|
|
#ifdef _WIN32
|
|
# ifndef vsnprintf
|
|
# define vsnprintf _vsnprintf
|
|
# endif
|
|
#endif /* _WIN32 */
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
string string_printf(const char *format, ...)
|
|
{
|
|
vector<char> str(128, 0);
|
|
|
|
while (1) {
|
|
va_list args;
|
|
int result;
|
|
|
|
va_start(args, format);
|
|
result = vsnprintf(&str[0], str.size(), format, args);
|
|
va_end(args);
|
|
|
|
if (result == -1) {
|
|
/* not enough space or formatting error */
|
|
if (str.size() > 65536) {
|
|
assert(0);
|
|
return string("");
|
|
}
|
|
|
|
str.resize(str.size() * 2, 0);
|
|
continue;
|
|
}
|
|
else if (result >= (int)str.size()) {
|
|
/* not enough space */
|
|
str.resize(result + 1, 0);
|
|
continue;
|
|
}
|
|
|
|
return string(&str[0]);
|
|
}
|
|
}
|
|
|
|
bool string_iequals(const string &a, const string &b)
|
|
{
|
|
if (a.size() == b.size()) {
|
|
for (size_t i = 0; i < a.size(); i++)
|
|
if (toupper(a[i]) != toupper(b[i]))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void string_split(vector<string> &tokens,
|
|
const string &str,
|
|
const string &separators,
|
|
bool skip_empty_tokens)
|
|
{
|
|
size_t token_start = 0, token_length = 0;
|
|
for (size_t i = 0; i < str.size(); ++i) {
|
|
const char ch = str[i];
|
|
if (separators.find(ch) == string::npos) {
|
|
/* Current character is not a separator,
|
|
* append it to token by increasing token length.
|
|
*/
|
|
++token_length;
|
|
}
|
|
else {
|
|
/* Current character is a separator,
|
|
* append current token to the list.
|
|
*/
|
|
if (!skip_empty_tokens || token_length > 0) {
|
|
string token = str.substr(token_start, token_length);
|
|
tokens.push_back(token);
|
|
}
|
|
token_start = i + 1;
|
|
token_length = 0;
|
|
}
|
|
}
|
|
/* Append token from the tail of the string if exists. */
|
|
if (token_length) {
|
|
string token = str.substr(token_start, token_length);
|
|
tokens.push_back(token);
|
|
}
|
|
}
|
|
|
|
bool string_startswith(const string &s, const char *start)
|
|
{
|
|
size_t len = strlen(start);
|
|
|
|
if (len > s.size())
|
|
return 0;
|
|
else
|
|
return strncmp(s.c_str(), start, len) == 0;
|
|
}
|
|
|
|
bool string_endswith(const string &s, const char *end)
|
|
{
|
|
size_t len = strlen(end);
|
|
|
|
if (len > s.size())
|
|
return 0;
|
|
else
|
|
return strncmp(s.c_str() + s.size() - len, end, len) == 0;
|
|
}
|
|
|
|
string string_strip(const string &s)
|
|
{
|
|
string result = s;
|
|
result.erase(0, result.find_first_not_of(' '));
|
|
result.erase(result.find_last_not_of(' ') + 1);
|
|
return result;
|
|
}
|
|
|
|
void string_replace(string &haystack, const string &needle, const string &other)
|
|
{
|
|
size_t i = 0, index;
|
|
while ((index = haystack.find(needle, i)) != string::npos) {
|
|
haystack.replace(index, needle.size(), other);
|
|
i = index + other.size();
|
|
}
|
|
}
|
|
|
|
string string_remove_trademark(const string &s)
|
|
{
|
|
string result = s;
|
|
|
|
/* Special case, so we don;t leave sequential spaces behind. */
|
|
/* TODO(sergey): Consider using regex perhaps? */
|
|
string_replace(result, " (TM)", "");
|
|
string_replace(result, " (R)", "");
|
|
|
|
string_replace(result, "(TM)", "");
|
|
string_replace(result, "(R)", "");
|
|
|
|
return string_strip(result);
|
|
}
|
|
|
|
string string_from_bool(bool var)
|
|
{
|
|
if (var)
|
|
return "True";
|
|
else
|
|
return "False";
|
|
}
|
|
|
|
string to_string(const char *str)
|
|
{
|
|
return string(str);
|
|
}
|
|
|
|
/* Wide char strings helpers for Windows. */
|
|
|
|
#ifdef _WIN32
|
|
|
|
wstring string_to_wstring(const string &str)
|
|
{
|
|
const int length_wc = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), NULL, 0);
|
|
wstring str_wc(length_wc, 0);
|
|
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), &str_wc[0], length_wc);
|
|
return str_wc;
|
|
}
|
|
|
|
string string_from_wstring(const wstring &str)
|
|
{
|
|
int length_mb = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), str.size(), NULL, 0, NULL, NULL);
|
|
string str_mb(length_mb, 0);
|
|
WideCharToMultiByte(CP_UTF8, 0, str.c_str(), str.size(), &str_mb[0], length_mb, NULL, NULL);
|
|
return str_mb;
|
|
}
|
|
|
|
string string_to_ansi(const string &str)
|
|
{
|
|
const int length_wc = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), NULL, 0);
|
|
wstring str_wc(length_wc, 0);
|
|
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), &str_wc[0], length_wc);
|
|
|
|
int length_mb = WideCharToMultiByte(
|
|
CP_ACP, 0, str_wc.c_str(), str_wc.size(), NULL, 0, NULL, NULL);
|
|
|
|
string str_mb(length_mb, 0);
|
|
WideCharToMultiByte(CP_ACP, 0, str_wc.c_str(), str_wc.size(), &str_mb[0], length_mb, NULL, NULL);
|
|
|
|
return str_mb;
|
|
}
|
|
|
|
#endif /* _WIN32 */
|
|
|
|
string string_human_readable_size(size_t size)
|
|
{
|
|
static const char suffixes[] = "BKMGTPEZY";
|
|
|
|
const char *suffix = suffixes;
|
|
size_t r = 0;
|
|
|
|
while (size >= 1024) {
|
|
r = size % 1024;
|
|
size /= 1024;
|
|
suffix++;
|
|
}
|
|
|
|
if (*suffix != 'B')
|
|
return string_printf("%.2f%c", double(size * 1024 + r) / 1024.0, *suffix);
|
|
else
|
|
return string_printf("%zu", size);
|
|
}
|
|
|
|
string string_human_readable_number(size_t num)
|
|
{
|
|
if (num == 0) {
|
|
return "0";
|
|
}
|
|
|
|
/* Add thousands separators. */
|
|
char buf[32];
|
|
|
|
char *p = buf + 31;
|
|
*p = '\0';
|
|
|
|
int i = -1;
|
|
while (num) {
|
|
if (++i && i % 3 == 0)
|
|
*(--p) = ',';
|
|
|
|
*(--p) = '0' + (num % 10);
|
|
|
|
num /= 10;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
CCL_NAMESPACE_END
|