Minor addition to TextBuffer for 2.3.2

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/core/util/TextBuffer.java

@@ -118,8 +118,7 @@ public final class TextBuffer
     /**********************************************************
      */
 
-    public TextBuffer(BufferRecycler allocator)
-    {
+    public TextBuffer(BufferRecycler allocator) {
         _allocator = allocator;
     }
 
@@ -204,7 +203,7 @@ public void resetWithCopy(char[] buf, int start, int len)
         if (_hasSegments) {
             clearSegments();
         } else if (_currentSegment == null) {
-            _currentSegment = findBuffer(len);
+            _currentSegment = buf(len);
         }
         _currentSize = _segmentSize = 0;
         append(buf, start, len);
@@ -230,7 +229,7 @@ public void resetWithString(String value)
      * Helper method used to find a buffer to use, ideally one
      * recycled earlier.
      */
-    private char[] findBuffer(int needed)
+    private char[] buf(int needed)
     {
         if (_allocator != null) {
             return _allocator.allocCharBuffer(BufferRecycler.CharBufferType.TEXT_BUFFER, needed);
@@ -275,8 +274,7 @@ public int size() {
         return _segmentSize + _currentSize;
     }
 
-    public int getTextOffset()
-    {
+    public int getTextOffset() {
         /* Only shared input buffer can have non-zero offset; buffer
          * segments start at 0, and if we have to create a combo buffer,
          * that too will start from beginning of the buffer
@@ -291,32 +289,22 @@ public int getTextOffset()
     public boolean hasTextAsCharacters()
     {
         // if we have array in some form, sure
-        if (_inputStart >= 0 || _resultArray != null) {
-            return true;
-        }
+        if (_inputStart >= 0 || _resultArray != null)  return true;
         // not if we have String as value
-        if (_resultString != null) {
-            return false;
-        }
+        if (_resultString != null) return false;
         return true;
     }
 
     public char[] getTextBuffer()
     {
         // Are we just using shared input buffer?
-        if (_inputStart >= 0) {
-            return _inputBuffer;
-        }
-        if (_resultArray != null) {
-            return _resultArray;
-        }
+        if (_inputStart >= 0) return _inputBuffer;
+        if (_resultArray != null)  return _resultArray;
         if (_resultString != null) {
             return (_resultArray = _resultString.toCharArray());
         }
         // Nope; but does it fit in just one segment?
-        if (!_hasSegments) {
-            return _currentSegment;
-        }
+        if (!_hasSegments)  return _currentSegment;
         // Nope, need to have/create a non-segmented array and return it
         return contentsAsArray();
     }
@@ -366,11 +354,10 @@ public String contentsAsString()
         return _resultString;
     }
 
-    public char[] contentsAsArray()
-    {
+    public char[] contentsAsArray() {
         char[] result = _resultArray;
         if (result == null) {
-            _resultArray = result = buildResultArray();
+            _resultArray = result = resultArray();
         }
         return result;
     }
@@ -379,8 +366,7 @@ public char[] contentsAsArray()
      * Convenience method for converting contents of the buffer
      * into a {@link BigDecimal}.
      */
-    public BigDecimal contentsAsDecimal()
-        throws NumberFormatException
+    public BigDecimal contentsAsDecimal() throws NumberFormatException
     {
         // Already got a pre-cut array?
         if (_resultArray != null) {
@@ -402,9 +388,7 @@ public BigDecimal contentsAsDecimal()
      * Convenience method for converting contents of the buffer
      * into a Double value.
      */
-    public double contentsAsDouble()
-        throws NumberFormatException
-    {
+    public double contentsAsDouble() throws NumberFormatException {
         return NumberInput.parseDouble(contentsAsString());
     }
 
@@ -532,7 +516,7 @@ public char[] getCurrentSegment()
         } else {
             char[] curr = _currentSegment;
             if (curr == null) {
-                _currentSegment = findBuffer(0);
+                _currentSegment = buf(0);
             } else if (_currentSize >= curr.length) {
                 // Plus, we better have room for at least one more char
                 expand(1);
@@ -558,21 +542,15 @@ public char[] emptyAndGetCurrentSegment()
         }
         char[] curr = _currentSegment;
         if (curr == null) {
-            _currentSegment = curr = findBuffer(0);
+            _currentSegment = curr = buf(0);
         }
         return curr;
     }
 
-    public int getCurrentSegmentSize() {
-        return _currentSize;
-    }
+    public int getCurrentSegmentSize() { return _currentSize; }
+    public void setCurrentLength(int len) { _currentSize = len; }
 
-    public void setCurrentLength(int len) {
-        _currentSize = len;
-    }
-
-    public char[] finishCurrentSegment()
-    {
+    public char[] finishCurrentSegment() {
         if (_segments == null) {
             _segments = new ArrayList<char[]>();
         }
@@ -582,7 +560,7 @@ public char[] finishCurrentSegment()
         _segmentSize += oldLen;
         // Let's grow segments by 50%
         int newLen = Math.min(oldLen + (oldLen >> 1), MAX_SEGMENT_LEN);
-        char[] curr = _charArray(newLen);
+        char[] curr = carr(newLen);
         _currentSize = 0;
         _currentSegment = curr;
         return curr;
@@ -599,11 +577,26 @@ public char[] expandCurrentSegment()
         // Let's grow by 50%
         final int len = curr.length;
         // Must grow by at least 1 char, no matter what
-        int newLen = (len == MAX_SEGMENT_LEN) ?
-            (MAX_SEGMENT_LEN + 1) : Math.min(MAX_SEGMENT_LEN, len + (len >> 1));
+        int newLen = (len == MAX_SEGMENT_LEN) ? (MAX_SEGMENT_LEN+1) : Math.min(MAX_SEGMENT_LEN, len + (len >> 1));
         return (_currentSegment = Arrays.copyOf(curr, newLen));
     }
 
+    /**
+     * Method called to expand size of the current segment, to
+     * accommodate for more contiguous content. Usually only
+     * used when parsing tokens like names if even then.
+     * 
+     * @param minSize Required minimum strength of the current segment
+     *
+     * @since 2.4.0
+     */
+    public char[] expandCurrentSegment(int minSize) {
+        char[] curr = _currentSegment;
+        if (curr.length >= minSize) return curr;
+        _currentSegment = curr = Arrays.copyOf(curr, minSize);
+        return curr;
+    }
+
     /*
     /**********************************************************
     /* Standard methods:
@@ -615,10 +608,7 @@ public char[] expandCurrentSegment()
      * {@link #contentsAsString}, since it's not guaranteed that resulting
      * String is cached.
      */
-    @Override
-    public String toString() {
-         return contentsAsString();
-    }
+    @Override public String toString() { return contentsAsString(); }
 
     /*
     /**********************************************************
@@ -642,7 +632,7 @@ private void unshare(int needExtra)
         // Is buffer big enough, or do we need to reallocate?
         int needed = sharedLen+needExtra;
         if (_currentSegment == null || needed > _currentSegment.length) {
-            _currentSegment = findBuffer(needed);
+            _currentSegment = buf(needed);
         }
         if (sharedLen > 0) {
             System.arraycopy(inputBuf, start, _currentSegment, 0, sharedLen);
@@ -672,10 +662,10 @@ private void expand(int minNewSegmentSize)
             sizeAddition = minNewSegmentSize;
         }
         _currentSize = 0;
-        _currentSegment = _charArray(Math.min(MAX_SEGMENT_LEN, oldLen + sizeAddition));
+        _currentSegment = carr(Math.min(MAX_SEGMENT_LEN, oldLen + sizeAddition));
     }
 
-    private char[] buildResultArray()
+    private char[] resultArray()
     {
         if (_resultString != null) { // Can take a shortcut...
             return _resultString.toCharArray();
@@ -698,7 +688,7 @@ private char[] buildResultArray()
             return NO_CHARS;
         }
         int offset = 0;
-        final char[] result = _charArray(size);
+        final char[] result = carr(size);
         if (_segments != null) {
             for (int i = 0, len = _segments.size(); i < len; ++i) {
                 char[] curr = (char[]) _segments.get(i);
@@ -711,7 +701,5 @@ private char[] buildResultArray()
         return result;
     }
 
-    private char[] _charArray(int len) {
-        return new char[len];
-    }
+    private char[] carr(int len) { return new char[len]; }
 }