diff options
Diffstat (limited to 'include/google/protobuf/stubs/strutil.h')
| -rw-r--r-- | include/google/protobuf/stubs/strutil.h | 950 |
1 files changed, 0 insertions, 950 deletions
diff --git a/include/google/protobuf/stubs/strutil.h b/include/google/protobuf/stubs/strutil.h deleted file mode 100644 index 9658abf908..0000000000 --- a/include/google/protobuf/stubs/strutil.h +++ /dev/null @@ -1,950 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// from google3/strings/strutil.h - -#ifndef GOOGLE_PROTOBUF_STUBS_STRUTIL_H__ -#define GOOGLE_PROTOBUF_STUBS_STRUTIL_H__ - -#include <google/protobuf/stubs/common.h> -#include <google/protobuf/stubs/stringpiece.h> -#include <stdlib.h> - -#include <cstring> -#include <google/protobuf/port_def.inc> -#include <vector> - -namespace google { -namespace protobuf { - -#if defined(_MSC_VER) && _MSC_VER < 1800 -#define strtoll _strtoi64 -#define strtoull _strtoui64 -#elif defined(__DECCXX) && defined(__osf__) -// HP C++ on Tru64 does not have strtoll, but strtol is already 64-bit. -#define strtoll strtol -#define strtoull strtoul -#endif - -// ---------------------------------------------------------------------- -// ascii_isalnum() -// Check if an ASCII character is alphanumeric. We can't use ctype's -// isalnum() because it is affected by locale. This function is applied -// to identifiers in the protocol buffer language, not to natural-language -// strings, so locale should not be taken into account. -// ascii_isdigit() -// Like above, but only accepts digits. -// ascii_isspace() -// Check if the character is a space character. -// ---------------------------------------------------------------------- - -inline bool ascii_isalnum(char c) { - return ('a' <= c && c <= 'z') || - ('A' <= c && c <= 'Z') || - ('0' <= c && c <= '9'); -} - -inline bool ascii_isdigit(char c) { - return ('0' <= c && c <= '9'); -} - -inline bool ascii_isspace(char c) { - return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || - c == '\r'; -} - -inline bool ascii_isupper(char c) { - return c >= 'A' && c <= 'Z'; -} - -inline bool ascii_islower(char c) { - return c >= 'a' && c <= 'z'; -} - -inline char ascii_toupper(char c) { - return ascii_islower(c) ? c - ('a' - 'A') : c; -} - -inline char ascii_tolower(char c) { - return ascii_isupper(c) ? c + ('a' - 'A') : c; -} - -inline int hex_digit_to_int(char c) { - /* Assume ASCII. */ - int x = static_cast<unsigned char>(c); - if (x > '9') { - x += 9; - } - return x & 0xf; -} - -// ---------------------------------------------------------------------- -// HasPrefixString() -// Check if a string begins with a given prefix. -// StripPrefixString() -// Given a string and a putative prefix, returns the string minus the -// prefix string if the prefix matches, otherwise the original -// string. -// ---------------------------------------------------------------------- -inline bool HasPrefixString(StringPiece str, StringPiece prefix) { - return str.size() >= prefix.size() && - memcmp(str.data(), prefix.data(), prefix.size()) == 0; -} - -inline std::string StripPrefixString(const std::string& str, - const std::string& prefix) { - if (HasPrefixString(str, prefix)) { - return str.substr(prefix.size()); - } else { - return str; - } -} - -// ---------------------------------------------------------------------- -// HasSuffixString() -// Return true if str ends in suffix. -// StripSuffixString() -// Given a string and a putative suffix, returns the string minus the -// suffix string if the suffix matches, otherwise the original -// string. -// ---------------------------------------------------------------------- -inline bool HasSuffixString(StringPiece str, StringPiece suffix) { - return str.size() >= suffix.size() && - memcmp(str.data() + str.size() - suffix.size(), suffix.data(), - suffix.size()) == 0; -} - -inline std::string StripSuffixString(const std::string& str, - const std::string& suffix) { - if (HasSuffixString(str, suffix)) { - return str.substr(0, str.size() - suffix.size()); - } else { - return str; - } -} - -// ---------------------------------------------------------------------- -// ReplaceCharacters -// Replaces any occurrence of the character 'remove' (or the characters -// in 'remove') with the character 'replacewith'. -// Good for keeping html characters or protocol characters (\t) out -// of places where they might cause a problem. -// StripWhitespace -// Removes whitespaces from both ends of the given string. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT void ReplaceCharacters(std::string* s, const char* remove, - char replacewith); - -PROTOBUF_EXPORT void StripWhitespace(std::string* s); - -// ---------------------------------------------------------------------- -// LowerString() -// UpperString() -// ToUpper() -// Convert the characters in "s" to lowercase or uppercase. ASCII-only: -// these functions intentionally ignore locale because they are applied to -// identifiers used in the Protocol Buffer language, not to natural-language -// strings. -// ---------------------------------------------------------------------- - -inline void LowerString(std::string* s) { - std::string::iterator end = s->end(); - for (std::string::iterator i = s->begin(); i != end; ++i) { - // tolower() changes based on locale. We don't want this! - if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A'; - } -} - -inline void UpperString(std::string* s) { - std::string::iterator end = s->end(); - for (std::string::iterator i = s->begin(); i != end; ++i) { - // toupper() changes based on locale. We don't want this! - if ('a' <= *i && *i <= 'z') *i += 'A' - 'a'; - } -} - -inline void ToUpper(std::string* s) { UpperString(s); } - -inline std::string ToUpper(const std::string& s) { - std::string out = s; - UpperString(&out); - return out; -} - -// ---------------------------------------------------------------------- -// StringReplace() -// Give me a string and two patterns "old" and "new", and I replace -// the first instance of "old" in the string with "new", if it -// exists. RETURN a new string, regardless of whether the replacement -// happened or not. -// ---------------------------------------------------------------------- - -PROTOBUF_EXPORT std::string StringReplace(const std::string& s, - const std::string& oldsub, - const std::string& newsub, - bool replace_all); - -// ---------------------------------------------------------------------- -// SplitStringUsing() -// Split a string using a character delimiter. Append the components -// to 'result'. If there are consecutive delimiters, this function skips -// over all of them. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT void SplitStringUsing(StringPiece full, const char* delim, - std::vector<std::string>* res); - -// Split a string using one or more byte delimiters, presented -// as a nul-terminated c string. Append the components to 'result'. -// If there are consecutive delimiters, this function will return -// corresponding empty strings. If you want to drop the empty -// strings, try SplitStringUsing(). -// -// If "full" is the empty string, yields an empty string as the only value. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT void SplitStringAllowEmpty(StringPiece full, const char* delim, - std::vector<std::string>* result); - -// ---------------------------------------------------------------------- -// Split() -// Split a string using a character delimiter. -// ---------------------------------------------------------------------- -inline std::vector<std::string> Split(StringPiece full, const char* delim, - bool skip_empty = true) { - std::vector<std::string> result; - if (skip_empty) { - SplitStringUsing(full, delim, &result); - } else { - SplitStringAllowEmpty(full, delim, &result); - } - return result; -} - -// ---------------------------------------------------------------------- -// JoinStrings() -// These methods concatenate a vector of strings into a C++ string, using -// the C-string "delim" as a separator between components. There are two -// flavors of the function, one flavor returns the concatenated string, -// another takes a pointer to the target string. In the latter case the -// target string is cleared and overwritten. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT void JoinStrings(const std::vector<std::string>& components, - const char* delim, std::string* result); - -inline std::string JoinStrings(const std::vector<std::string>& components, - const char* delim) { - std::string result; - JoinStrings(components, delim, &result); - return result; -} - -// ---------------------------------------------------------------------- -// UnescapeCEscapeSequences() -// Copies "source" to "dest", rewriting C-style escape sequences -// -- '\n', '\r', '\\', '\ooo', etc -- to their ASCII -// equivalents. "dest" must be sufficiently large to hold all -// the characters in the rewritten string (i.e. at least as large -// as strlen(source) + 1 should be safe, since the replacements -// are always shorter than the original escaped sequences). It's -// safe for source and dest to be the same. RETURNS the length -// of dest. -// -// It allows hex sequences \xhh, or generally \xhhhhh with an -// arbitrary number of hex digits, but all of them together must -// specify a value of a single byte (e.g. \x0045 is equivalent -// to \x45, and \x1234 is erroneous). -// -// It also allows escape sequences of the form \uhhhh (exactly four -// hex digits, upper or lower case) or \Uhhhhhhhh (exactly eight -// hex digits, upper or lower case) to specify a Unicode code -// point. The dest array will contain the UTF8-encoded version of -// that code-point (e.g., if source contains \u2019, then dest will -// contain the three bytes 0xE2, 0x80, and 0x99). -// -// Errors: In the first form of the call, errors are reported with -// LOG(ERROR). The same is true for the second form of the call if -// the pointer to the string std::vector is nullptr; otherwise, error -// messages are stored in the std::vector. In either case, the effect on -// the dest array is not defined, but rest of the source will be -// processed. -// ---------------------------------------------------------------------- - -PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest); -PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest, - std::vector<std::string>* errors); - -// ---------------------------------------------------------------------- -// UnescapeCEscapeString() -// This does the same thing as UnescapeCEscapeSequences, but creates -// a new string. The caller does not need to worry about allocating -// a dest buffer. This should be used for non performance critical -// tasks such as printing debug messages. It is safe for src and dest -// to be the same. -// -// The second call stores its errors in a supplied string vector. -// If the string vector pointer is nullptr, it reports the errors with LOG(). -// -// In the first and second calls, the length of dest is returned. In the -// the third call, the new string is returned. -// ---------------------------------------------------------------------- - -PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src, - std::string* dest); -PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src, - std::string* dest, - std::vector<std::string>* errors); -PROTOBUF_EXPORT std::string UnescapeCEscapeString(const std::string& src); - -// ---------------------------------------------------------------------- -// CEscape() -// Escapes 'src' using C-style escape sequences and returns the resulting -// string. -// -// Escaped chars: \n, \r, \t, ", ', \, and !isprint(). -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT std::string CEscape(const std::string& src); - -// ---------------------------------------------------------------------- -// CEscapeAndAppend() -// Escapes 'src' using C-style escape sequences, and appends the escaped -// string to 'dest'. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT void CEscapeAndAppend(StringPiece src, std::string* dest); - -namespace strings { -// Like CEscape() but does not escape bytes with the upper bit set. -PROTOBUF_EXPORT std::string Utf8SafeCEscape(const std::string& src); - -// Like CEscape() but uses hex (\x) escapes instead of octals. -PROTOBUF_EXPORT std::string CHexEscape(const std::string& src); -} // namespace strings - -// ---------------------------------------------------------------------- -// strto32() -// strtou32() -// strto64() -// strtou64() -// Architecture-neutral plug compatible replacements for strtol() and -// strtoul(). Long's have different lengths on ILP-32 and LP-64 -// platforms, so using these is safer, from the point of view of -// overflow behavior, than using the standard libc functions. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT int32_t strto32_adaptor(const char* nptr, char** endptr, - int base); -PROTOBUF_EXPORT uint32_t strtou32_adaptor(const char* nptr, char** endptr, - int base); - -inline int32_t strto32(const char *nptr, char **endptr, int base) { - if (sizeof(int32_t) == sizeof(long)) - return strtol(nptr, endptr, base); - else - return strto32_adaptor(nptr, endptr, base); -} - -inline uint32_t strtou32(const char *nptr, char **endptr, int base) { - if (sizeof(uint32_t) == sizeof(unsigned long)) - return strtoul(nptr, endptr, base); - else - return strtou32_adaptor(nptr, endptr, base); -} - -// For now, long long is 64-bit on all the platforms we care about, so these -// functions can simply pass the call to strto[u]ll. -inline int64_t strto64(const char *nptr, char **endptr, int base) { - static_assert(sizeof(int64_t) == sizeof(long long), - "sizeof int64_t is not sizeof long long"); - return strtoll(nptr, endptr, base); -} - -inline uint64_t strtou64(const char *nptr, char **endptr, int base) { - static_assert(sizeof(uint64_t) == sizeof(unsigned long long), - "sizeof uint64_t is not sizeof unsigned long long"); - return strtoull(nptr, endptr, base); -} - -// ---------------------------------------------------------------------- -// safe_strtob() -// safe_strto32() -// safe_strtou32() -// safe_strto64() -// safe_strtou64() -// safe_strtof() -// safe_strtod() -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value); - -PROTOBUF_EXPORT bool safe_strto32(const std::string& str, int32_t* value); -PROTOBUF_EXPORT bool safe_strtou32(const std::string& str, uint32_t* value); -inline bool safe_strto32(const char* str, int32_t* value) { - return safe_strto32(std::string(str), value); -} -inline bool safe_strto32(StringPiece str, int32_t* value) { - return safe_strto32(str.ToString(), value); -} -inline bool safe_strtou32(const char* str, uint32_t* value) { - return safe_strtou32(std::string(str), value); -} -inline bool safe_strtou32(StringPiece str, uint32_t* value) { - return safe_strtou32(str.ToString(), value); -} - -PROTOBUF_EXPORT bool safe_strto64(const std::string& str, int64_t* value); -PROTOBUF_EXPORT bool safe_strtou64(const std::string& str, uint64_t* value); -inline bool safe_strto64(const char* str, int64_t* value) { - return safe_strto64(std::string(str), value); -} -inline bool safe_strto64(StringPiece str, int64_t* value) { - return safe_strto64(str.ToString(), value); -} -inline bool safe_strtou64(const char* str, uint64_t* value) { - return safe_strtou64(std::string(str), value); -} -inline bool safe_strtou64(StringPiece str, uint64_t* value) { - return safe_strtou64(str.ToString(), value); -} - -PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value); -PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value); -inline bool safe_strtof(const std::string& str, float* value) { - return safe_strtof(str.c_str(), value); -} -inline bool safe_strtod(const std::string& str, double* value) { - return safe_strtod(str.c_str(), value); -} -inline bool safe_strtof(StringPiece str, float* value) { - return safe_strtof(str.ToString(), value); -} -inline bool safe_strtod(StringPiece str, double* value) { - return safe_strtod(str.ToString(), value); -} - -// ---------------------------------------------------------------------- -// FastIntToBuffer() -// FastHexToBuffer() -// FastHex64ToBuffer() -// FastHex32ToBuffer() -// FastTimeToBuffer() -// These are intended for speed. FastIntToBuffer() assumes the -// integer is non-negative. FastHexToBuffer() puts output in -// hex rather than decimal. FastTimeToBuffer() puts the output -// into RFC822 format. -// -// FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format, -// padded to exactly 16 bytes (plus one byte for '\0') -// -// FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format, -// padded to exactly 8 bytes (plus one byte for '\0') -// -// All functions take the output buffer as an arg. -// They all return a pointer to the beginning of the output, -// which may not be the beginning of the input buffer. -// ---------------------------------------------------------------------- - -// Suggested buffer size for FastToBuffer functions. Also works with -// DoubleToBuffer() and FloatToBuffer(). -static const int kFastToBufferSize = 32; - -PROTOBUF_EXPORT char* FastInt32ToBuffer(int32_t i, char* buffer); -PROTOBUF_EXPORT char* FastInt64ToBuffer(int64_t i, char* buffer); -char* FastUInt32ToBuffer(uint32_t i, char* buffer); // inline below -char* FastUInt64ToBuffer(uint64_t i, char* buffer); // inline below -PROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer); -PROTOBUF_EXPORT char* FastHex64ToBuffer(uint64_t i, char* buffer); -PROTOBUF_EXPORT char* FastHex32ToBuffer(uint32_t i, char* buffer); - -// at least 22 bytes long -inline char* FastIntToBuffer(int i, char* buffer) { - return (sizeof(i) == 4 ? - FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer)); -} -inline char* FastUIntToBuffer(unsigned int i, char* buffer) { - return (sizeof(i) == 4 ? - FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer)); -} -inline char* FastLongToBuffer(long i, char* buffer) { - return (sizeof(i) == 4 ? - FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer)); -} -inline char* FastULongToBuffer(unsigned long i, char* buffer) { - return (sizeof(i) == 4 ? - FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer)); -} - -// ---------------------------------------------------------------------- -// FastInt32ToBufferLeft() -// FastUInt32ToBufferLeft() -// FastInt64ToBufferLeft() -// FastUInt64ToBufferLeft() -// -// Like the Fast*ToBuffer() functions above, these are intended for speed. -// Unlike the Fast*ToBuffer() functions, however, these functions write -// their output to the beginning of the buffer (hence the name, as the -// output is left-aligned). The caller is responsible for ensuring that -// the buffer has enough space to hold the output. -// -// Returns a pointer to the end of the string (i.e. the null character -// terminating the string). -// ---------------------------------------------------------------------- - -PROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32_t i, char* buffer); -PROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32_t i, char* buffer); -PROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64_t i, char* buffer); -PROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64_t i, char* buffer); - -// Just define these in terms of the above. -inline char* FastUInt32ToBuffer(uint32_t i, char* buffer) { - FastUInt32ToBufferLeft(i, buffer); - return buffer; -} -inline char* FastUInt64ToBuffer(uint64_t i, char* buffer) { - FastUInt64ToBufferLeft(i, buffer); - return buffer; -} - -inline std::string SimpleBtoa(bool value) { return value ? "true" : "false"; } - -// ---------------------------------------------------------------------- -// SimpleItoa() -// Description: converts an integer to a string. -// -// Return value: string -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT std::string SimpleItoa(int i); -PROTOBUF_EXPORT std::string SimpleItoa(unsigned int i); -PROTOBUF_EXPORT std::string SimpleItoa(long i); -PROTOBUF_EXPORT std::string SimpleItoa(unsigned long i); -PROTOBUF_EXPORT std::string SimpleItoa(long long i); -PROTOBUF_EXPORT std::string SimpleItoa(unsigned long long i); - -// ---------------------------------------------------------------------- -// SimpleDtoa() -// SimpleFtoa() -// DoubleToBuffer() -// FloatToBuffer() -// Description: converts a double or float to a string which, if -// passed to NoLocaleStrtod(), will produce the exact same original double -// (except in case of NaN; all NaNs are considered the same value). -// We try to keep the string short but it's not guaranteed to be as -// short as possible. -// -// DoubleToBuffer() and FloatToBuffer() write the text to the given -// buffer and return it. The buffer must be at least -// kDoubleToBufferSize bytes for doubles and kFloatToBufferSize -// bytes for floats. kFastToBufferSize is also guaranteed to be large -// enough to hold either. -// -// Return value: string -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT std::string SimpleDtoa(double value); -PROTOBUF_EXPORT std::string SimpleFtoa(float value); - -PROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer); -PROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer); - -// In practice, doubles should never need more than 24 bytes and floats -// should never need more than 14 (including null terminators), but we -// overestimate to be safe. -static const int kDoubleToBufferSize = 32; -static const int kFloatToBufferSize = 24; - -namespace strings { - -enum PadSpec { - NO_PAD = 1, - ZERO_PAD_2, - ZERO_PAD_3, - ZERO_PAD_4, - ZERO_PAD_5, - ZERO_PAD_6, - ZERO_PAD_7, - ZERO_PAD_8, - ZERO_PAD_9, - ZERO_PAD_10, - ZERO_PAD_11, - ZERO_PAD_12, - ZERO_PAD_13, - ZERO_PAD_14, - ZERO_PAD_15, - ZERO_PAD_16, -}; - -struct Hex { - uint64_t value; - enum PadSpec spec; - template <class Int> - explicit Hex(Int v, PadSpec s = NO_PAD) - : spec(s) { - // Prevent sign-extension by casting integers to - // their unsigned counterparts. -#ifdef LANG_CXX11 - static_assert( - sizeof(v) == 1 || sizeof(v) == 2 || sizeof(v) == 4 || sizeof(v) == 8, - "Unknown integer type"); -#endif - value = sizeof(v) == 1 ? static_cast<uint8_t>(v) - : sizeof(v) == 2 ? static_cast<uint16_t>(v) - : sizeof(v) == 4 ? static_cast<uint32_t>(v) - : static_cast<uint64_t>(v); - } -}; - -struct PROTOBUF_EXPORT AlphaNum { - const char *piece_data_; // move these to string_ref eventually - size_t piece_size_; // move these to string_ref eventually - - char digits[kFastToBufferSize]; - - // No bool ctor -- bools convert to an integral type. - // A bool ctor would also convert incoming pointers (bletch). - - AlphaNum(int i32) - : piece_data_(digits), - piece_size_(FastInt32ToBufferLeft(i32, digits) - &digits[0]) {} - AlphaNum(unsigned int u32) - : piece_data_(digits), - piece_size_(FastUInt32ToBufferLeft(u32, digits) - &digits[0]) {} - AlphaNum(long long i64) - : piece_data_(digits), - piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {} - AlphaNum(unsigned long long u64) - : piece_data_(digits), - piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {} - - // Note: on some architectures, "long" is only 32 bits, not 64, but the - // performance hit of using FastInt64ToBufferLeft to handle 32-bit values - // is quite minor. - AlphaNum(long i64) - : piece_data_(digits), - piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {} - AlphaNum(unsigned long u64) - : piece_data_(digits), - piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {} - - AlphaNum(float f) - : piece_data_(digits), piece_size_(strlen(FloatToBuffer(f, digits))) {} - AlphaNum(double f) - : piece_data_(digits), piece_size_(strlen(DoubleToBuffer(f, digits))) {} - - AlphaNum(Hex hex); - - AlphaNum(const char* c_str) - : piece_data_(c_str), piece_size_(strlen(c_str)) {} - // TODO: Add a string_ref constructor, eventually - // AlphaNum(const StringPiece &pc) : piece(pc) {} - - AlphaNum(const std::string& str) - : piece_data_(str.data()), piece_size_(str.size()) {} - - AlphaNum(StringPiece str) - : piece_data_(str.data()), piece_size_(str.size()) {} - - size_t size() const { return piece_size_; } - const char *data() const { return piece_data_; } - - private: - // Use ":" not ':' - AlphaNum(char c); // NOLINT(runtime/explicit) - - // Disallow copy and assign. - AlphaNum(const AlphaNum&); - void operator=(const AlphaNum&); -}; - -} // namespace strings - -using strings::AlphaNum; - -// ---------------------------------------------------------------------- -// StrCat() -// This merges the given strings or numbers, with no delimiter. This -// is designed to be the fastest possible way to construct a string out -// of a mix of raw C strings, strings, bool values, -// and numeric values. -// -// Don't use this for user-visible strings. The localization process -// works poorly on strings built up out of fragments. -// -// For clarity and performance, don't use StrCat when appending to a -// string. In particular, avoid using any of these (anti-)patterns: -// str.append(StrCat(...) -// str += StrCat(...) -// str = StrCat(str, ...) -// where the last is the worse, with the potential to change a loop -// from a linear time operation with O(1) dynamic allocations into a -// quadratic time operation with O(n) dynamic allocations. StrAppend -// is a better choice than any of the above, subject to the restriction -// of StrAppend(&str, a, b, c, ...) that none of the a, b, c, ... may -// be a reference into str. -// ---------------------------------------------------------------------- - -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d, - const AlphaNum& e); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d, - const AlphaNum& e, const AlphaNum& f); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d, - const AlphaNum& e, const AlphaNum& f, - const AlphaNum& g); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d, - const AlphaNum& e, const AlphaNum& f, - const AlphaNum& g, const AlphaNum& h); -PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, - const AlphaNum& c, const AlphaNum& d, - const AlphaNum& e, const AlphaNum& f, - const AlphaNum& g, const AlphaNum& h, - const AlphaNum& i); - -inline std::string StrCat(const AlphaNum& a) { - return std::string(a.data(), a.size()); -} - -// ---------------------------------------------------------------------- -// StrAppend() -// Same as above, but adds the output to the given string. -// WARNING: For speed, StrAppend does not try to check each of its input -// arguments to be sure that they are not a subset of the string being -// appended to. That is, while this will work: -// -// string s = "foo"; -// s += s; -// -// This will not (necessarily) work: -// -// string s = "foo"; -// StrAppend(&s, s); -// -// Note: while StrCat supports appending up to 9 arguments, StrAppend -// is currently limited to 4. That's rarely an issue except when -// automatically transforming StrCat to StrAppend, and can easily be -// worked around as consecutive calls to StrAppend are quite efficient. -// ---------------------------------------------------------------------- - -PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a); -PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a, - const AlphaNum& b); -PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a, - const AlphaNum& b, const AlphaNum& c); -PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a, - const AlphaNum& b, const AlphaNum& c, - const AlphaNum& d); - -// ---------------------------------------------------------------------- -// Join() -// These methods concatenate a range of components into a C++ string, using -// the C-string "delim" as a separator between components. -// ---------------------------------------------------------------------- -template <typename Iterator> -void Join(Iterator start, Iterator end, const char* delim, - std::string* result) { - for (Iterator it = start; it != end; ++it) { - if (it != start) { - result->append(delim); - } - StrAppend(result, *it); - } -} - -template <typename Range> -std::string Join(const Range& components, const char* delim) { - std::string result; - Join(components.begin(), components.end(), delim, &result); - return result; -} - -// ---------------------------------------------------------------------- -// ToHex() -// Return a lower-case hex string representation of the given integer. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT std::string ToHex(uint64_t num); - -// ---------------------------------------------------------------------- -// GlobalReplaceSubstring() -// Replaces all instances of a substring in a string. Does nothing -// if 'substring' is empty. Returns the number of replacements. -// -// NOTE: The string pieces must not overlap s. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT int GlobalReplaceSubstring(const std::string& substring, - const std::string& replacement, - std::string* s); - -// ---------------------------------------------------------------------- -// Base64Unescape() -// Converts "src" which is encoded in Base64 to its binary equivalent and -// writes it to "dest". If src contains invalid characters, dest is cleared -// and the function returns false. Returns true on success. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT bool Base64Unescape(StringPiece src, std::string* dest); - -// ---------------------------------------------------------------------- -// WebSafeBase64Unescape() -// This is a variation of Base64Unescape which uses '-' instead of '+', and -// '_' instead of '/'. src is not null terminated, instead specify len. I -// recommend that slen<szdest, but we honor szdest anyway. -// RETURNS the length of dest, or -1 if src contains invalid chars. - -// The variation that stores into a string clears the string first, and -// returns false (with dest empty) if src contains invalid chars; for -// this version src and dest must be different strings. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT int WebSafeBase64Unescape(const char* src, int slen, char* dest, - int szdest); -PROTOBUF_EXPORT bool WebSafeBase64Unescape(StringPiece src, std::string* dest); - -// Return the length to use for the output buffer given to the base64 escape -// routines. Make sure to use the same value for do_padding in both. -// This function may return incorrect results if given input_len values that -// are extremely high, which should happen rarely. -PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len, bool do_padding); -// Use this version when calling Base64Escape without a do_padding arg. -PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len); - -// ---------------------------------------------------------------------- -// Base64Escape() -// WebSafeBase64Escape() -// Encode "src" to "dest" using base64 encoding. -// src is not null terminated, instead specify len. -// 'dest' should have at least CalculateBase64EscapedLen() length. -// RETURNS the length of dest. -// The WebSafe variation use '-' instead of '+' and '_' instead of '/' -// so that we can place the out in the URL or cookies without having -// to escape them. It also has an extra parameter "do_padding", -// which when set to false will prevent padding with "=". -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT int Base64Escape(const unsigned char* src, int slen, char* dest, - int szdest); -PROTOBUF_EXPORT int WebSafeBase64Escape(const unsigned char* src, int slen, - char* dest, int szdest, - bool do_padding); -// Encode src into dest with padding. -PROTOBUF_EXPORT void Base64Escape(StringPiece src, std::string* dest); -// Encode src into dest web-safely without padding. -PROTOBUF_EXPORT void WebSafeBase64Escape(StringPiece src, std::string* dest); -// Encode src into dest web-safely with padding. -PROTOBUF_EXPORT void WebSafeBase64EscapeWithPadding(StringPiece src, - std::string* dest); - -PROTOBUF_EXPORT void Base64Escape(const unsigned char* src, int szsrc, - std::string* dest, bool do_padding); -PROTOBUF_EXPORT void WebSafeBase64Escape(const unsigned char* src, int szsrc, - std::string* dest, bool do_padding); - -inline bool IsValidCodePoint(uint32_t code_point) { - return code_point < 0xD800 || - (code_point >= 0xE000 && code_point <= 0x10FFFF); -} - -static const int UTFmax = 4; -// ---------------------------------------------------------------------- -// EncodeAsUTF8Char() -// Helper to append a Unicode code point to a string as UTF8, without bringing -// in any external dependencies. The output buffer must be as least 4 bytes -// large. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT int EncodeAsUTF8Char(uint32_t code_point, char* output); - -// ---------------------------------------------------------------------- -// UTF8FirstLetterNumBytes() -// Length of the first UTF-8 character. -// ---------------------------------------------------------------------- -PROTOBUF_EXPORT int UTF8FirstLetterNumBytes(const char* src, int len); - -// From google3/third_party/absl/strings/escaping.h - -// ---------------------------------------------------------------------- -// CleanStringLineEndings() -// Clean up a multi-line string to conform to Unix line endings. -// Reads from src and appends to dst, so usually dst should be empty. -// -// If there is no line ending at the end of a non-empty string, it can -// be added automatically. -// -// Four different types of input are correctly handled: -// -// - Unix/Linux files: line ending is LF: pass through unchanged -// -// - DOS/Windows files: line ending is CRLF: convert to LF -// -// - Legacy Mac files: line ending is CR: convert to LF -// -// - Garbled files: random line endings: convert gracefully -// lonely CR, lonely LF, CRLF: convert to LF -// -// @param src The multi-line string to convert -// @param dst The converted string is appended to this string -// @param auto_end_last_line Automatically terminate the last line -// -// Limitations: -// -// This does not do the right thing for CRCRLF files created by -// broken programs that do another Unix->DOS conversion on files -// that are already in CRLF format. For this, a two-pass approach -// brute-force would be needed that -// -// (1) determines the presence of LF (first one is ok) -// (2) if yes, removes any CR, else convert every CR to LF -PROTOBUF_EXPORT void CleanStringLineEndings(const std::string& src, - std::string* dst, - bool auto_end_last_line); - -// Same as above, but transforms the argument in place. -PROTOBUF_EXPORT void CleanStringLineEndings(std::string* str, - bool auto_end_last_line); - -namespace strings { -inline bool EndsWith(StringPiece text, StringPiece suffix) { - return suffix.empty() || - (text.size() >= suffix.size() && - memcmp(text.data() + (text.size() - suffix.size()), suffix.data(), - suffix.size()) == 0); -} -} // namespace strings - -namespace internal { - -// A locale-independent version of the standard strtod(), which always -// uses a dot as the decimal separator. -double NoLocaleStrtod(const char* str, char** endptr); - -} // namespace internal - -} // namespace protobuf -} // namespace google - -#include <google/protobuf/port_undef.inc> - -#endif // GOOGLE_PROTOBUF_STUBS_STRUTIL_H__ |