Add 2 more alloc methods for IOContext

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/core/io/IOContext.java

@@ -9,8 +9,10 @@
  * contextual objects that need to be passed by the factory to
  * readers and writers are combined under this object. One instance
  * is created for each reader and writer.
+ *<p>
+ * NOTE: non-final since 2.4, to allow sub-classing.
  */
-public final class IOContext
+public class IOContext
 {
     /*
     /**********************************************************
@@ -132,41 +134,51 @@ public TextBuffer constructTextBuffer() {
      * Note: the method can only be called once during its life cycle.
      * This is to protect against accidental sharing.
      */
-    public byte[] allocReadIOBuffer()
-    {
+    public byte[] allocReadIOBuffer() {
         _verifyAlloc(_readIOBuffer);
         return (_readIOBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER));
     }
 
-    public byte[] allocWriteEncodingBuffer()
-    {
+    /**
+     * @since 2.3.2
+     */
+    public byte[] allocReadIOBuffer(int minSize) {
+        _verifyAlloc(_readIOBuffer);
+        return (_readIOBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER, minSize));
+    }
+    
+    public byte[] allocWriteEncodingBuffer() {
         _verifyAlloc(_writeEncodingBuffer);
         return (_writeEncodingBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER));
     }
 
+    /**
+     * @since 2.3.2
+     */
+    public byte[] allocWriteEncodingBuffer(int minSize) {
+        _verifyAlloc(_writeEncodingBuffer);
+        return (_writeEncodingBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER, minSize));
+    }
+    
     /**
      * @since 2.1
      */
-    public byte[] allocBase64Buffer()
-    {
+    public byte[] allocBase64Buffer() {
         _verifyAlloc(_base64Buffer);
         return (_base64Buffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.BASE64_CODEC_BUFFER));
     }
 
-    public char[] allocTokenBuffer()
-    {
+    public char[] allocTokenBuffer() {
         _verifyAlloc(_tokenCBuffer);
         return (_tokenCBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER));
     }
 
-    public char[] allocConcatBuffer()
-    {
+    public char[] allocConcatBuffer() {
         _verifyAlloc(_concatCBuffer);
         return (_concatCBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER));
     }
 
-    public char[] allocNameCopyBuffer(int minSize)
-    {
+    public char[] allocNameCopyBuffer(int minSize) {
         _verifyAlloc(_nameCopyBuffer);
         return (_nameCopyBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, minSize));
     }
@@ -175,8 +187,7 @@ public char[] allocNameCopyBuffer(int minSize)
      * Method to call when all the processing buffers can be safely
      * recycled.
      */
-    public void releaseReadIOBuffer(byte[] buf)
-    {
+    public void releaseReadIOBuffer(byte[] buf) {
         if (buf != null) {
             /* Let's do sanity checks to ensure once-and-only-once release,
              * as well as avoiding trying to release buffers not owned
@@ -187,8 +198,7 @@ public void releaseReadIOBuffer(byte[] buf)
         }
     }
 
-    public void releaseWriteEncodingBuffer(byte[] buf)
-    {
+    public void releaseWriteEncodingBuffer(byte[] buf) {
         if (buf != null) {
             /* Let's do sanity checks to ensure once-and-only-once release,
              * as well as avoiding trying to release buffers not owned
@@ -199,36 +209,34 @@ public void releaseWriteEncodingBuffer(byte[] buf)
         }
     }
 
-    public void releaseBase64Buffer(byte[] buf)
-    {
+    public void releaseBase64Buffer(byte[] buf) {
         if (buf != null) { // sanity checks, release once-and-only-once, must be one owned
             _verifyRelease(buf, _base64Buffer);
             _base64Buffer = null;
             _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.BASE64_CODEC_BUFFER, buf);
         }
     }
 
-    public void releaseTokenBuffer(char[] buf)
-    {
+    public void releaseTokenBuffer(char[] buf) {
         if (buf != null) {
             _verifyRelease(buf, _tokenCBuffer);
             _tokenCBuffer = null;
             _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER, buf);
         }
     }
 
-    public void releaseConcatBuffer(char[] buf)
-    {
+    public void releaseConcatBuffer(char[] buf) {
         if (buf != null) {
+            // 14-Jan-2014, tatu: Let's actually allow upgrade of the original buffer.
             _verifyRelease(buf, _concatCBuffer);
             _concatCBuffer = null;
             _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER, buf);
         }
     }
 
-    public void releaseNameCopyBuffer(char[] buf)
-    {
+    public void releaseNameCopyBuffer(char[] buf) {
         if (buf != null) {
+            // 14-Jan-2014, tatu: Let's actually allow upgrade of the original buffer.
             _verifyRelease(buf, _nameCopyBuffer);
             _nameCopyBuffer = null;
             _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, buf);
@@ -241,17 +249,17 @@ public void releaseNameCopyBuffer(char[] buf)
     /**********************************************************
      */
 
-    private final void _verifyAlloc(Object buffer)
-    {
-        if (buffer != null) {
-            throw new IllegalStateException("Trying to call same allocXxx() method second time");
-        }
+    protected void _verifyAlloc(Object buffer) {
+        if (buffer != null) { throw new IllegalStateException("Trying to call same allocXxx() method second time"); }
     }
-    
-    private final void _verifyRelease(Object toRelease, Object src)
-    {
-        if (toRelease != src) {
-            throw new IllegalArgumentException("Trying to release buffer not owned by the context");
-        }
+
+    protected void _verifyRelease(byte[] toRelease, byte[] src) {
+        if ((toRelease != src) && (toRelease.length <= src.length)) { throw wrongBuf(); }
     }
+
+    protected void _verifyRelease(char[] toRelease, char[] src) {
+        if ((toRelease != src) && (toRelease.length <= src.length)) { throw wrongBuf(); }
+    }
+
+    private IllegalArgumentException wrongBuf() { return new IllegalArgumentException("Trying to release buffer not owned by the context"); }
 }