com.groupbyinc.common.jackson.databind.util.ObjectBuffer Maven / Gradle / Ivy
package com.fasterxml.jackson.databind.util;
import java.lang.reflect.Array;
import java.util.List;
/**
* Helper class to use for constructing Object arrays by appending entries
* to create arrays of various lengths (length that is not known a priori).
*/
public final class ObjectBuffer
{
// // // Config constants
/**
* Also: let's expand by doubling up until 64k chunks (which is 16k entries for
* 32-bit machines)
*/
private final static int SMALL_CHUNK = (1 << 14);
/**
* Let's limit maximum size of chunks we use; helps avoid excessive allocation
* overhead for huge data sets.
* For now, let's limit to quarter million entries, 1 meg chunks for 32-bit
* machines.
*/
private final static int MAX_CHUNK = (1 << 18);
// // // Data storage
private LinkedNode _head;
private LinkedNode _tail;
/**
* Number of total buffered entries in this buffer, counting all instances
* within linked list formed by following {@link #_head}.
*/
private int _size;
// // // Simple reuse
/**
* Reusable Object array, stored here after buffer has been released having
* been used previously.
*/
private Object[] _freeBuffer;
/*
/**********************************************************
/* Construction
/**********************************************************
*/
public ObjectBuffer() { }
/*
/**********************************************************
/* Public API
/**********************************************************
*/
/**
* Method called to start buffering process. Will ensure that the buffer
* is empty, and then return an object array to start chunking content on
*/
public Object[] resetAndStart()
{
_reset();
if (_freeBuffer == null) {
return (_freeBuffer = new Object[12]);
}
return _freeBuffer;
}
/**
* @since 2.9
*/
public Object[] resetAndStart(Object[] base, int count)
{
_reset();
if ((_freeBuffer == null) || (_freeBuffer.length < count)) {
_freeBuffer = new Object[Math.max(12, count)];
}
System.arraycopy(base, 0, _freeBuffer, 0, count);
return _freeBuffer;
}
/**
* Method called to add a full Object array as a chunk buffered within
* this buffer, and to obtain a new array to fill. Caller is not to use
* the array it gives; but to use the returned array for continued
* buffering.
*
* @param fullChunk Completed chunk that the caller is requesting
* to append to this buffer. It is generally chunk that was
* returned by an earlier call to {@link #resetAndStart} or
* {@link #appendCompletedChunk} (although this is not required or
* enforced)
*
* @return New chunk buffer for caller to fill
*/
public Object[] appendCompletedChunk(Object[] fullChunk)
{
LinkedNode next = new LinkedNode(fullChunk, null);
if (_head == null) { // first chunk
_head = _tail = next;
} else { // have something already
_tail.linkNext(next);
_tail = next;
}
int len = fullChunk.length;
_size += len;
// double the size for small chunks
if (len < SMALL_CHUNK) {
len += len;
} else if (len < MAX_CHUNK) { // but by +25% for larger (to limit overhead)
len += (len >> 2);
}
return new Object[len];
}
/**
* Method called to indicate that the buffering process is now
* complete; and to construct a combined exactly-sized result
* array. Additionally the buffer itself will be reset to
* reduce memory retention.
*
* Resulting array will be of generic Object[] type:
* if a typed array is needed, use the method with additional
* type argument.
*/
public Object[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries)
{
int totalSize = lastChunkEntries + _size;
Object[] result = new Object[totalSize];
_copyTo(result, totalSize, lastChunk, lastChunkEntries);
_reset();
return result;
}
/**
* Type-safe alternative to
* {@link #completeAndClearBuffer(Object[], int)}, to allow
* for constructing explicitly typed result array.
*
* @param componentType Type of elements included in the buffer. Will be
* used for constructing the result array.
*/
public T[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, Class componentType)
{
int totalSize = lastChunkEntries + _size;
@SuppressWarnings("unchecked")
T[] result = (T[]) Array.newInstance(componentType, totalSize);
_copyTo(result, totalSize, lastChunk, lastChunkEntries);
_reset();
return result;
}
public void completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, List