From e6918187568dbd01842d8d1d2c808ce16a894239 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:54:28 +0200 Subject: Adding upstream version 18.2.2. Signed-off-by: Daniel Baumann --- src/rocksdb/util/string_util.h | 177 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 src/rocksdb/util/string_util.h (limited to 'src/rocksdb/util/string_util.h') diff --git a/src/rocksdb/util/string_util.h b/src/rocksdb/util/string_util.h new file mode 100644 index 000000000..11178fd1d --- /dev/null +++ b/src/rocksdb/util/string_util.h @@ -0,0 +1,177 @@ +// Copyright (c) 2011-present, Facebook, Inc. All rights reserved. +// This source code is licensed under both the GPLv2 (found in the +// COPYING file in the root directory) and Apache 2.0 License +// (found in the LICENSE.Apache file in the root directory). +// + +#pragma once + +#include +#include +#include +#include +#include + +#include "rocksdb/rocksdb_namespace.h" + +namespace ROCKSDB_NAMESPACE { + +class Slice; + +extern std::vector StringSplit(const std::string& arg, char delim); + +// Append a human-readable printout of "num" to *str +extern void AppendNumberTo(std::string* str, uint64_t num); + +// Append a human-readable printout of "value" to *str. +// Escapes any non-printable characters found in "value". +extern void AppendEscapedStringTo(std::string* str, const Slice& value); + +// Put n digits from v in base kBase to (*buf)[0] to (*buf)[n-1] and +// advance *buf to the position after what was written. +template +inline void PutBaseChars(char** buf, size_t n, uint64_t v, bool uppercase) { + const char* digitChars = uppercase ? "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" + : "0123456789abcdefghijklmnopqrstuvwxyz"; + for (size_t i = n; i > 0; --i) { + (*buf)[i - 1] = digitChars[static_cast(v % kBase)]; + v /= kBase; + } + *buf += n; +} + +// Parse n digits from *buf in base kBase to *v and advance *buf to the +// position after what was read. On success, true is returned. On failure, +// false is returned, *buf is placed at the first bad character, and *v +// contains the partial parsed data. Overflow is not checked but the +// result is accurate mod 2^64. Requires the starting value of *v to be +// zero or previously accumulated parsed digits, i.e. +// ParseBaseChars(&b, n, &v); +// is equivalent to n calls to +// ParseBaseChars(&b, 1, &v); +template +inline bool ParseBaseChars(const char** buf, size_t n, uint64_t* v) { + while (n) { + char c = **buf; + *v *= static_cast(kBase); + if (c >= '0' && (kBase >= 10 ? c <= '9' : c < '0' + kBase)) { + *v += static_cast(c - '0'); + } else if (kBase > 10 && c >= 'A' && c < 'A' + kBase - 10) { + *v += static_cast(c - 'A' + 10); + } else if (kBase > 10 && c >= 'a' && c < 'a' + kBase - 10) { + *v += static_cast(c - 'a' + 10); + } else { + return false; + } + --n; + ++*buf; + } + return true; +} + +// Return a human-readable version of num. +// for num >= 10.000, prints "xxK" +// for num >= 10.000.000, prints "xxM" +// for num >= 10.000.000.000, prints "xxG" +extern std::string NumberToHumanString(int64_t num); + +// Return a human-readable version of bytes +// ex: 1048576 -> 1.00 GB +extern std::string BytesToHumanString(uint64_t bytes); + +// Return a human-readable version of unix time +// ex: 1562116015 -> "Tue Jul 2 18:06:55 2019" +extern std::string TimeToHumanString(int unixtime); + +// Append a human-readable time in micros. +int AppendHumanMicros(uint64_t micros, char* output, int len, + bool fixed_format); + +// Append a human-readable size in bytes +int AppendHumanBytes(uint64_t bytes, char* output, int len); + +// Return a human-readable version of "value". +// Escapes any non-printable characters found in "value". +extern std::string EscapeString(const Slice& value); + +// Parse a human-readable number from "*in" into *value. On success, +// advances "*in" past the consumed number and sets "*val" to the +// numeric value. Otherwise, returns false and leaves *in in an +// unspecified state. +extern bool ConsumeDecimalNumber(Slice* in, uint64_t* val); + +// Returns true if the input char "c" is considered as a special character +// that will be escaped when EscapeOptionString() is called. +// +// @param c the input char +// @return true if the input char "c" is considered as a special character. +// @see EscapeOptionString +bool isSpecialChar(const char c); + +// If the input char is an escaped char, it will return the its +// associated raw-char. Otherwise, the function will simply return +// the original input char. +char UnescapeChar(const char c); + +// If the input char is a control char, it will return the its +// associated escaped char. Otherwise, the function will simply return +// the original input char. +char EscapeChar(const char c); + +// Converts a raw string to an escaped string. Escaped-characters are +// defined via the isSpecialChar() function. When a char in the input +// string "raw_string" is classified as a special characters, then it +// will be prefixed by '\' in the output. +// +// It's inverse function is UnescapeOptionString(). +// @param raw_string the input string +// @return the '\' escaped string of the input "raw_string" +// @see isSpecialChar, UnescapeOptionString +std::string EscapeOptionString(const std::string& raw_string); + +// The inverse function of EscapeOptionString. It converts +// an '\' escaped string back to a raw string. +// +// @param escaped_string the input '\' escaped string +// @return the raw string of the input "escaped_string" +std::string UnescapeOptionString(const std::string& escaped_string); + +std::string trim(const std::string& str); + +// Returns true if "string" ends with "pattern" +bool EndsWith(const std::string& string, const std::string& pattern); + +// Returns true if "string" starts with "pattern" +bool StartsWith(const std::string& string, const std::string& pattern); + +#ifndef ROCKSDB_LITE +bool ParseBoolean(const std::string& type, const std::string& value); + +uint8_t ParseUint8(const std::string& value); + +uint32_t ParseUint32(const std::string& value); + +int32_t ParseInt32(const std::string& value); +#endif + +uint64_t ParseUint64(const std::string& value); + +int ParseInt(const std::string& value); + +int64_t ParseInt64(const std::string& value); + +double ParseDouble(const std::string& value); + +size_t ParseSizeT(const std::string& value); + +std::vector ParseVectorInt(const std::string& value); + +bool SerializeIntVector(const std::vector& vec, std::string* value); + +extern const std::string kNullptrString; + +// errnoStr() function returns a string that describes the error code passed in +// the argument err +extern std::string errnoStr(int err); + +} // namespace ROCKSDB_NAMESPACE -- cgit v1.2.3