ByteArrayBuilder (jackson-core 2.18.0)

java.lang.Object
- java.io.OutputStream
- - com.fasterxml.jackson.core.util.ByteArrayBuilder

All Implemented Interfaces:

BufferRecycler.Gettable, Closeable, Flushable, AutoCloseable
```
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 Summary

Fields
Modifier and Type Field and Description

static byte[] NO_BYTES

Fields
Modifier and Type	Field and Description
`static byte[]`	`NO_BYTES`

Constructor Summary

Constructors
Constructor and Description
`ByteArrayBuilder()`
`ByteArrayBuilder(BufferRecycler br)`
`ByteArrayBuilder(BufferRecycler br, int firstBlockSize)`
`ByteArrayBuilder(int firstBlockSize)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`append(int i)`
`void`	`appendFourBytes(int b32)`
`void`	`appendThreeBytes(int b24)`
`void`	`appendTwoBytes(int b16)`
`BufferRecycler`	`bufferRecycler()`
`void`	`close()`
`byte[]`	`completeAndCoalesce(int lastBlockLength)` Method that will complete "manual" output process, coalesce content (if necessary) and return results as a contiguous buffer.
`byte[]`	`finishCurrentSegment()` Method called when the current segment buffer is full; will append to current contents, allocate a new segment buffer and return it
`void`	`flush()`
`static ByteArrayBuilder`	`fromInitial(byte[] initialBlock, int length)`
`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.
`byte[]`	`getCurrentSegment()`
`int`	`getCurrentSegmentLength()`
`void`	`release()` Clean up method to call to release all buffers this object may be using.
`void`	`reset()`
`byte[]`	`resetAndGetFirstSegment()` Method called when starting "manual" output: will clear out current state and return the first segment buffer to fill
`void`	`setCurrentSegmentLength(int len)`
`int`	`size()`
`byte[]`	`toByteArray()` Method called when results are finalized and we can get the full aggregated result buffer to return to the caller
`void`	`write(byte[] b)`
`void`	`write(byte[] b, int off, int len)`
`void`	`write(int b)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NO_BYTES
```
public static final byte[] NO_BYTES
```
- Constructor Detail
  - ByteArrayBuilder
```
public ByteArrayBuilder()
```
  - ByteArrayBuilder
```
public ByteArrayBuilder(BufferRecycler br)
```
  - ByteArrayBuilder
```
public ByteArrayBuilder(int firstBlockSize)
```
  - ByteArrayBuilder
```
public ByteArrayBuilder(BufferRecycler br,
                        int firstBlockSize)
```
- Method Detail
  - 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:
    
    Content in byte array
    
    Since:
    
    2.17
  - 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 Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Overrides:
    
    close in class OutputStream
  - flush
```
public void flush()
```
    Specified by:
    
    flush in interface Flushable
    
    Overrides:
    
    flush in class OutputStream

Class ByteArrayBuilder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NO_BYTES

Constructor Detail

ByteArrayBuilder

ByteArrayBuilder

ByteArrayBuilder

ByteArrayBuilder

Method Detail

fromInitial

reset

size

release

append

appendTwoBytes

appendThreeBytes

appendFourBytes

toByteArray

getClearAndRelease

bufferRecycler

resetAndGetFirstSegment

finishCurrentSegment

completeAndCoalesce

getCurrentSegment

setCurrentSegmentLength

getCurrentSegmentLength

write

write

write

close

flush