blob: 7e113412f9dfb47b360a2cb872efea39af53b7c2 [file] [log] [blame]
/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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 "perfetto/ext/base/string_utils.h"
#include <string.h>
#include <algorithm>
#include "perfetto/base/logging.h"
namespace perfetto {
namespace base {
bool StartsWith(const std::string& str, const std::string& prefix) {
return str.compare(0, prefix.length(), prefix) == 0;
}
bool EndsWith(const std::string& str, const std::string& suffix) {
if (suffix.size() > str.size())
return false;
return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}
bool Contains(const std::string& haystack, const std::string& needle) {
return haystack.find(needle) != std::string::npos;
}
size_t Find(const StringView& needle, const StringView& haystack) {
if (needle.size() == 0)
return 0;
if (needle.size() > haystack.size())
return std::string::npos;
for (size_t i = 0; i < haystack.size() - (needle.size() - 1); ++i) {
if (strncmp(haystack.data() + i, needle.data(), needle.size()) == 0)
return i;
}
return std::string::npos;
}
bool CaseInsensitiveEqual(const std::string& first, const std::string& second) {
return first.size() == second.size() &&
std::equal(
first.begin(), first.end(), second.begin(),
[](char a, char b) { return Lowercase(a) == Lowercase(b); });
}
std::string Join(const std::vector<std::string>& parts,
const std::string& delim) {
std::string acc;
for (size_t i = 0; i < parts.size(); ++i) {
acc += parts[i];
if (i + 1 != parts.size()) {
acc += delim;
}
}
return acc;
}
std::vector<std::string> SplitString(const std::string& text,
const std::string& delimiter) {
PERFETTO_CHECK(!delimiter.empty());
std::vector<std::string> output;
size_t start = 0;
size_t next;
for (;;) {
next = std::min(text.find(delimiter, start), text.size());
if (next > start)
output.emplace_back(&text[start], next - start);
start = next + delimiter.size();
if (start >= text.size())
break;
}
return output;
}
std::string StripPrefix(const std::string& str, const std::string& prefix) {
return StartsWith(str, prefix) ? str.substr(prefix.size()) : str;
}
std::string StripSuffix(const std::string& str, const std::string& suffix) {
return EndsWith(str, suffix) ? str.substr(0, str.size() - suffix.size())
: str;
}
std::string ToUpper(const std::string& str) {
// Don't use toupper(), it depends on the locale.
std::string res(str);
auto end = res.end();
for (auto c = res.begin(); c != end; ++c)
*c = Uppercase(*c);
return res;
}
std::string ToLower(const std::string& str) {
// Don't use tolower(), it depends on the locale.
std::string res(str);
auto end = res.end();
for (auto c = res.begin(); c != end; ++c)
*c = Lowercase(*c);
return res;
}
std::string ToHex(const char* data, size_t size) {
std::string hex(2 * size + 1, 'x');
for (size_t i = 0; i < size; ++i) {
// snprintf prints 3 characters, the two hex digits and a null byte. As we
// write left to write, we keep overwriting the nullbytes, except for the
// last call to snprintf.
snprintf(&(hex[2 * i]), 3, "%02hhx", data[i]);
}
// Remove the trailing nullbyte produced by the last snprintf.
hex.resize(2 * size);
return hex;
}
std::string StripChars(const std::string& str,
const std::string& chars,
char replacement) {
std::string res(str);
const char* start = res.c_str();
const char* remove = chars.c_str();
for (const char* c = strpbrk(start, remove); c; c = strpbrk(c + 1, remove))
res[static_cast<uintptr_t>(c - start)] = replacement;
return res;
}
} // namespace base
} // namespace perfetto