Add StringToDoubleConverter::StringTo<T> member function templates

Allowed users to write generic code more easily, like this (when `T` is
either `float` or `double`):

    converter.StringTo<T>(buffer, length, &processed);

Included a unit test, `TEST(StringToTemplate)`.

Fixes issue #157

With help from Florian Loitsch (floitsch)

Author: N-Dekker

double-conversion/string-to-double.cc

@@ -779,4 +779,40 @@ float StringToDoubleConverter::StringToFloat(
                                          processed_characters_count));
 }
 
+
+template<>
+double StringToDoubleConverter::StringTo<double>(
+    const char* buffer,
+    int length,
+    int* processed_characters_count) const {
+    return StringToDouble(buffer, length, processed_characters_count);
+}
+
+
+template<>
+float StringToDoubleConverter::StringTo<float>(
+    const char* buffer,
+    int length,
+    int* processed_characters_count) const {
+    return StringToFloat(buffer, length, processed_characters_count);
+}
+
+
+template<>
+double StringToDoubleConverter::StringTo<double>(
+    const uc16* buffer,
+    int length,
+    int* processed_characters_count) const {
+    return StringToDouble(buffer, length, processed_characters_count);
+}
+
+
+template<>
+float StringToDoubleConverter::StringTo<float>(
+    const uc16* buffer,
+    int length,
+    int* processed_characters_count) const {
+    return StringToFloat(buffer, length, processed_characters_count);
+}
+
 }  // namespace double_conversion

double-conversion/string-to-double.h

@@ -204,6 +204,20 @@ class StringToDoubleConverter {
                       int length,
                       int* processed_characters_count) const;
 
+  // Same as StringToDouble for T = double, and StringToFloat for T = float.
+  template <typename T>
+  T StringTo(
+      const char* buffer,
+      int length,
+      int* processed_characters_count) const;
+
+  // Same as StringTo above but for 16 bit characters.
+  template <typename T>
+  T StringTo(
+      const uc16* buffer,
+      int length,
+      int* processed_characters_count) const;
+
  private:
   const int flags_;
   const double empty_string_value_;

test/cctest/test-conversions.cc

@@ -5889,3 +5889,86 @@ TEST(StringToDoubleCaseInsensitiveSpecialValues) {
   CHECK_EQ(1.0, converter.StringToDouble("+inf", 4, &processed));
   CHECK_EQ(0, processed);
 }
+
+
+TEST(StringToTemplate) {
+    const StringToDoubleConverter converter(StringToDoubleConverter::ALLOW_HEX, 0.0, Double::NaN(), "inf", "nan");
+    {
+        int processed = 0;
+        CHECK_EQ(converter.StringTo<double>("1", 1, &processed), 1.0);
+        CHECK_EQ(processed, 1);
+
+        processed = 0;
+        CHECK_EQ(converter.StringTo<float>("1", 1, &processed), 1.0f);
+        CHECK_EQ(processed, 1);
+
+        const uc16 buffer16[1] = { static_cast<uc16>('1') };
+
+        processed = 0;
+        CHECK_EQ(converter.StringTo<double>(buffer16, 1, &processed), 1.0);
+        CHECK_EQ(processed, 1);
+
+        processed = 0;
+        CHECK_EQ(converter.StringTo<float>(buffer16, 1, &processed), 1.0f);
+        CHECK_EQ(processed, 1);
+    }
+    {
+        // A number that can be represented by a double, but not by a float.
+        // Allows testing that StringTo<double> behaves like StringToDouble
+        // (and not like StringToFloat).
+        const char buffer[] = "1e+100";
+        const int length = DOUBLE_CONVERSION_ARRAY_SIZE(buffer) - 1;
+
+        int processed1 = 1;
+        int processed2 = 2;
+
+        CHECK_EQ(
+            converter.StringToDouble(buffer, length, &processed1),
+            converter.StringTo<double>(buffer, length, &processed2));
+        CHECK_EQ(processed1, processed2);
+
+        uc16 buffer16[DOUBLE_CONVERSION_ARRAY_SIZE(buffer)];
+
+        for (int i = 0; i <= length; ++i) {
+            buffer16[i] = buffer[i];
+        }
+
+        processed1 = 1;
+        processed2 = 2;
+
+        CHECK_EQ(
+            converter.StringToDouble(buffer16, length, &processed1),
+            converter.StringTo<double>(buffer16, length, &processed2));
+        CHECK_EQ(processed1, processed2);
+    }
+    {
+        // The double rounding example from TEST(StringToFloatHexString), which
+        // yields a slightly different result from StringToFloat than from
+        // StringToDouble. Allows testing that StringTo<float> behaves like
+        // StringToFloat (rather than like StringToDouble). 
+        const char buffer[] = "0x100000100000008";
+        const int length = DOUBLE_CONVERSION_ARRAY_SIZE(buffer) - 1;
+
+        int processed1 = 1;
+        int processed2 = 2;
+
+        CHECK_EQ(
+            converter.StringToFloat(buffer, length, &processed1),
+            converter.StringTo<float>(buffer, length, &processed2));
+        CHECK_EQ(processed1, processed2);
+
+        uc16 buffer16[DOUBLE_CONVERSION_ARRAY_SIZE(buffer)];
+
+        for (int i = 0; i <= length; ++i) {
+            buffer16[i] = buffer[i];
+        }
+
+        processed1 = 1;
+        processed2 = 2;
+
+        CHECK_EQ(
+            converter.StringToFloat(buffer16, length, &processed1),
+            converter.StringTo<float>(buffer16, length, &processed2));
+        CHECK_EQ(processed1, processed2);
+    }
+}