Package org.apache.derby.client.am

Class ByteArrayCombinerStream

  • All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable
    public class ByteArrayCombinerStream
extends java.io.InputStream
    A stream whose source is a list of byte arrays. This class was created when first implementing the JDBC 4 length less overloads in the client driver. The reason was missing support for streaming data with unknown length from the client to the server. The purpose of the stream is to avoid having to repeatedly copy data to grow the byte buffer, or doing a single big copy to combine the byte arrays in the end. This is important for the temporary solution, since we must materialize the stream to find the length anyway. If there is less data available than the specified length, an exception is thrown. Available data is determined by the length of the byte arrays, not the contents of them. A byte array with all 0's is considered valid data. Besides from truncation, this stream does not change the underlying data in any way.

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private int arrayIndex
      Index of the array we are currently reading from.
      private java.util.ArrayList<byte[]> arrays
      A list of the arrays to combine.
      private byte[] curArray
      The array we are currently reading from.
      private long gOffset
      Global offset into the whole stream.
      private int off
      The local offset into the current array.
      private long specifiedLength
      Length of the stream.

    • Constructor Summary

      Constructors 
      Constructor Description
      ByteArrayCombinerStream​(java.util.ArrayList<byte[]> arraysIn, long length)
      Create a stream whose source is a list of byte arrays.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      int available()
      Return the number of available bytes.
      private byte[] nextArray()
      Fetch the next array to read data from.
      int read()
      Read a single byte.
      int read​(byte[] buf, int offset, int length)
      Reads up to len bytes of data from the input stream into an array of bytes.

      • Methods inherited from class java.io.InputStream

        close, mark, markSupported, nullInputStream, read, readAllBytes, readNBytes, readNBytes, reset, skip, transferTo

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • arrays

        private final java.util.ArrayList<byte[]> arrays
        A list of the arrays to combine.

      • specifiedLength

        private final long specifiedLength
        Length of the stream.

      • gOffset

        private long gOffset
        Global offset into the whole stream.

      • arrayIndex

        private int arrayIndex
        Index of the array we are currently reading from.

      • curArray

        private byte[] curArray
        The array we are currently reading from.

      • off

        private int off
        The local offset into the current array.

    • Constructor Detail

      • ByteArrayCombinerStream

        public ByteArrayCombinerStream​(java.util.ArrayList<byte[]> arraysIn,
                               long length)
        Create a stream whose source is a list of byte arrays.
        Parameters:
        arraysIn - an ArrayList with references to the source byte arrays. The references are copied to a new ArrayList instance.
        length - the length of the stream. Never published outside this object. Note that the length specified can be shorter than the actual number of bytes in the byte arrays.
        Throws:
        java.lang.IllegalArgumentException - if there is less data available than specified by length, or length is negative.

    • Method Detail

      • read

        public int read()
         throws java.io.IOException
        Read a single byte.
        Specified by:
        read in class java.io.InputStream
        Returns:
        a byte, or -1 if the end-of-stream is reached
        Throws:
        java.io.IOException

      • read

        public int read​(byte[] buf,
                int offset,
                int length)
         throws java.io.IOException
        Reads up to len bytes of data from the input stream into an array of bytes. An attempt is made to read as many as len bytes, but a smaller number may be read. The number of bytes actually read is returned as an integer.
        Overrides:
        read in class java.io.InputStream
        Parameters:
        buf - the array to copy bytes into
        offset - offset into the array
        length - the maximum number of bytes to read
        Returns:
        the number of bytes read, or -1 if end-of-stream is reached
        Throws:
        java.io.IOException

      • available

        public int available()
        Return the number of available bytes. The method assumes the specified length of the stream is correct.
        Overrides:
        available in class java.io.InputStream
        Returns:
        number of available bytes

      • nextArray

        private byte[] nextArray()
        Fetch the next array to read data from. The reference in the ArrayList is cleared when the array is "taken out".
        Returns:
        a byte[]-object, or null if there are no more arrays