third_party/protobuf/src/google/protobuf/stubs/strutil.h - Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll).

Unified Diff: third_party/protobuf/src/google/protobuf/stubs/strutil.h

Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 5 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« no previous file with comments | « third_party/protobuf/src/google/protobuf/stubs/stringprintf_unittest.cc ('k') | third_party/protobuf/src/google/protobuf/stubs/strutil.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: third_party/protobuf/src/google/protobuf/stubs/strutil.h

diff --git a/third_party/protobuf/src/google/protobuf/stubs/strutil.h b/third_party/protobuf/src/google/protobuf/stubs/strutil.h

index b22066b61675c0843110ddb2b89c6ef797121640..a401c63a91823a4def98bbedc060161e6c40eb7d 100644

--- a/third_party/protobuf/src/google/protobuf/stubs/strutil.h

+++ b/third_party/protobuf/src/google/protobuf/stubs/strutil.h

@@ -1,6 +1,6 @@

// Protocol Buffers - Google's data interchange format

-// https://developers.google.com/protocol-buffers/

+// http://code.google.com/p/protobuf/

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

@@ -36,7 +36,6 @@

#include <stdlib.h>

#include <vector>

#include <google/protobuf/stubs/common.h>

-#include <google/protobuf/stubs/stringpiece.h>

namespace google {

namespace protobuf {

@@ -58,8 +57,6 @@ namespace protobuf {

// 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) {

@@ -72,36 +69,6 @@ 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.

@@ -152,19 +119,13 @@ inline string StripSuffixString(const string& str, const string& suffix) {

// 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.

// ----------------------------------------------------------------------

LIBPROTOBUF_EXPORT void StripString(string* s, const char* remove,

char replacewith);

-LIBPROTOBUF_EXPORT void StripWhitespace(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

@@ -187,12 +148,6 @@ inline void UpperString(string * s) {

}

-inline string ToUpper(const string& s) {

- string out = s;

- UpperString(&out);

- return out;

// ----------------------------------------------------------------------

// StringReplace()

// Give me a string and two patterns "old" and "new", and I replace

@@ -226,21 +181,6 @@ LIBPROTOBUF_EXPORT void SplitStringAllowEmpty(const string& full,

vector<string>* result);

// ----------------------------------------------------------------------

-// Split()

-// Split a string using a character delimiter.

-// ----------------------------------------------------------------------

-inline vector<string> Split(

- const string& full, const char* delim, bool skip_empty = true) {

- vector<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

@@ -387,62 +327,6 @@ inline uint64 strtou64(const char *nptr, char **endptr, int base) {

}

// ----------------------------------------------------------------------

-// safe_strtob()

-// safe_strto32()

-// safe_strtou32()

-// safe_strto64()

-// safe_strtou64()

-// safe_strtof()

-// safe_strtod()

-// ----------------------------------------------------------------------

-LIBPROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value);

-LIBPROTOBUF_EXPORT bool safe_strto32(const string& str, int32* value);

-LIBPROTOBUF_EXPORT bool safe_strtou32(const string& str, uint32* value);

-inline bool safe_strto32(const char* str, int32* value) {

- return safe_strto32(string(str), value);

-inline bool safe_strto32(StringPiece str, int32* value) {

- return safe_strto32(str.ToString(), value);

-inline bool safe_strtou32(const char* str, uint32* value) {

- return safe_strtou32(string(str), value);

-inline bool safe_strtou32(StringPiece str, uint32* value) {

- return safe_strtou32(str.ToString(), value);

-LIBPROTOBUF_EXPORT bool safe_strto64(const string& str, int64* value);

-LIBPROTOBUF_EXPORT bool safe_strtou64(const string& str, uint64* value);

-inline bool safe_strto64(const char* str, int64* value) {

- return safe_strto64(string(str), value);

-inline bool safe_strto64(StringPiece str, int64* value) {

- return safe_strto64(str.ToString(), value);

-inline bool safe_strtou64(const char* str, uint64* value) {

- return safe_strtou64(string(str), value);

-inline bool safe_strtou64(StringPiece str, uint64* value) {

- return safe_strtou64(str.ToString(), value);

-LIBPROTOBUF_EXPORT bool safe_strtof(const char* str, float* value);

-LIBPROTOBUF_EXPORT bool safe_strtod(const char* str, double* value);

-inline bool safe_strtof(const string& str, float* value) {

- return safe_strtof(str.c_str(), value);

-inline bool safe_strtod(const 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()

@@ -525,10 +409,6 @@ inline char* FastUInt64ToBuffer(uint64 i, char* buffer) {

return buffer;

}

-inline string SimpleBtoa(bool value) {

- return value ? "true" : "false";

// ----------------------------------------------------------------------

// SimpleItoa()

// Description: converts an integer to a string.

@@ -573,300 +453,13 @@ LIBPROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer);

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 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>(v)

- : sizeof(v) == 2 ? static_cast<uint16>(v)

- : sizeof(v) == 4 ? static_cast<uint32>(v)

- : static_cast<uint64>(v);

- }

-};

-struct LIBPROTOBUF_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(int32 i32)

- : piece_data_(digits),

- piece_size_(FastInt32ToBufferLeft(i32, digits) - &digits[0]) {}

- AlphaNum(uint32 u32)

- : piece_data_(digits),

- piece_size_(FastUInt32ToBufferLeft(u32, digits) - &digits[0]) {}

- AlphaNum(int64 i64)

- : piece_data_(digits),

- piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {}

- AlphaNum(uint64 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 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.

-// ----------------------------------------------------------------------

-LIBPROTOBUF_EXPORT string StrCat(const AlphaNum& a, const AlphaNum& b);