Class ByteArrayBuilder

java.lang.Object
java.io.OutputStream
tools.jackson.core.util.ByteArrayBuilder
All Implemented Interfaces:
Closeable, Flushable, AutoCloseable, BufferRecycler.Gettable
public final class ByteArrayBuilder extends OutputStream implements BufferRecycler.Gettable
Helper class that is similar to ByteArrayOutputStream in usage, but more geared to Jackson use cases internally. Specific changes include segment storage (no need to have linear backing buffer, can avoid reallocations, copying), as well API not based on OutputStream. In short, a very much specialized builder object.

Also implements OutputStream to allow efficient aggregation of output content as a byte array, similar to how ByteArrayOutputStream works, but somewhat more efficiently for many use cases.

NOTE: maximum size limited to Java Array maximum, 2 gigabytes: this because usage pattern is to collect content for a `byte[]` and so although theoretically this builder can aggregate more content it will not be usable as things are. Behavior may be improved if we solve the access problem.

  • Field Details

    • NO_BYTES

      public static final byte[] NO_BYTES

    • INITIAL_BLOCK_SIZE

      private static final int INITIAL_BLOCK_SIZE
      See Also:

    • MAX_BLOCK_SIZE

      private static final int MAX_BLOCK_SIZE
      See Also:

    • DEFAULT_BLOCK_ARRAY_SIZE

      static final int DEFAULT_BLOCK_ARRAY_SIZE
      See Also:

    • _bufferRecycler

      private final BufferRecycler _bufferRecycler

    • _pastBlocks

      private final List<byte[]> _pastBlocks

    • _pastLen

      private int _pastLen

    • _currBlock

      private byte[] _currBlock

    • _currBlockPtr

      private int _currBlockPtr

  • Constructor Details

    • ByteArrayBuilder

      public ByteArrayBuilder()

    • ByteArrayBuilder

      public ByteArrayBuilder(BufferRecycler br)

    • ByteArrayBuilder

      public ByteArrayBuilder(int firstBlockSize)

    • ByteArrayBuilder

      public ByteArrayBuilder(BufferRecycler br, int firstBlockSize)

    • ByteArrayBuilder

      private ByteArrayBuilder(BufferRecycler br, byte[] initialBlock, int initialLen)

  • Method Details

    • fromInitial

      public static ByteArrayBuilder fromInitial(byte[] initialBlock, int length)

    • reset

      public void reset()

    • size

      public int size()
      Returns:
      Number of bytes aggregated so far
      Since:
      2.9

    • release

      public void release()
      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).

    • append

      public void append(int i)

    • appendTwoBytes

      public void appendTwoBytes(int b16)

    • appendThreeBytes

      public void appendThreeBytes(int b24)

    • appendFourBytes

      public void appendFourBytes(int b32)

    • toByteArray

      public byte[] toByteArray()
      Method called when results are finalized and we can get the full aggregated result buffer to return to the caller
      Returns:
      Aggregated contents as a byte[]

    • getClearAndRelease

      public byte[] getClearAndRelease()
      Method functionally same as calling: 
        byte[] bytes = toByteArray();
  release();
  return bytes;
      that is; aggregates output contained in the builder (if any), clear state; returns buffer(s) to BufferRecycler configured, if any, and returns output to caller.
      Returns:
      Byte array with built contents

    • bufferRecycler

      public BufferRecycler bufferRecycler()
      Specified by:
      bufferRecycler in interface BufferRecycler.Gettable
      Returns:
      Buffer recycler instance object is configured with, if any; whether this can be null depends on type of object

    • resetAndGetFirstSegment

      public byte[] resetAndGetFirstSegment()
      Method called when starting "manual" output: will clear out current state and return the first segment buffer to fill
      Returns:
      Segment to use for writing

    • finishCurrentSegment

      public byte[] finishCurrentSegment()
      Method called when the current segment buffer is full; will append to current contents, allocate a new segment buffer and return it
      Returns:
      Segment to use for writing

    • completeAndCoalesce

      public byte[] completeAndCoalesce(int lastBlockLength)
      Method that will complete "manual" output process, coalesce content (if necessary) and return results as a contiguous buffer.
      Parameters:
      lastBlockLength - Amount of content in the current segment buffer.
      Returns:
      Coalesced contents

    • getCurrentSegment

      public byte[] getCurrentSegment()

    • setCurrentSegmentLength

      public void setCurrentSegmentLength(int len)

    • getCurrentSegmentLength

      public int getCurrentSegmentLength()

    • write

      public void write(byte[] b)
      Overrides:
      write in class OutputStream

    • write

      public void write(byte[] b, int off, int len)
      Overrides:
      write in class OutputStream

    • write

      public void write(int b)
      Specified by:
      write in class OutputStream

    • close

      public void close()
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Overrides:
      close in class OutputStream

    • flush

      public void flush()
      Specified by:
      flush in interface Flushable
      Overrides:
      flush in class OutputStream

    • _allocMore

      private void _allocMore()