java.lang.Object
- org.apache.druid.frame.channel.ReadableByteChunksFrameChannel

All Implemented Interfaces:

Closeable, AutoCloseable, ReadableFrameChannel
```
public class ReadableByteChunksFrameChannel
extends Object
implements ReadableFrameChannel
```
Channel backed by a byte stream that is continuously streamed in using addChunk(byte[]). The byte stream must be in the format of a FrameFile. This class is used by FrameFileHttpResponseHandler to provide nonblocking reads from a remote http server.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`com.google.common.util.concurrent.ListenableFuture<?>`	`addChunk(byte[] chunk)`	Adds a chunk of bytes.
`boolean`	`canRead()`	Returns whether this channel has a frame or error condition currently available.
`void`	`close()`	Releases any resources associated with this readable channel.
`static ReadableByteChunksFrameChannel`	`create(String id, boolean framesOnly)`	Create a channel that aims to limit its memory footprint to one frame.
`void`	`doneWriting()`	Call method when caller is done adding chunks.
`long`	`getBytesAdded()`
`String`	`getId()`
`boolean`	`isErrorOrFinished()`
`boolean`	`isFinished()`	Returns whether this channel is finished.
`Frame`	`read()`	Returns the next available frame from this channel.
`com.google.common.util.concurrent.ListenableFuture<?>`	`readabilityFuture()`	Returns a future that will resolve when either `ReadableFrameChannel.isFinished()` or `ReadableFrameChannel.canRead()` would return true.
`void`	`setError(Throwable t)`	Clears the channel and replaces it with the given error.

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

- Method Detail
  - create
```
public static ReadableByteChunksFrameChannel create(String id,
                                                    boolean framesOnly)
```
    Create a channel that aims to limit its memory footprint to one frame. The channel exerts backpressure from addChunk(byte[]) immediately once a full frame has been buffered.
  - addChunk
```
@Nullable
public com.google.common.util.concurrent.ListenableFuture<?> addChunk(byte[] chunk)
```
    Adds a chunk of bytes. If this chunk forms a full frame, it will immediately become available for reading. Otherwise, the bytes will be buffered until a full frame is encountered. Returns a backpressure future if the amount of queued bytes is at or above this channel's limit. If the return future is nonnull, callers are politely requested to wait for the future to resolve before adding additional chunks. (This is not enforced; addChunk will continue to accept new chunks even if the channel is over its limit.) When done adding chunks call doneWriting.
  - setError
```
public void setError(Throwable t)
```
    Clears the channel and replaces it with the given error. After calling this method, no additional chunks will be accepted.
  - doneWriting
```
public void doneWriting()
```
    Call method when caller is done adding chunks.
  - isFinished
```
public boolean isFinished()
```
    Description copied from interface: ReadableFrameChannel
    
    Returns whether this channel is finished. Finished channels will not generate any further frames or errors. Generally, once you discover that a channel is finished, you should call ReadableFrameChannel.close() and then discard it. Note that it is possible for a channel to be unfinished and also have no available frames or errors. This happens when it is not in a ready-for-reading state. See ReadableFrameChannel.readabilityFuture() for details.
    
    Specified by:
    
    isFinished in interface ReadableFrameChannel
  - canRead
```
public boolean canRead()
```
    Description copied from interface: ReadableFrameChannel
    
    Returns whether this channel has a frame or error condition currently available. If this method returns true, then you can call ReadableFrameChannel.read() to retrieve the frame or error. Note that it is possible for a channel to be unfinished and also have no available frames or errors. This happens when it is not in a ready-for-reading state. See ReadableFrameChannel.readabilityFuture() for details.
    
    Specified by:
    
    canRead in interface ReadableFrameChannel
  - read
```
public Frame read()
```
    Description copied from interface: ReadableFrameChannel
    
    Returns the next available frame from this channel. Before calling this method, you should check ReadableFrameChannel.canRead() to ensure there is a frame or error available.
    
    Specified by:
    
    read in interface ReadableFrameChannel
  - readabilityFuture
```
public com.google.common.util.concurrent.ListenableFuture<?> readabilityFuture()
```
    Description copied from interface: ReadableFrameChannel
    
    Returns a future that will resolve when either ReadableFrameChannel.isFinished() or ReadableFrameChannel.canRead() would return true. The future will never resolve to an exception. If something exceptional has happened, the exception can be retrieved from ReadableFrameChannel.read().
    
    Specified by:
    
    readabilityFuture in interface ReadableFrameChannel
  - close
```
public void close()
```
    Description copied from interface: ReadableFrameChannel
    
    Releases any resources associated with this readable channel. After calling this, you should not call any other methods on the channel.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface ReadableFrameChannel
  - getId
```
public String getId()
```
  - getBytesAdded
```
public long getBytesAdded()
```
  - isErrorOrFinished
```
public boolean isErrorOrFinished()
```

Class ReadableByteChunksFrameChannel

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

addChunk

setError

doneWriting

isFinished

canRead

read

readabilityFuture

close

getId

getBytesAdded

isErrorOrFinished