Merge branch '2.14'

Author: cowtowncoder

release-notes/VERSION-2.x

@@ -16,6 +16,9 @@ JSON library.
 
 2.14.0 (not yet released)
 
+#478: Provide implementation of async JSON parser fed by `ByteBufferFeeder`
+ (requested by Arjen P)
+ (contributed by @pjfanning)
 #577: Improve performance of floating-point number parsing
  (contributed by @pjfanning)
 #684: Add "JsonPointer#appendProperty" and "JsonPointer#appendIndex"

src/main/java/tools/jackson/core/TokenStreamFactory.java

@@ -1035,7 +1035,11 @@ public abstract JsonParser createParser(ObjectReadContext readCtxt,
      *<p>
      * If this factory does not support non-blocking parsing (either at all,
      * or from byte array),
-     * will throw {@link UnsupportedOperationException}
+     * will throw {@link UnsupportedOperationException}.
+     *<p>
+     * Note that JSON-backed factory only supports parsing of UTF-8 encoded JSON content
+     * (and US-ASCII since it is proper subset); other encodings are not supported
+     * at this point.
      *
      * @param <P> Nominal type of parser constructed and returned
      * @param readCtxt Object read context to use
@@ -1044,10 +1048,37 @@ public abstract JsonParser createParser(ObjectReadContext readCtxt,
      *
      * @throws JacksonException If parser construction or initialization fails
      */
-    public <P extends JsonParser & ByteArrayFeeder> P createNonBlockingByteArrayParser(ObjectReadContext readCtxt) throws JacksonException {
+    public <P extends JsonParser & ByteArrayFeeder> P createNonBlockingByteArrayParser(ObjectReadContext readCtxt)
+            throws JacksonException {
         return _unsupported("Non-blocking source not (yet?) support for this format ("+getFormatName()+")");        
     }
 
+    /**
+     * Optional method for constructing parser for non-blocking parsing
+     * via {@link tools.jackson.core.async.ByteBufferFeeder}
+     * interface (accessed using {@link JsonParser#nonBlockingInputFeeder()}
+     * from constructed instance).
+     *<p>
+     * If this factory does not support non-blocking parsing (either at all,
+     * or from byte array),
+     * will throw {@link UnsupportedOperationException}.
+     *<p>
+     * Note that JSON-backed factory only supports parsing of UTF-8 encoded JSON content
+     * (and US-ASCII since it is proper subset); other encodings are not supported
+     * at this point.
+     *
+     * @param <P> Nominal type of parser constructed and returned
+     * @param readCtxt Object read context to use
+     *
+     * @return Non-blocking parser constructed
+     *
+     * @throws JacksonException If parser construction or initialization fails
+     */
+    public  <P extends JsonParser & ByteArrayFeeder> P createNonBlockingByteBufferParser(ObjectReadContext readCtxt)
+        throws JacksonException {
+        return _unsupported("Non-blocking source not (yet?) support for this format ("+getFormatName()+")");
+    }
+
     /*
     /**********************************************************************
     /* Generator factories with databind context (3.0)

src/main/java/tools/jackson/core/json/JsonFactory.java

@@ -12,6 +12,7 @@
 import tools.jackson.core.base.TextualTSFactory;
 import tools.jackson.core.io.*;
 import tools.jackson.core.json.async.NonBlockingJsonParser;
+import tools.jackson.core.json.async.NonBlockingByteBufferJsonParser;
 import tools.jackson.core.sym.BinaryNameMatcher;
 import tools.jackson.core.sym.ByteQuadsCanonicalizer;
 import tools.jackson.core.sym.CharsToNameCanonicalizer;
@@ -328,7 +329,6 @@ public String getRootValueSeparator() {
 
     @Override
     public JsonParser createNonBlockingByteArrayParser(ObjectReadContext readCtxt)
-            throws JacksonException
     {
         IOContext ioCtxt = _createNonBlockingContext(null);
         ByteQuadsCanonicalizer can = _byteSymbolCanonicalizer.makeChild(_factoryFeatures);
@@ -338,10 +338,21 @@ public JsonParser createNonBlockingByteArrayParser(ObjectReadContext readCtxt)
                 can);
     }
 
+    @Override
+    public JsonParser createNonBlockingByteBufferParser(ObjectReadContext readCtxt)
+    {
+        IOContext ioCtxt = _createNonBlockingContext(null);
+        ByteQuadsCanonicalizer can = _byteSymbolCanonicalizer.makeChild(_factoryFeatures);
+        return new NonBlockingByteBufferJsonParser(readCtxt, ioCtxt,
+                readCtxt.getStreamReadFeatures(_streamReadFeatures),
+                readCtxt.getFormatReadFeatures(_formatReadFeatures),
+                can);
+    }
+
     protected IOContext _createNonBlockingContext(Object srcRef) {
         return new IOContext(_getBufferRecycler(),
                 ContentReference.rawReference(srcRef), false);
-    }    
+    }
 
     /*
     /**********************************************************************

src/main/java/tools/jackson/core/json/async/NonBlockingByteBufferJsonParser.java

@@ -0,0 +1,98 @@
+package tools.jackson.core.json.async;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.core.ObjectReadContext;
+import tools.jackson.core.async.ByteBufferFeeder;
+import tools.jackson.core.async.NonBlockingInputFeeder;
+import tools.jackson.core.io.IOContext;
+import tools.jackson.core.sym.ByteQuadsCanonicalizer;
+
+/**
+ * Non-blocking parser implementation for JSON content that takes its input
+ * via {@link java.nio.ByteBuffer} instance(s) passed.
+ *<p>
+ * NOTE: only supports parsing of UTF-8 encoded content (and 7-bit US-ASCII since
+ * it is strict subset of UTF-8): other encodings are not supported.
+ */
+public class NonBlockingByteBufferJsonParser
+        extends NonBlockingUtf8JsonParserBase
+        implements ByteBufferFeeder
+{
+    private ByteBuffer _inputBuffer = ByteBuffer.wrap(NO_BYTES);
+
+    public NonBlockingByteBufferJsonParser(ObjectReadContext readCtxt, IOContext ctxt,
+            int stdFeatures, int formatReadFeatures, ByteQuadsCanonicalizer sym) {
+        super(readCtxt, ctxt, stdFeatures, formatReadFeatures, sym);
+    }
+
+    @Override
+    public NonBlockingInputFeeder nonBlockingInputFeeder() {
+        return this;
+    }
+
+    @Override
+    public void feedInput(final ByteBuffer byteBuffer) throws JacksonException {
+        // Must not have remaining input
+        if (_inputPtr < _inputEnd) {
+            _reportError("Still have %d undecoded bytes, should not call 'feedInput'", _inputEnd - _inputPtr);
+        }
+
+        final int start = byteBuffer.position();
+        final int end = byteBuffer.limit();
+
+        if (end < start) {
+            _reportError("Input end (%d) may not be before start (%d)", end, start);
+        }
+        // and shouldn't have been marked as end-of-input
+        if (_endOfInput) {
+            _reportError("Already closed, can not feed more input");
+        }
+        // Time to update pointers first
+        _currInputProcessed += _origBufferLen;
+
+        // Also need to adjust row start, to work as if it extended into the past wrt new buffer
+        _currInputRowStart = start - (_inputEnd - _currInputRowStart);
+
+        // And then update buffer settings
+        _currBufferStart = start;
+        _inputBuffer = byteBuffer;
+        _inputPtr = start;
+        _inputEnd = end;
+        _origBufferLen = end - start;
+    }
+
+    @Override
+    public int releaseBuffered(final OutputStream out) throws JacksonException {
+        final int avail = _inputEnd - _inputPtr;
+        if (avail > 0) {
+            final WritableByteChannel channel = Channels.newChannel(out);
+            try {
+                channel.write(_inputBuffer);
+            } catch (IOException e) {
+                throw _wrapIOFailure(e);
+            }
+        }
+        return avail;
+    }
+
+    @Override
+    protected byte getNextSignedByteFromBuffer() {
+        return _inputBuffer.get(_inputPtr++);
+    }
+
+    @Override
+    protected int getNextUnsignedByteFromBuffer() {
+        return _inputBuffer.get(_inputPtr++) & 0xFF;
+    }
+
+    @Override
+    protected byte getByteFromBuffer(final int ptr) {
+        return _inputBuffer.get(ptr);
+    }
+}