Support use of fast double parser

src/main/java/com/fasterxml/jackson/databind/deser/std/NumberDeserializers.java

@@ -645,7 +645,7 @@ protected final Float _parseFloat(JsonParser p, DeserializationContext ctxt)
                 return (Float) getNullValue(ctxt);
             }
             try {
-                return NumberInput.parseFloat(text);
+                return NumberInput.parseFloat(text, p.isEnabled(JsonParser.Feature.USE_FAST_DOUBLE_PARSER));
             } catch (IllegalArgumentException iae) { }
             return (Float) ctxt.handleWeirdStringValue(_valueClass, text,
                     "not a valid `Float` value");
@@ -736,7 +736,7 @@ protected final Double _parseDouble(JsonParser p, DeserializationContext ctxt) t
                 return (Double) getNullValue(ctxt);
             }
             try {
-                return _parseDouble(text);
+                return _parseDouble(text, p.isEnabled(JsonParser.Feature.USE_FAST_DOUBLE_PARSER));
             } catch (IllegalArgumentException iae) { }
             return (Double) ctxt.handleWeirdStringValue(_valueClass, text,
                     "not a valid `Double` value");

src/main/java/com/fasterxml/jackson/databind/deser/std/StdDeserializer.java

@@ -1157,10 +1157,24 @@ protected final double _parseDoublePrimitive(DeserializationContext ctxt, String
     /**
      * Helper method for encapsulating calls to low-level double value parsing; single place
      * just because we need a work-around that must be applied to all calls.
+     * Does not use the new <code>useFastParser</code> support.
+     *
+     * @see #_parseDouble(String, boolean)
+     */
+    protected final static double _parseDouble(final String numStr) throws NumberFormatException
+    {
+        return _parseDouble(numStr, false);
+    }
+
+    /**
+     * Helper method for encapsulating calls to low-level double value parsing; single place
+     * just because we need a work-around that must be applied to all calls.
+     *
+     * @since 2.14
      */
-    protected final static double _parseDouble(String numStr) throws NumberFormatException
+    protected final static double _parseDouble(final String numStr, final boolean useFastParser) throws NumberFormatException
     {
-        return NumberInput.parseDouble(numStr);
+        return NumberInput.parseDouble(numStr, useFastParser);
     }
 
     /**

src/test/java/com/fasterxml/jackson/databind/seq/ReadValuesTest.java

@@ -10,6 +10,7 @@
 import com.fasterxml.jackson.databind.MappingIterator;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectReader;
+import com.fasterxml.jackson.databind.json.JsonMapper;
 
 @SuppressWarnings("resource")
 public class ReadValuesTest extends BaseMapTest
@@ -307,7 +308,27 @@ public void testNonRootMapsWithObjectReader() throws Exception
         assertEquals(2, map.size());
         assertFalse(iterator.hasNext());
     }
-
+
+    public void testObjectReaderWithJsonParserFastDoubleParser() throws Exception
+    {
+        testObjectReaderWithFastDoubleParser(true);
+    }
+
+    public void testObjectReaderWithJsonReadFeatureFastDoubleParser() throws Exception
+    {
+        testObjectReaderWithFastDoubleParser(false);
+    }
+
+    public void testObjectReaderWithJsonParserFastFloatParser() throws Exception
+    {
+        testObjectReaderWithFastFloatParser(true);
+    }
+
+    public void testObjectReaderWithJsonReadFeatureFastFloatParser() throws Exception
+    {
+        testObjectReaderWithFastFloatParser(false);
+    }
+
     public void testNonRootArraysUsingParser() throws Exception
     {
         final String JSON = "[[1],[3]]";
@@ -342,4 +363,59 @@ public void testEmptyIterator() throws Exception
 
         empty.close();
     }
+
+    private void testObjectReaderWithFastDoubleParser(final boolean useParserFeature) throws Exception
+    {
+        final String JSON = "[{ \"val1\": 1.23456, \"val2\": 5 }, { \"val1\": 3.14, \"val2\": -6.5 }]";
+        final ObjectMapper mapper;
+        if (useParserFeature) {
+            JsonFactory factory = new JsonFactory();
+            factory.enable(JsonParser.Feature.USE_FAST_DOUBLE_PARSER);
+            mapper = JsonMapper.builder(factory).build();
+        } else {
+            mapper = JsonMapper.builder().enable(StreamReadFeature.USE_FAST_DOUBLE_PARSER).build();
+        }
+
+        final MappingIterator<Map<String, Double>> iterator = mapper.reader().forType(new TypeReference<Map<String, Double>>(){}).readValues(JSON);
+
+        Map<String, Double> map;
+        assertTrue(iterator.hasNext());
+        map = iterator.nextValue();
+        assertEquals(2, map.size());
+        assertEquals(Double.valueOf(1.23456), map.get("val1"));
+        assertEquals(Double.valueOf(5), map.get("val2"));
+        assertTrue(iterator.hasNext());
+        map = iterator.nextValue();
+        assertEquals(Double.valueOf(3.14), map.get("val1"));
+        assertEquals(Double.valueOf(-6.5), map.get("val2"));
+        assertEquals(2, map.size());
+        assertFalse(iterator.hasNext());
+    }
+
+    private void testObjectReaderWithFastFloatParser(final boolean useParserFeature) throws Exception
+    {
+        final String JSON = "[{ \"val1\": 1.23456, \"val2\": 5 }, { \"val1\": 3.14, \"val2\": -6.5 }]";
+        final ObjectMapper mapper;
+        if (useParserFeature) {
+            JsonFactory factory = new JsonFactory();
+            factory.enable(JsonParser.Feature.USE_FAST_DOUBLE_PARSER);
+            mapper = JsonMapper.builder(factory).build();
+        } else {
+            mapper = JsonMapper.builder().enable(StreamReadFeature.USE_FAST_DOUBLE_PARSER).build();
+        }
+        final MappingIterator<Map<String, Float>> iterator = mapper.reader().forType(new TypeReference<Map<String, Float>>(){}).readValues(JSON);
+
+        Map<String, Float> map;
+        assertTrue(iterator.hasNext());
+        map = iterator.nextValue();
+        assertEquals(2, map.size());
+        assertEquals(Float.valueOf(1.23456f), map.get("val1"));
+        assertEquals(Float.valueOf(5), map.get("val2"));
+        assertTrue(iterator.hasNext());
+        map = iterator.nextValue();
+        assertEquals(Float.valueOf(3.14f), map.get("val1"));
+        assertEquals(Float.valueOf(-6.5f), map.get("val2"));
+        assertEquals(2, map.size());
+        assertFalse(iterator.hasNext());
+    }
 }