com.lowagie.text.pdf

## Class ByteBuffer

- java.lang.Object
- - java.io.OutputStream
  - - com.lowagie.text.pdf.ByteBuffer

- All Implemented Interfaces:
    java.io.Closeable, java.io.Flushable

      public class ByteBuffer
      extends java.io.OutputStream

  Acts like a `StringBuffer` but works with `byte` arrays. Floating point is converted to a format suitable to the PDF.
  Author:
    Paulo Soares (psoares@consiste.pt)

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected byte[]` | `buf` The buffer where the bytes are stored.
    `private static byte[][]` | `byteCache`
    `private static int` | `byteCacheSize`
    `private static byte[]` | `bytes`
    `private static char[]` | `chars`
    `protected int` | `count` The count of bytes in the buffer.
    `private static java.text.DecimalFormatSymbols` | `dfs`
    `static boolean` | `HIGH_PRECISION` If `true` always output floating point numbers with 6 decimal digits.
    `static byte` | `ZERO`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ByteBuffer()` Creates new ByteBuffer with capacity 128
    `ByteBuffer(int size)` Creates a byte buffer with a certain capacity.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `ByteBuffer` | `append_i(int b)` Appends an `int`.
    `ByteBuffer` | `append(byte b)`
    `ByteBuffer` | `append(byte[] b)` Appends an array of bytes.
    `ByteBuffer` | `append(byte[] b, int off, int len)` Appends the subarray of the `byte` array.
    `ByteBuffer` | `append(ByteBuffer buf)` Appends another `ByteBuffer` to this buffer.
    `ByteBuffer` | `append(char c)` Appends a `char` to the buffer.
    `ByteBuffer` | `append(double d)` Appends a string representation of a `double` according to the Pdf conventions.
    `ByteBuffer` | `append(float i)` Appends a string representation of a `float` according to the Pdf conventions.
    `ByteBuffer` | `append(int i)` Appends the string representation of an `int`.
    `ByteBuffer` | `append(java.lang.String str)` Appends a `String` to the buffer.
    `ByteBuffer` | `appendHex(byte b)`
    `private static byte[]` | `convertToBytes(int i)` Converts an double (multiplied by 100 and cast to an int) into an array of bytes.
    `static void` | `fillCache(int decimals)` You can fill the cache in advance if you want to.
    `static java.lang.String` | `formatDouble(double d)` Outputs a `double` into a format suitable for the PDF.
    `static java.lang.String` | `formatDouble(double d, ByteBuffer buf)` Outputs a `double` into a format suitable for the PDF.
    `byte[]` | `getBuffer()`
    `void` | `reset()` Sets the size to zero.
    `static void` | `setCacheSize(int size)` Sets the cache size.
    `void` | `setSize(int size)`
    `int` | `size()` Returns the current size of the buffer.
    `byte[]` | `toByteArray()` Creates a newly allocated byte array.
    `java.lang.String` | `toString()` Converts the buffer's contents into a string, translating bytes into characters according to the platform's default character encoding.
    `java.lang.String` | `toString(java.lang.String enc)` Converts the buffer's contents into a string, translating bytes into characters according to the specified character encoding.
    `void` | `write(byte[] b, int off, int len)`
    `void` | `write(int b)`
    `void` | `writeTo(java.io.OutputStream out)` Writes the complete contents of this byte buffer output to the specified output stream argument, as if by calling the output stream's write method using `out.write(buf, 0, count)`.

    - ### Methods inherited from class java.io.OutputStream

      `close, flush, write`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### count

          protected int count

      The count of bytes in the buffer.

    - #### buf

          protected byte[] buf

      The buffer where the bytes are stored.

    - #### byteCacheSize

          private static int byteCacheSize

    - #### byteCache

          private static byte[][] byteCache

    - #### ZERO

          public static final byte ZERO

      See Also:
        Constant Field Values

    - #### chars

          private static final char[] chars

    - #### bytes

          private static final byte[] bytes

    - #### HIGH_PRECISION

          public static boolean HIGH_PRECISION

      If `true` always output floating point numbers with 6 decimal digits. If `false` uses the faster, although less precise, representation.

    - #### dfs

          private static final java.text.DecimalFormatSymbols dfs

  - ### Constructor Detail

    - #### ByteBuffer

          public ByteBuffer()

      Creates new ByteBuffer with capacity 128

    - #### ByteBuffer

          public ByteBuffer(int size)

      Creates a byte buffer with a certain capacity.
      Parameters:
        `size` - the initial capacity

  - ### Method Detail

    - #### setCacheSize

          public static void setCacheSize(int size)

      Sets the cache size.

      This can only be used to increment the size. If the size that is passed through is smaller than the current size, nothing happens.

      Parameters:
        `size` - the size of the cache

    - #### fillCache

          public static void fillCache(int decimals)

      You can fill the cache in advance if you want to.
      Parameters:
        `decimals` -

    - #### convertToBytes

          private static byte[] convertToBytes(int i)

      Converts an double (multiplied by 100 and cast to an int) into an array of bytes.
      Parameters:
        `i` - the int
      Returns:
        a byte array

    - #### append_i

          public ByteBuffer append_i(int b)

      Appends an `int`. The size of the array will grow by one.
      Parameters:
        `b` - the int to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(byte[] b,
                          int off,
                          int len)

      Appends the subarray of the `byte` array. The buffer will grow by `len` bytes.
      Parameters:
        `b` - the array to be appended
        `off` - the offset to the start of the array
        `len` - the length of bytes to append
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(byte[] b)

      Appends an array of bytes.
      Parameters:
        `b` - the array to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(java.lang.String str)

      Appends a `String` to the buffer. The `String` is converted according to the encoding ISO-8859-1.
      Parameters:
        `str` - the `String` to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(char c)

      Appends a `char` to the buffer. The `char` is converted according to the encoding ISO-8859-1.
      Parameters:
        `c` - the `char` to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(ByteBuffer buf)

      Appends another `ByteBuffer` to this buffer.
      Parameters:
        `buf` - the `ByteBuffer` to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(int i)

      Appends the string representation of an `int`.
      Parameters:
        `i` - the `int` to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(byte b)

    - #### appendHex

          public ByteBuffer appendHex(byte b)

    - #### append

          public ByteBuffer append(float i)

      Appends a string representation of a `float` according to the Pdf conventions.
      Parameters:
        `i` - the `float` to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### append

          public ByteBuffer append(double d)

      Appends a string representation of a `double` according to the Pdf conventions.
      Parameters:
        `d` - the `double` to be appended
      Returns:
        a reference to this `ByteBuffer` object

    - #### formatDouble

          public static java.lang.String formatDouble(double d)

      Outputs a `double` into a format suitable for the PDF.
      Parameters:
        `d` - a double
      Returns:
        the `String` representation of the `double`

    - #### formatDouble

          public static java.lang.String formatDouble(double d,
                                      ByteBuffer buf)

      Outputs a `double` into a format suitable for the PDF.
      Parameters:
        `d` - a double
        `buf` - a ByteBuffer
      Returns:
        the `String` representation of the `double` if `buf` is `null`. If `buf` is not `null`, then the double is appended directly to the buffer and this methods returns `null`.

    - #### reset

          public void reset()

      Sets the size to zero.

    - #### toByteArray

          public byte[] toByteArray()

      Creates a newly allocated byte array. Its size is the current size of this output stream and the valid contents of the buffer have been copied into it.
      Returns:
        the current contents of this output stream, as a byte array.

    - #### size

          public int size()

      Returns the current size of the buffer.
      Returns:
        the value of the `count` field, which is the number of valid bytes in this byte buffer.

    - #### setSize

          public void setSize(int size)

    - #### toString

          public java.lang.String toString()

      Converts the buffer's contents into a string, translating bytes into characters according to the platform's default character encoding.
      Overrides:
        `toString` in class `java.lang.Object`
      Returns:
        String translated from the buffer's contents.

    - #### toString

          public java.lang.String toString(java.lang.String enc)
                                    throws java.io.UnsupportedEncodingException

      Converts the buffer's contents into a string, translating bytes into characters according to the specified character encoding.
      Parameters:
        `enc` - a character-encoding name.
      Returns:
        String translated from the buffer's contents.
      Throws:
        `java.io.UnsupportedEncodingException` - If the named encoding is not supported.

    - #### writeTo

          public void writeTo(java.io.OutputStream out)
                       throws java.io.IOException

      Writes the complete contents of this byte buffer output to the specified output stream argument, as if by calling the output stream's write method using `out.write(buf, 0, count)`.
      Parameters:
        `out` - the output stream to which to write the data.
      Throws:
        `java.io.IOException` - if an I/O error occurs.

    - #### write

          public void write(int b)
                     throws java.io.IOException

      Specified by:
        `write` in class `java.io.OutputStream`
      Throws:
        `java.io.IOException`

    - #### write

          public void write(byte[] b,
                   int off,
                   int len)

      Overrides:
        `write` in class `java.io.OutputStream`

    - #### getBuffer

          public byte[] getBuffer()