Revert 114929 - Standardize StringToInt{,64} interface.

base/string_number_conversions.cc

 // Copyright (c) 2011 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.
 
 #include "base/string_number_conversions.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <wctype.h>
@@ skipping 274 matching lines @@
   typedef VALUE value_type;
   static value_type min() {
     return std::numeric_limits<value_type>::min();
   }
   static value_type max() {
     return std::numeric_limits<value_type>::max();
   }
   static const int kBase = BASE;
 };
 
+typedef BaseIteratorRangeToNumberTraits<std::string::const_iterator, int, 10>
+    IteratorRangeToIntTraits;
+typedef BaseIteratorRangeToNumberTraits<string16::const_iterator, int, 10>
+    WideIteratorRangeToIntTraits;
+typedef BaseIteratorRangeToNumberTraits<std::string::const_iterator, int64, 10>
+    IteratorRangeToInt64Traits;
+typedef BaseIteratorRangeToNumberTraits<string16::const_iterator, int64, 10>
+    WideIteratorRangeToInt64Traits;
+
+typedef BaseIteratorRangeToNumberTraits<const char*, int, 10>
+    CharBufferToIntTraits;
+typedef BaseIteratorRangeToNumberTraits<const char16*, int, 10>
+    WideCharBufferToIntTraits;
+typedef BaseIteratorRangeToNumberTraits<const char*, int64, 10>
+    CharBufferToInt64Traits;
+typedef BaseIteratorRangeToNumberTraits<const char16*, int64, 10>
+    WideCharBufferToInt64Traits;
+
 template<typename ITERATOR>
 class BaseHexIteratorRangeToIntTraits
     : public BaseIteratorRangeToNumberTraits<ITERATOR, int, 16> {
  public:
   // Allow parsing of 0xFFFFFFFF, which is technically an overflow
   static unsigned int max() {
     return std::numeric_limits<unsigned int>::max();
   }
 };
 
-typedef BaseHexIteratorRangeToIntTraits<StringPiece::const_iterator>
+typedef BaseHexIteratorRangeToIntTraits<std::string::const_iterator>
     HexIteratorRangeToIntTraits;
+typedef BaseHexIteratorRangeToIntTraits<const char*>
+    HexCharBufferToIntTraits;
 
 template<typename STR>
 bool HexStringToBytesT(const STR& input, std::vector<uint8>* output) {
   DCHECK_EQ(output->size(), 0u);
   size_t count = input.size();
   if (count == 0 || (count % 2) != 0)
     return false;
   for (uintptr_t i = 0; i < count / 2; ++i) {
     uint8 msb = 0;  // most significant 4 bits
     uint8 lsb = 0;  // least significant 4 bits
     if (!CharToDigit<16>(input[i * 2], &msb) ||
         !CharToDigit<16>(input[i * 2 + 1], &lsb))
       return false;
     output->push_back((msb << 4) | lsb);
   }
   return true;
 }
 
-template <typename VALUE, int BASE>
-class StringPieceToNumberTraits
-    : public BaseIteratorRangeToNumberTraits<StringPiece::const_iterator,
-                                             VALUE,
-                                             BASE> {};
-
-template <typename VALUE>
-bool StringToIntImpl(const StringPiece& input, VALUE* output) {
-  return IteratorRangeToNumber<StringPieceToNumberTraits<VALUE, 10> >::Invoke(
-      input.begin(), input.end(), output);
-}
-
-template <typename VALUE, int BASE>
-class StringPiece16ToNumberTraits
-    : public BaseIteratorRangeToNumberTraits<StringPiece16::const_iterator,
-                                             VALUE,
-                                             BASE> {};
-
-template <typename VALUE>
-bool String16ToIntImpl(const StringPiece16& input, VALUE* output) {
-  return IteratorRangeToNumber<StringPiece16ToNumberTraits<VALUE, 10> >::Invoke(
-      input.begin(), input.end(), output);
-}
-
 }  // namespace
 
 std::string IntToString(int value) {
   return IntToStringT<std::string, int, unsigned int, true>::
       IntToString(value);
 }
 
 string16 IntToString16(int value) {
   return IntToStringT<string16, int, unsigned int, true>::
       IntToString(value);
@@ skipping 28 matching lines @@
       IntToString(value);
 }
 
 std::string DoubleToString(double value) {
   // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
   char buffer[32];
   dmg_fp::g_fmt(buffer, value);
   return std::string(buffer);
 }
 
