/** * Method used by factory to create buffer recycler instances * for parsers and generators. *<p> * Note: only public to give access for <code>ObjectMapper</code> */ public BufferRecycler _getBufferRecycler() { SoftReference<BufferRecycler> ref = _recyclerRef.get(); BufferRecycler br = (ref == null) ? null : ref.get(); if (br == null) { br = new BufferRecycler(); _recyclerRef.set(new SoftReference<BufferRecycler>(br)); } return br; }
public ByteArrayBuilder(BufferRecycler br, int firstBlockSize) { _bufferRecycler = br; if (br == null) { _currBlock = new byte[firstBlockSize]; } else { _currBlock = br.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_CONCAT_BUFFER); } }
public final char[] allocCharBuffer(CharBufferType type) { return allocCharBuffer(type, 0); }
public final void releaseTokenBuffer(char[] buf) { if (buf != null) { if (buf != _tokenCBuffer) { throw new IllegalArgumentException("Trying to release buffer not owned by the context"); } _tokenCBuffer = null; _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER, buf); } }
public final 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 */ if (buf != _writeEncodingBuffer) { throw new IllegalArgumentException("Trying to release buffer not owned by the context"); } _writeEncodingBuffer = null; _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER, buf); } }
public final byte[] allocByteBuffer(ByteBufferType type) { int ix = type.ordinal(); byte[] buffer = _byteBuffers[ix]; if (buffer == null) { buffer = balloc(type.size); } else { _byteBuffers[ix] = null; } return buffer; }
public final char[] allocCharBuffer(CharBufferType type, int minSize) { if (type.size > minSize) { minSize = type.size; } int ix = type.ordinal(); char[] buffer = _charBuffers[ix]; if (buffer == null || buffer.length < minSize) { buffer = calloc(minSize); } else { _charBuffers[ix] = null; } return buffer; }
public final void releaseConcatBuffer(char[] buf) { if (buf != null) { if (buf != _concatCBuffer) { throw new IllegalArgumentException("Trying to release buffer not owned by the context"); } _concatCBuffer = null; _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER, buf); } }
/** * Method to call when all the processing buffers can be safely * recycled. */ public final 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 */ if (buf != _readIOBuffer) { throw new IllegalArgumentException("Trying to release buffer not owned by the context"); } _readIOBuffer = null; _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER, buf); } }
public final byte[] allocByteBuffer(ByteBufferType type) { int ix = type.ordinal(); byte[] buffer = _byteBuffers[ix]; if (buffer == null) { buffer = balloc(type.size); } else { _byteBuffers[ix] = null; } return buffer; }
public final char[] allocCharBuffer(CharBufferType type, int minSize) { if (type.size > minSize) { minSize = type.size; } int ix = type.ordinal(); char[] buffer = _charBuffers[ix]; if (buffer == null || buffer.length < minSize) { buffer = calloc(minSize); } else { _charBuffers[ix] = null; } return buffer; }
/** * Helper method used to find a buffer to use, ideally one * recycled earlier. */ private final char[] findBuffer(int needed) { if (_allocator != null) { return _allocator.allocCharBuffer(BufferRecycler.CharBufferType.TEXT_BUFFER, needed); } return new char[Math.max(needed, MIN_SEGMENT_LEN)]; }
public final void releaseNameCopyBuffer(char[] buf) { if (buf != null) { if (buf != _nameCopyBuffer) { throw new IllegalArgumentException("Trying to release buffer not owned by the context"); } _nameCopyBuffer = null; _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, buf); } } }
public final byte[] allocWriteEncodingBuffer() { if (_writeEncodingBuffer != null) { throw new IllegalStateException("Trying to call allocWriteEncodingBuffer() second time"); } _writeEncodingBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER); return _writeEncodingBuffer; }
/** * Clean up method to call to release all buffers this object may be * using. After calling the method, no other accessors can be used (and * attempt to do so may result in an exception) */ public void release() { reset(); if (_bufferRecycler != null && _currBlock != null) { _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.WRITE_CONCAT_BUFFER, _currBlock); _currBlock = null; } }
/** * Method used by factory to create buffer recycler instances * for parsers and generators. *<p> * Note: only public to give access for <code>ObjectMapper</code> */ public BufferRecycler _getBufferRecycler() { SoftReference<BufferRecycler> ref = _recyclerRef.get(); BufferRecycler br = (ref == null) ? null : ref.get(); if (br == null) { br = new BufferRecycler(); _recyclerRef.set(new SoftReference<BufferRecycler>(br)); } return br; }
public byte[] allocByteBuffer(ByteBufferType type) { int ix = type.ordinal(); byte[] buffer = mByteBuffers[ix]; if (buffer == null) { buffer = balloc(type.size); } else { mByteBuffers[ix] = null; } return buffer; }
public char[] allocCharBuffer(CharBufferType type, int minSize) { if (type.size > minSize) { minSize = type.size; } int ix = type.ordinal(); char[] buffer = mCharBuffers[ix]; if (buffer == null || buffer.length < minSize) { buffer = calloc(minSize); } else { mCharBuffers[ix] = null; } return buffer; }
public final char[] allocNameCopyBuffer(int minSize) { if (_nameCopyBuffer != null) { throw new IllegalStateException("Trying to call allocNameCopyBuffer() second time"); } _nameCopyBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, minSize); return _nameCopyBuffer; }
/** * Method called to indicate that the underlying buffers should now * be recycled if they haven't yet been recycled. Although caller * can still use this text buffer, it is not advisable to call this * method if that is likely, since next time a buffer is needed, * buffers need to reallocated. * Note: calling this method automatically also clears contents * of the buffer. */ public void releaseBuffers() { if (_allocator == null) { resetWithEmpty(); } else { if (_currentSegment != null) { // First, let's get rid of all but the largest char array resetWithEmpty(); // And then return that array char[] buf = _currentSegment; _currentSegment = null; _allocator.releaseCharBuffer(BufferRecycler.CharBufferType.TEXT_BUFFER, buf); } } }