Package org.glassfish.jersey.internal.util.collection

Class ByteBufferInputStream

  • All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable
    public final class ByteBufferInputStream
extends NonBlockingInputStream
    An InputStream backed by a queue of byte buffers to be read.

    This input stream serves as a bridging inbound I/O component between a blocking upper I/O layer and an underlying non-blocking I/O layer. In addition to the blocking InputStream.read operations, this input stream provides the non-blocking tryRead counterparts.

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private java.util.concurrent.BlockingQueue<java.nio.ByteBuffer> buffers
      Queue of byte buffers to be read.
      private java.util.concurrent.atomic.AtomicBoolean closed
      Closed flag.
      private java.nio.ByteBuffer current
      Currently read byte buffer.
      private boolean eof
      Read-side EOF flag.
      private static java.nio.ByteBuffer EOF
      Constant buffer indicating EOF.
      private java.util.concurrent.atomic.AtomicReference<java.lang.Object> queueStatus
      Content represents the buffer queue status.

    • Constructor Summary

      Constructors 
      Constructor Description
      ByteBufferInputStream()
      Create a new input stream that is backed by a a queue of byte buffers to be read.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      int available()
      Returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream.
      private void checkNotClosed()  
      private void checkThrowable()  
      void close()  
      void closeQueue()
      Closes the byte buffer sink of this input stream to indicate that writing to the stream has been finished.
      void closeQueue​(java.lang.Throwable throwable)
      Closes the byte buffer sink of this input stream to indicate that writing to the stream has been finished due to a throwable.
      private boolean fetchChunk​(boolean block)  
      boolean put​(java.nio.ByteBuffer src)
      Put the ByteBuffer to the internal queue to be available for reading from the stream.
      int read()  
      int read​(byte[] b, int off, int len)  
      int tryRead()
      Behaves mostly like InputStream.read().
      private int tryRead​(boolean block)  
      int tryRead​(byte[] b)
      Behaves mostly like InputStream.read(byte[]).
      int tryRead​(byte[] b, int off, int len)
      Behaves mostly like InputStream.read(byte[], int, int).
      private int tryRead​(byte[] b, int off, int len, boolean block)  

      • Methods inherited from class java.io.InputStream

        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

      • EOF

        private static final java.nio.ByteBuffer EOF
        Constant buffer indicating EOF.

      • eof

        private boolean eof
        Read-side EOF flag. Does not have to be volatile, it is transient and only accessed from the reader thread.

      • current

        private java.nio.ByteBuffer current
        Currently read byte buffer.

      • buffers

        private final java.util.concurrent.BlockingQueue<java.nio.ByteBuffer> buffers
        Queue of byte buffers to be read.

      • queueStatus

        private final java.util.concurrent.atomic.AtomicReference<java.lang.Object> queueStatus
        Content represents the buffer queue status. null = open, POISON_PILL = closed, Throwable = closed with error

      • closed

        private final java.util.concurrent.atomic.AtomicBoolean closed
        Closed flag.

    • Constructor Detail

      • ByteBufferInputStream

        public ByteBufferInputStream()
        Create a new input stream that is backed by a a queue of byte buffers to be read.

    • Method Detail

      • fetchChunk

        private boolean fetchChunk​(boolean block)
                    throws java.lang.InterruptedException
        Throws:
        java.lang.InterruptedException

      • checkNotClosed

        private void checkNotClosed()
                     throws java.io.IOException
        Throws:
        java.io.IOException

      • checkThrowable

        private void checkThrowable()
                     throws java.io.IOException
        Throws:
        java.io.IOException

      • available

        public int available()
              throws java.io.IOException
        Description copied from class: NonBlockingInputStream
        Returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream. The next invocation might be the same thread or another thread. A single read or skip of this many bytes will not block, but may read or skip fewer bytes.

        Note that while some implementations of InputStream will return the total number of bytes in the stream, many will not. It is never correct to use the return value of this method to allocate a buffer intended to hold all data in this stream.

        A subclass' implementation of this method may choose to throw an IOException if this input stream has been closed by invoking the InputStream.close() method.

        The default implementation of this method in NonBlockingInputStream throws an UnsupportedOperationException. This method must be overridden by subclasses. The overriding implementations must guarantee non-blocking behavior of the method. The overriding implementation must also guarantee that a non-empty stream does not return zero from the method. IOW, it must be possible to use the method for empty check: stream.available() == 0

        Overrides:
        available in class NonBlockingInputStream
        Returns:
        an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking or 0 when it reaches the end of the input stream or the stream is empty.
        Throws:
        java.io.IOException - if an I/O error occurs.

      • read

        public int read()
         throws java.io.IOException
        Specified by:
        read in class java.io.InputStream
        Throws:
        java.io.IOException

      • read

        public int read​(byte[] b,
                int off,
                int len)
         throws java.io.IOException
        Overrides:
        read in class java.io.InputStream
        Throws:
        java.io.IOException

      • tryRead

        public int tryRead()
            throws java.io.IOException
        Description copied from class: NonBlockingInputStream
        Behaves mostly like InputStream.read(). The main difference is that this method is non-blocking. In case there are no data available to be read, the method returns NonBlockingInputStream.NOTHING immediately.
        Specified by:
        tryRead in class NonBlockingInputStream
        Returns:
        next byte of data, -1 if end of the stream has been reached or NonBlockingInputStream.NOTHING in case no data are available to be read at the moment.
        Throws:
        java.io.IOException - if an I/O error occurs.

      • tryRead

        public int tryRead​(byte[] b)
            throws java.io.IOException
        Description copied from class: NonBlockingInputStream
        Behaves mostly like InputStream.read(byte[]). The main difference is that this method is non-blocking. In case there are no data available to be read, the method returns zero immediately.
        Specified by:
        tryRead in class NonBlockingInputStream
        Parameters:
        b - the buffer into which the data is read.
        Returns:
        the total number of bytes read into the buffer or -1 if end of the stream has been reached or 0 in case no data are available to be read at the moment.
        Throws:
        java.io.IOException - if an I/O error occurs.

      • tryRead

        public int tryRead​(byte[] b,
                   int off,
                   int len)
            throws java.io.IOException
        Description copied from class: NonBlockingInputStream
        Behaves mostly like InputStream.read(byte[], int, int). The main difference is that this method is non-blocking. In case there are no data available to be read, the method returns zero immediately.
        Specified by:
        tryRead in class NonBlockingInputStream
        Parameters:
        b - the buffer into which the data is read.
        off - the start offset in array b at which the data is written.
        len - the maximum number of bytes to read.
        Returns:
        the total number of bytes read into the buffer or -1 if end of the stream has been reached or 0 in case no data are available to be read at the moment.
        Throws:
        java.io.IOException - if an I/O error occurs.

      • close

        public void close()
           throws java.io.IOException
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface java.io.Closeable
        Overrides:
        close in class java.io.InputStream
        Throws:
        java.io.IOException

      • put

        public boolean put​(java.nio.ByteBuffer src)
            throws java.lang.InterruptedException
        Put the ByteBuffer to the internal queue to be available for reading from the stream.

        If the sink is open, the method puts the buffer into an internal byte buffer read queue , waiting if necessary for space to become available. Then the method returns true to indicate the buffer has been successfully queued. In case the internal read queue has been closed already, the method simply returns false without registering the buffer in the closed queue.

        Parameters:
        src - the source buffer to be registered in the byte buffer read queue.
        Returns:
        true if the byte buffer has been successfully put in the read queue, false if the read queue has been closed.
        Throws:
        java.lang.InterruptedException - in case the put operation has been interrupted.

      • closeQueue

        public void closeQueue()
        Closes the byte buffer sink of this input stream to indicate that writing to the stream has been finished.

        If the sink has already been closed then this method returns immediately. Otherwise the sink is marked as closed and no more data can be written to it.

      • closeQueue

        public void closeQueue​(java.lang.Throwable throwable)
        Closes the byte buffer sink of this input stream to indicate that writing to the stream has been finished due to a throwable. The throwable set by this method will be propagated to the reader thread when a new attempt to read bytes is made.

        If the sink has already been closed then this method only sets the throwable in the stream and then returns immediately. Otherwise the sink is also marked as closed and no more data can be written to it.

        Parameters:
        throwable - throwable that is set in the stream. It will be thrown by the stream in case an attempt to read more data or check available bytes is made.

      • tryRead

        private int tryRead​(byte[] b,
                    int off,
                    int len,
                    boolean block)
             throws java.io.IOException
        Throws:
        java.io.IOException

      • tryRead

        private int tryRead​(boolean block)
             throws java.io.IOException
        Throws:
        java.io.IOException