Upstream android string implementation etc.

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 <errno.h>
 #include <stdlib.h>
 #include <wctype.h>
 
@@ skipping 385 matching lines @@
 }
 
 bool StringToInt(std::string::const_iterator begin,
                  std::string::const_iterator end,
                  int* output) {
   return IteratorRangeToNumber<IteratorRangeToIntTraits>::Invoke(begin,
                                                                  end,
                                                                  output);
 }
 
+#if !defined(OS_ANDROID)

[darin (slow to review), 2011/06/24 16:46:05]

i think it would be better to declare a #define like
STD_STRING_ITERATOR_IS_CHAR_POINTER.  that way you do not need to duplicate the
comment everywhere.

this reminds me of how wchar_t == char16 when compiling under MSVC.  so we have
the WCHAR_T_IS_UTF16 #define, which we use to avoid a similar warning on MSVC. 
on other platforms, wchar_t is 32-bits.

STD_STRING_ITERATOR_IS_CHAR_POINTER would probably get added to
build/build_config.h.

[michaelbai, 2011/06/24 18:51:30]

Thanks, Done.

+// In Android platform, the compiler thinks std::string::const_iterator and
+// "const char*" are equivalent types.
 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 StringToInt(string16::const_iterator begin,
                  string16::const_iterator end,
                  int* output) {
   return IteratorRangeToNumber<WideIteratorRangeToIntTraits>::Invoke(begin,
                                                                      end,
                                                                      output);
 }
 
+#if !defined(OS_ANDROID)
+// In Android platform, the compiler thinks base::string16::const_iterator and
+// "char16*" are equivalent types.
 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(OS_ANDROID)
+// In Android platform, the compiler thinks std::string::const_iterator and
+// "char*" are equivalent types.
 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(OS_ANDROID)
+// In Android platform, the compiler thinks base::string16::const_iterator and
+// "char16*" are equivalent types.
 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
@@ skipping 36 matching lines @@
 }
 
 bool HexStringToInt(std::string::const_iterator begin,
                     std::string::const_iterator end,
                     int* output) {
   return IteratorRangeToNumber<HexIteratorRangeToIntTraits>::Invoke(begin,
                                                                     end,
                                                                     output);
 }
 
+#if !defined(OS_ANDROID)
+// In Android platform, the compiler thinks std::string::const_iterator and
+// "char*" are equivalent types.
 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