-bool StringToInt(const StringPiece& input, int* output) {
-  return StringToIntImpl(input, output);
+bool StringToInt(const std::string& input, int* output) {
+  return IteratorRangeToNumber<IteratorRangeToIntTraits>::Invoke(input.begin(),
+                                                                 input.end(),
+                                                                 output);
 }
 
-bool StringToInt(const StringPiece16& input, int* output) {
-  return String16ToIntImpl(input, output);
+bool StringToInt(std::string::const_iterator begin,
+                 std::string::const_iterator end,
+                 int* output) {
+  return IteratorRangeToNumber<IteratorRangeToIntTraits>::Invoke(begin,
+                                                                 end,
+                                                                 output);
 }
 
-bool StringToInt64(const StringPiece& input, int64* output) {
-  return StringToIntImpl(input, output);
+#if !defined(STD_STRING_ITERATOR_IS_CHAR_POINTER)
+bool StringToInt(const char* begin, const char* end, int* output) {
+  return IteratorRangeToNumber<CharBufferToIntTraits>::Invoke(begin,
+                                                              end,
+                                                              output);
+}
+#endif
+
+bool StringToInt(const string16& input, int* output) {
+  return IteratorRangeToNumber<WideIteratorRangeToIntTraits>::Invoke(
+    input.begin(), input.end(), output);
 }
 
-bool StringToInt64(const StringPiece16& input, int64* output) {
-  return String16ToIntImpl(input, output);
+bool StringToInt(string16::const_iterator begin,
+                 string16::const_iterator end,
+                 int* output) {
+  return IteratorRangeToNumber<WideIteratorRangeToIntTraits>::Invoke(begin,
+                                                                     end,
+                                                                     output);
 }
 
+#if !defined(BASE_STRING16_ITERATOR_IS_CHAR16_POINTER)
+bool StringToInt(const char16* begin, const char16* end, int* output) {
+  return IteratorRangeToNumber<WideCharBufferToIntTraits>::Invoke(begin,
+                                                                  end,
+                                                                  output);
+}
+#endif
+
+bool StringToInt64(const std::string& input, int64* output) {
+  return IteratorRangeToNumber<IteratorRangeToInt64Traits>::Invoke(
+    input.begin(), input.end(), output);
+}
+
+bool StringToInt64(std::string::const_iterator begin,
+                 std::string::const_iterator end,
+                 int64* output) {
+  return IteratorRangeToNumber<IteratorRangeToInt64Traits>::Invoke(begin,
+                                                                 end,
+                                                                 output);
+}
+
+#if !defined(STD_STRING_ITERATOR_IS_CHAR_POINTER)
+bool StringToInt64(const char* begin, const char* end, int64* output) {
+  return IteratorRangeToNumber<CharBufferToInt64Traits>::Invoke(begin,
+                                                              end,
+                                                              output);
+}
+#endif
+
+bool StringToInt64(const string16& input, int64* output) {
+  return IteratorRangeToNumber<WideIteratorRangeToInt64Traits>::Invoke(
+    input.begin(), input.end(), output);
+}
+
+bool StringToInt64(string16::const_iterator begin,
+                 string16::const_iterator end,
+                 int64* output) {
+  return IteratorRangeToNumber<WideIteratorRangeToInt64Traits>::Invoke(begin,
+                                                                     end,
+                                                                     output);
+}
+
+#if !defined(BASE_STRING16_ITERATOR_IS_CHAR16_POINTER)
+bool StringToInt64(const char16* begin, const char16* end, int64* output) {
+  return IteratorRangeToNumber<WideCharBufferToInt64Traits>::Invoke(begin,
+                                                                  end,
+                                                                  output);
+}
+#endif
+
 bool StringToDouble(const std::string& input, double* output) {
   errno = 0;  // Thread-safe?  It is on at least Mac, Linux, and Windows.
   char* endptr = NULL;
   *output = dmg_fp::strtod(input.c_str(), &endptr);
 
   // Cases to return false:
   //  - If errno is ERANGE, there was an overflow or underflow.
   //  - If the input string is empty, there was nothing to parse.
   //  - If endptr does not point to the end of the string, there are either
   //    characters remaining in the string after a parsed number, or the string
@@ skipping 22 matching lines @@
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }
 
-bool HexStringToInt(const StringPiece& input, int* output) {
+bool HexStringToInt(const std::string& input, int* output) {
   return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(
     input.begin(), input.end(), output);
 }
 
+bool HexStringToInt(std::string::const_iterator begin,
+                    std::string::const_iterator end,
+                    int* output) {
+  return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(begin,
+                                                                    end,
+                                                                    output);
+}
+
+#if !defined(STD_STRING_ITERATOR_IS_CHAR_POINTER)
+bool HexStringToInt(const char* begin, const char* end, int* output) {
+  return IteratorRangeToNumber<HexCharBufferToIntTraits>::Invoke(begin,
+                                                                    end,
+                                                                    output);
+}
+#endif
+
 bool HexStringToBytes(const std::string& input, std::vector<uint8>* output) {
   return HexStringToBytesT(input, output);
 }
 
 }  // namespace base