Initial commit of sync engine code to browser/sync....

chrome/browser/sync/notifier/base/string.h

+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_SYNC_NOTIFIER_BASE_STRING_H_
+#define CHROME_BROWSER_SYNC_NOTIFIER_BASE_STRING_H_
+
+#ifdef COMPILER_MSVC
+#include <xhash>
+#elif defined(__GNUC__)
+#include <ext/hash_map>
+#endif
+
+#include <ctype.h>
+#include <string>
+
+#include "chrome/browser/sync/notifier/base/fastalloc.h"
+#include "talk/base/basictypes.h"
+
+namespace notifier {
+
+// Does html encoding of strings.
+std::string HtmlEncode(const std::string& src);
+
+// Does html decoding of strings.
+std::string HtmlDecode(const std::string& src);
+
+// Does utl encoding of strings.
+std::string UrlEncode(const std::string& src);
+
+// Does url decoding of strings.
+std::string UrlDecode(const std::string& src);
+
+// Convert a character to a digit
+// if the character is not a digit return -1 (same as CRT)
+inline int CharToDigit(char c) {
+  return ((c) >= '0' && (c) <= '9' ? (c) - '0' : -1);
+}
+
+int CharToHexValue(char hex);
+
+// ----------------------------------------------------------------------
+// ParseStringToInt()
+// ParseStringToUint()
+// ParseStringToInt64()
+// ParseStringToDouble()
+//    Convert a string to an int/int64/double
+//    If strict is true, check for the validity and overflow
+// ----------------------------------------------------------------------
+
+bool ParseStringToInt(const char* str, int* value, bool strict);
+
+bool ParseStringToUint(const char* str, uint32* value, bool strict);
+
+bool ParseStringToInt64(const char* str, int64* value, bool strict);
+
+bool ParseStringToDouble(const char* str, double* value, bool strict);
+
+// ----------------------------------------------------------------------
+// StringToInt()
+// StringToUint()
+// StringToInt64()
+// StringToDouble()
+//    Convert a string to an int/int64/double
+//    Note that these functions do not check for the validity or overflow
+// ----------------------------------------------------------------------
+
+int StringToInt(const char* str);
+
+uint32 StringToUint(const char* str);
+
+int64 StringToInt64(const char* str);
+
+double StringToDouble(const char* str);
+
+// ----------------------------------------------------------------------
+// FloatToString()
+// DoubleToString()
+// IntToString()
+// UIntToString()
+// Int64ToString()
+// UInt64ToString()
+//    Convert various types to their string representation.  These
+//    all do the obvious, trivial thing.
+// ----------------------------------------------------------------------
+
+std::string FloatToString(float f);
+std::string DoubleToString(double d);
+
+std::string IntToString(int i);
+std::string UIntToString(uint32 i);
+
+std::string Int64ToString(int64 i64);
+std::string UInt64ToString(uint64 i64);
+
+std::string Int64ToHexString(int64 i64);
+
+// ----------------------------------------------------------------------
+// StringStartsWith()
+// StringEndsWith()
+//    Check if a string starts or ends with a pattern
+// ----------------------------------------------------------------------
+
+inline bool StringStartsWith(const std::string& s, const char* p) {
+  return s.find(p) == 0;
+}
+
+inline bool StringEndsWith(const std::string& s, const char* p) {
+  return s.rfind(p) == (s.length() - strlen(p));
+}
+
+// ----------------------------------------------------------------------
+// MakeStringEndWith()
+//   If the string does not end with a pattern, make it end with it
+// ----------------------------------------------------------------------
+
+inline std::string MakeStringEndWith(const std::string& s, const char* p) {
+  if (StringEndsWith(s, p)) {
+    return s;
+  } else {
+    std::string ns(s);
+    ns += p;
+    return ns;
+  }
+}
+
+// Convert a lower_case_string to LowerCaseString
+std::string LowerWithUnderToPascalCase(const char* lower_with_under);
+
+// Convert a PascalCaseString to pascal_case_string
+std::string PascalCaseToLowerWithUnder(const char* pascal_case);
+
+// ----------------------------------------------------------------------
+// LowerString()
+// LowerStringToBuf()
+//    Convert the characters in "s" to lowercase.
+//    Changes contents of "s".  LowerStringToBuf copies at most
+//    "n" characters (including the terminating '\0')  from "s"
+//    to another buffer.
+// ----------------------------------------------------------------------
+
+inline void LowerString(char* s) {
+  for (; *s; ++s) {
+    *s = tolower(*s);
+  }
+}
+
+inline void LowerString(std::string* s) {
+  std::string::iterator end = s->end();
+  for (std::string::iterator i = s->begin(); i != end; ++i) {
+    *i = tolower(*i);
+  }
+}
+
+inline void LowerStringToBuf(const char* s, char* buf, int n) {
+  for (int i = 0; i < n - 1; ++i) {
+    char c = s[i];
+    buf[i] = tolower(c);
+    if (c == '\0') {
+      return;
+    }
+  }
+  buf[n - 1] = '\0';
+}
+
+// ----------------------------------------------------------------------
+// UpperString()
+// UpperStringToBuf()
+//    Convert the characters in "s" to uppercase.
+//    UpperString changes "s". UpperStringToBuf copies at most
+//    "n" characters (including the terminating '\0')  from "s"
+//    to another buffer.
+// ----------------------------------------------------------------------
+
+inline void UpperString(char* s) {
+  for (; *s; ++s) {
+    *s = toupper(*s);
+  }
+}
+
+inline void UpperString(std::string* s) {
+  for (std::string::iterator iter = s->begin(); iter != s->end(); ++iter) {
+    *iter = toupper(*iter);
+  }
+}
+
+inline void UpperStringToBuf(const char* s, char* buf, int n) {
+  for (int i = 0; i < n - 1; ++i) {
+    char c = s[i];
+    buf[i] = toupper(c);
+    if (c == '\0') {
+      return;
+    }
+  }
+  buf[n - 1] = '\0';
+}
+
+// ----------------------------------------------------------------------
+// TrimStringLeft
+//    Removes any occurrences of the characters in 'remove' from the start
+//    of the string.  Returns the number of chars trimmed.
+// ----------------------------------------------------------------------
+inline int TrimStringLeft(std::string* s, const char* remove) {
+  int i = 0;
+  for (; i < static_cast<int>(s->size()) && strchr(remove, (*s)[i]); ++i);
+  if (i > 0) s->erase(0, i);
+  return i;
+}
+
+// ----------------------------------------------------------------------
+// TrimStringRight
+//    Removes any occurrences of the characters in 'remove' from the end
+//    of the string.  Returns the number of chars trimmed.
+// ----------------------------------------------------------------------
+inline int TrimStringRight(std::string* s, const char* remove) {
+  int size = static_cast<int>(s->size());
+  int i = size;
+  for (; i > 0 && strchr(remove, (*s)[i - 1]); --i);
+  if (i < size) {
+    s->erase(i);
+  }
+  return size - i;
+}
+
+// ----------------------------------------------------------------------
+// TrimString
+//    Removes any occurrences of the characters in 'remove' from either
+//    end of the string.
+// ----------------------------------------------------------------------
+inline int TrimString(std::string* s, const char* remove) {
+  return TrimStringRight(s, remove) + TrimStringLeft(s, remove);
+}
+
+// ----------------------------------------------------------------------
+// StringReplace()
+//    Replace the "old" pattern with the "new" pattern in a string.  If
+//    replace_all is false, it only replaces the first instance of "old."
+// ----------------------------------------------------------------------
+
+void StringReplace(std::string* s,
+                   const char* old_sub,
+                   const char* new_sub,
+                   bool replace_all);
+
+inline size_t HashString(const std::string &value) {
+#ifdef COMPILER_MSVC
+  return stdext::hash_value(value);
+#elif defined(__GNUC__)
+  __gnu_cxx::hash<const char*> h;
+  return h(value.c_str());
+#else
+  // Compile time error because we don't return a value
+#endif
+}
+
+// ----------------------------------------------------------------------
+// SplitOneStringToken()
+//   Parse a single "delim" delimited string from "*source"
+//   Modify *source to point after the delimiter.
+//   If no delimiter is present after the string, set *source to NULL.
+//
+//   If the start of *source is a delimiter, return an empty string.
+//   If *source is NULL, return an empty string.
+// ----------------------------------------------------------------------
+std::string SplitOneStringToken(const char** source, const char* delim);
+
+//----------------------------------------------------------------------
+// CharTraits provides wrappers with common function names for char/wchar_t
+// specific CRT functions
+//----------------------------------------------------------------------
+
+template <class CharT> struct CharTraits {
+};
+
+template <>
+struct CharTraits<char> {
+  static inline size_t length(const char* s) {
+    return strlen(s);
+  }
+  static inline bool copy(char* dst, size_t dst_size, const char* s) {
+    if (s == NULL || dst == NULL)
+      return false;
+    else
+      return copy_num(dst, dst_size, s, strlen(s));
+  }
+  static inline bool copy_num(char* dst, size_t dst_size, const char* s,
+                              size_t s_len) {
+    if (dst_size < (s_len + 1))
+      return false;
+    memcpy(dst, s, s_len);
+    dst[s_len] = '\0';
+    return true;
+  }
+};
+
+template <>
+struct CharTraits<wchar_t> {
+  static inline size_t length(const wchar_t* s) {
+    return wcslen(s);
+  }
+  static inline bool copy(wchar_t* dst, size_t dst_size, const wchar_t* s) {
+    if (s == NULL || dst == NULL)
+      return false;
+    else
+      return copy_num(dst, dst_size, s, wcslen(s));
+  }
+  static inline bool copy_num(wchar_t* dst, size_t dst_size, const wchar_t* s,
+                              size_t s_len) {
+    if (dst_size < (s_len + 1)) {
+      return false;
+    }
+    memcpy(dst, s, s_len * sizeof(wchar_t));
+    dst[s_len] = '\0';
+    return true;
+  }
+};
+
+//----------------------------------------------------------------------
+// This class manages a fixed-size, null-terminated string buffer.  It is
+// meant to be allocated on the stack, and it makes no use of the heap
+// internally. In most cases you'll just want to use a std::(w)string, but
+// when you need to avoid the heap, you can use this class instead.
+//
+// Methods are provided to read the null-terminated buffer and to append
+// data to the buffer, and once the buffer fills-up, it simply discards any
+// extra append calls.
+//----------------------------------------------------------------------
+
+template <class CharT, int MaxSize>
+class FixedString {
+ public:
+  typedef CharTraits<CharT> char_traits;
+
+  FixedString() : index_(0), truncated_(false) {
+    buf_[0] = CharT(0);
+  }
+
+  ~FixedString() {
+    memset(buf_, 0xCC, sizeof(buf_));
+  }
+
+  // Returns true if the Append ever failed.
+  bool was_truncated() const { return truncated_; }
+
+  // Returns the number of characters in the string, excluding the null
+  // terminator.
+  size_t size() const { return index_; }
+
+  // Returns the null-terminated string.
+  const CharT* get() const { return buf_; }
+  CharT* get() { return buf_; }
+
+  // Append an array of characters.  The operation is bounds checked, and if
+  // there is insufficient room, then the was_truncated() flag is set to true.
+  void Append(const CharT* s, size_t n) {
+    if (char_traits::copy_num(buf_ + index_, arraysize(buf_) - index_, s, n)) {
+      index_ += n;
+    } else {
+      truncated_ = true;
+    }
+  }
+
+  // Append a null-terminated string.
+  void Append(const CharT* s) {
+    Append(s, char_traits::length(s));
+  }
+
+  // Append a single character.
+  void Append(CharT c) {
+    Append(&c, 1);
+  }
+
+ private:
+  CharT buf_[MaxSize];
+  size_t index_;
+  bool truncated_;
+};
+
+}  // namespace notifier
+
+#endif  // CHROME_BROWSER_SYNC_NOTIFIER_BASE_STRING_H_