Uses of Interface
io.netty.handler.codec.http2.Http2Stream

Packages that use Http2Stream

Package	Description
io.netty.handler.codec.http2	Handlers for sending and receiving HTTP/2 frames.

Uses of Http2Stream in io.netty.handler.codec.http2

Classes in io.netty.handler.codec.http2 that implement Http2Stream

Modifier and Type	Class	Description
private final class	DefaultHttp2Connection.ConnectionStream	Stream class representing the connection, itself.
private class	DefaultHttp2Connection.DefaultStream	Simple stream implementation.

Fields in io.netty.handler.codec.http2 declared as Http2Stream

Modifier and Type	Field	Description
protected final Http2Stream	DefaultHttp2ConnectionEncoder.FlowControlledBase.stream
private final Http2Stream	DefaultHttp2LocalFlowController.DefaultState.stream
private final Http2Stream	DefaultHttp2RemoteFlowController.FlowState.stream
private Http2Stream	DelegatingDecompressorFrameListener.Http2Decompressor.stream
private Http2Stream	Http2FrameCodec.DefaultHttp2FrameStream.stream
(package private) final Http2Stream	UniformStreamByteDistributor.State.stream
(package private) Http2Stream	WeightedFairQueueByteDistributor.State.stream	Maybe null if the stream if the stream is not active.

Fields in io.netty.handler.codec.http2 with type parameters of type Http2Stream

Modifier and Type	Field	Description
(package private) final IntObjectMap<Http2Stream>	DefaultHttp2Connection.streamMap
private final Set<Http2Stream>	DefaultHttp2Connection.ActiveStreams.streams

Methods in io.netty.handler.codec.http2 that return Http2Stream

Modifier and Type	Method	Description
Http2Stream	DefaultHttp2Connection.ConnectionStream.close()
Http2Stream	DefaultHttp2Connection.DefaultStream.close()
(package private) Http2Stream	DefaultHttp2Connection.DefaultStream.close(Iterator<?> itr)
Http2Stream	Http2Stream.close()	Closes the stream.
Http2Stream	DefaultHttp2Connection.ConnectionStream.closeLocalSide()
Http2Stream	DefaultHttp2Connection.DefaultStream.closeLocalSide()
Http2Stream	Http2Stream.closeLocalSide()	Closes the local side of this stream.
Http2Stream	DefaultHttp2Connection.ConnectionStream.closeRemoteSide()
Http2Stream	DefaultHttp2Connection.DefaultStream.closeRemoteSide()
Http2Stream	Http2Stream.closeRemoteSide()	Closes the remote side of this stream.
Http2Stream	DefaultHttp2Connection.connectionStream()
Http2Stream	Http2Connection.connectionStream()	Gets the stream object representing the connection, itself (i.e.
Http2Stream	Http2Connection.Endpoint.createStream(int streamId, boolean halfClosed)	Creates a stream initiated by this endpoint.
Http2Stream	DefaultHttp2Connection.ActiveStreams.forEachActiveStream(Http2StreamVisitor visitor)
Http2Stream	DefaultHttp2Connection.forEachActiveStream(Http2StreamVisitor visitor)
Http2Stream	Http2Connection.forEachActiveStream(Http2StreamVisitor visitor)	Provide a means of iterating over the collection of active streams.
Http2Stream	DefaultHttp2Connection.DefaultStream.headersReceived(boolean isInformational)
Http2Stream	Http2Stream.headersReceived(boolean isInformational)	Indicates that headers have been received.
Http2Stream	DefaultHttp2Connection.ConnectionStream.headersSent(boolean isInformational)
Http2Stream	DefaultHttp2Connection.DefaultStream.headersSent(boolean isInformational)
Http2Stream	Http2Stream.headersSent(boolean isInformational)	Indicates that headers have been sent to the remote endpoint on this stream.
Http2Stream	DefaultHttp2Connection.ConnectionStream.open(boolean halfClosed)
Http2Stream	DefaultHttp2Connection.DefaultStream.open(boolean halfClosed)
Http2Stream	Http2Stream.open(boolean halfClosed)	Opens this stream, making it available via Http2Connection.forEachActiveStream(Http2StreamVisitor) and transition state to: Http2Stream.State.OPEN if state() is Http2Stream.State.IDLE and halfClosed is false. Http2Stream.State.HALF_CLOSED_LOCAL if state() is Http2Stream.State.IDLE and halfClosed is true and the stream is local.
Http2Stream	DefaultHttp2Connection.ConnectionStream.pushPromiseSent()
Http2Stream	DefaultHttp2Connection.DefaultStream.pushPromiseSent()
Http2Stream	Http2Stream.pushPromiseSent()	Indicates that a push promise was sent to the remote endpoint.
private Http2Stream	DefaultHttp2ConnectionEncoder.requireStream(int streamId)
Http2Stream	Http2Connection.Endpoint.reservePushStream(int streamId, Http2Stream parent)	Creates a push stream in the reserved state for this endpoint and notifies all listeners.
Http2Stream	DefaultHttp2Connection.ConnectionStream.resetSent()
Http2Stream	DefaultHttp2Connection.DefaultStream.resetSent()
Http2Stream	Http2Stream.resetSent()	Sets the flag indicating that a RST_STREAM frame has been sent from the local endpoint for this stream.
Http2Stream	DefaultHttp2Connection.stream(int streamId)
Http2Stream	DefaultHttp2RemoteFlowController.FlowState.stream()	The stream this state is associated with.
Http2Stream	Http2Connection.stream(int streamId)	Gets the stream if it exists.
Http2Stream	StreamByteDistributor.StreamState.stream()	Gets the stream this state is associated with.

Methods in io.netty.handler.codec.http2 with parameters of type Http2Stream

Modifier and Type	Method	Description
void	DefaultHttp2RemoteFlowController.addFlowControlled(Http2Stream stream, Http2RemoteFlowController.FlowControlled frame)
void	Http2RemoteFlowController.addFlowControlled(Http2Stream stream, Http2RemoteFlowController.FlowControlled payload)	Queues a payload for transmission to the remote endpoint.
(package private) void	CompressorHttp2ConnectionEncoder.cleanup(Http2Stream stream, EmbeddedChannel compressor)	Release remaining content from EmbeddedChannel and remove the compressor from the Http2Stream.
void	Http2ConnectionHandler.closeStream(Http2Stream stream, ChannelFuture future)
void	Http2LifecycleManager.closeStream(Http2Stream stream, ChannelFuture future)	Closes and deactivates the given stream.
void	Http2ConnectionHandler.closeStreamLocal(Http2Stream stream, ChannelFuture future)	Closes the local side of the given stream.
void	Http2LifecycleManager.closeStreamLocal(Http2Stream stream, ChannelFuture future)	Closes the local side of the stream.
void	Http2ConnectionHandler.closeStreamRemote(Http2Stream stream, ChannelFuture future)	Closes the remote side of the given stream.
void	Http2LifecycleManager.closeStreamRemote(Http2Stream stream, ChannelFuture future)	Closes the remote side of the stream.
boolean	DefaultHttp2LocalFlowController.consumeBytes(Http2Stream stream, int numBytes)
boolean	DelegatingDecompressorFrameListener.ConsumedBytesConverter.consumeBytes(Http2Stream stream, int numBytes)
boolean	Http2LocalFlowController.consumeBytes(Http2Stream stream, int numBytes)	Indicates that the application has consumed a number of bytes for the given stream and is therefore ready to receive more data from the remote endpoint.
boolean	DefaultHttp2Connection.DefaultEndpoint.created(Http2Stream stream)
boolean	Http2Connection.Endpoint.created(Http2Stream stream)	Indicates whether or not this endpoint created the given stream.
(package private) int	DelegatingDecompressorFrameListener.Http2Decompressor.decompress(ChannelHandlerContext ctx, Http2Stream stream, ByteBuf data, int padding, boolean endOfStream)
(package private) DelegatingDecompressorFrameListener.Http2Decompressor	DelegatingDecompressorFrameListener.decompressor(Http2Stream stream)
private void	Http2ConnectionHandler.doCloseStream(Http2Stream stream, ChannelFuture future)
protected void	InboundHttp2ToHttpAdapter.fireChannelRead(ChannelHandlerContext ctx, FullHttpMessage msg, boolean release, Http2Stream stream)	Set final headers and fire a channel read event
protected final FullHttpMessage	InboundHttp2ToHttpAdapter.getMessage(Http2Stream stream)	Get the FullHttpMessage associated with stream.
protected void	Http2ConnectionHandler.handleServerHeaderDecodeSizeError(ChannelHandlerContext ctx, Http2Stream stream)	Notifies client that this server has received headers that are larger than what it is willing to accept.
boolean	DefaultHttp2RemoteFlowController.hasFlowControlled(Http2Stream stream)
boolean	Http2RemoteFlowController.hasFlowControlled(Http2Stream stream)	Determine if stream has any Http2RemoteFlowController.FlowControlled frames currently queued.
void	DefaultHttp2LocalFlowController.incrementWindowSize(Http2Stream stream, int delta)
void	DefaultHttp2RemoteFlowController.incrementWindowSize(Http2Stream stream, int delta)
void	DelegatingDecompressorFrameListener.ConsumedBytesConverter.incrementWindowSize(Http2Stream stream, int delta)
void	Http2FlowController.incrementWindowSize(Http2Stream stream, int delta)	Increments the size of the stream's flow control window by the given delta.
int	DefaultHttp2LocalFlowController.initialWindowSize(Http2Stream stream)
int	DelegatingDecompressorFrameListener.ConsumedBytesConverter.initialWindowSize(Http2Stream stream)
int	Http2LocalFlowController.initialWindowSize(Http2Stream stream)	Get the initial flow control window size for the given stream.
private static boolean	DefaultHttp2LocalFlowController.isClosed(Http2Stream stream)
boolean	DefaultHttp2RemoteFlowController.isWritable(Http2Stream stream)
boolean	Http2RemoteFlowController.isWritable(Http2Stream stream)	Determine if the stream has bytes remaining for use in the flow control window.
protected FullHttpMessage	InboundHttp2ToHttpAdapter.newMessage(Http2Stream stream, Http2Headers headers, boolean validateHttpHeaders, ByteBufAllocator alloc)	Create a new FullHttpMessage based upon the current connection parameters
(package private) void	DefaultHttp2Connection.notifyClosed(Http2Stream stream)
(package private) void	DefaultHttp2Connection.notifyHalfClosed(Http2Stream stream)
private void	Http2FrameCodec.ConnectionListener.onHttp2StreamStateChanged0(Http2Stream stream)
protected void	InboundHttp2ToHttpAdapter.onRstStreamRead(Http2Stream stream, FullHttpMessage msg)	Called if a RST_STREAM is received but we have some data for that stream.
void	Http2Connection.Listener.onStreamActive(Http2Stream stream)	Notifies the listener that the given stream was made active (i.e.
void	Http2ConnectionAdapter.onStreamActive(Http2Stream stream)
void	Http2EventAdapter.onStreamActive(Http2Stream stream)
void	Http2FrameCodec.ConnectionListener.onStreamActive(Http2Stream stream)
private void	Http2FrameCodec.onStreamActive0(Http2Stream stream)
void	Http2Connection.Listener.onStreamAdded(Http2Stream stream)	Notifies the listener that the given stream was added to the connection.
void	Http2ConnectionAdapter.onStreamAdded(Http2Stream stream)
void	Http2EventAdapter.onStreamAdded(Http2Stream stream)
void	Http2FrameCodec.ConnectionListener.onStreamAdded(Http2Stream stream)
void	Http2Connection.Listener.onStreamClosed(Http2Stream stream)	Notifies the listener that the given stream is now CLOSED in both directions and will no longer be accessible via Http2Connection.forEachActiveStream(Http2StreamVisitor).
void	Http2ConnectionAdapter.onStreamClosed(Http2Stream stream)
void	Http2EventAdapter.onStreamClosed(Http2Stream stream)
void	Http2FrameCodec.ConnectionListener.onStreamClosed(Http2Stream stream)
void	Http2Connection.Listener.onStreamHalfClosed(Http2Stream stream)	Notifies the listener that the given stream has transitioned from OPEN to HALF CLOSED.
void	Http2ConnectionAdapter.onStreamHalfClosed(Http2Stream stream)
void	Http2EventAdapter.onStreamHalfClosed(Http2Stream stream)
void	Http2FrameCodec.ConnectionListener.onStreamHalfClosed(Http2Stream stream)
void	Http2Connection.Listener.onStreamRemoved(Http2Stream stream)	Notifies the listener that the given stream has now been removed from the connection and will no longer be returned via Http2Connection.stream(int).
void	Http2ConnectionAdapter.onStreamRemoved(Http2Stream stream)
void	Http2EventAdapter.onStreamRemoved(Http2Stream stream)
void	InboundHttp2ToHttpAdapter.onStreamRemoved(Http2Stream stream)
protected FullHttpMessage	InboundHttp2ToHttpAdapter.processHeadersBegin(ChannelHandlerContext ctx, Http2Stream stream, Http2Headers headers, boolean endOfStream, boolean allowAppend, boolean appendToTrailer)	Provides translation between HTTP/2 and HTTP header objects while ensuring the stream is in a valid state for additional headers.
private void	InboundHttp2ToHttpAdapter.processHeadersEnd(ChannelHandlerContext ctx, Http2Stream stream, FullHttpMessage msg, boolean endOfStream)	After HTTP/2 headers have been processed by InboundHttp2ToHttpAdapter.processHeadersBegin(io.netty.channel.ChannelHandlerContext, io.netty.handler.codec.http2.Http2Stream, io.netty.handler.codec.http2.Http2Headers, boolean, boolean, boolean) this method either sends the result up the pipeline or retains the message for future processing.
private void	Http2ConnectionHandler.processRstStreamWriteResult(ChannelHandlerContext ctx, Http2Stream stream, ChannelFuture future)
protected final void	InboundHttp2ToHttpAdapter.putMessage(Http2Stream stream, FullHttpMessage message)	Make message be the state associated with stream.
void	DefaultHttp2LocalFlowController.receiveFlowControlledFrame(Http2Stream stream, ByteBuf data, int padding, boolean endOfStream)
void	DelegatingDecompressorFrameListener.ConsumedBytesConverter.receiveFlowControlledFrame(Http2Stream stream, ByteBuf data, int padding, boolean endOfStream)
void	Http2LocalFlowController.receiveFlowControlledFrame(Http2Stream stream, ByteBuf data, int padding, boolean endOfStream)	Receives an inbound DATA frame from the remote endpoint and applies flow control policies to it for both the stream as well as the connection.
protected final void	InboundHttp2ToHttpAdapter.removeMessage(Http2Stream stream, boolean release)	The stream is out of scope for the HTTP message flow and will no longer be tracked
DefaultHttp2Connection.DefaultStream	DefaultHttp2Connection.DefaultEndpoint.reservePushStream(int streamId, Http2Stream parent)
Http2Stream	Http2Connection.Endpoint.reservePushStream(int streamId, Http2Stream parent)	Creates a push stream in the reserved state for this endpoint and notifies all listeners.
private ChannelFuture	Http2ConnectionHandler.resetStream(ChannelHandlerContext ctx, Http2Stream stream, long errorCode, ChannelPromise promise)
(package private) Http2FrameCodec.DefaultHttp2FrameStream	Http2FrameCodec.DefaultHttp2FrameStream.setStreamAndProperty(Http2Connection.PropertyKey streamKey, Http2Stream stream)
private boolean	DefaultHttp2ConnectionDecoder.FrameReadListener.shouldIgnoreHeadersOrDataFrame(ChannelHandlerContext ctx, int streamId, Http2Stream stream, boolean endOfStream, String frameName)	Helper method to determine if a frame that has the semantics of headers or data should be ignored for the stream (which may be null) associated with streamId.
private DefaultHttp2LocalFlowController.FlowState	DefaultHttp2LocalFlowController.state(Http2Stream stream)
private DefaultHttp2RemoteFlowController.FlowState	DefaultHttp2RemoteFlowController.state(Http2Stream stream)
private UniformStreamByteDistributor.State	UniformStreamByteDistributor.state(Http2Stream stream)
private WeightedFairQueueByteDistributor.State	WeightedFairQueueByteDistributor.state(Http2Stream stream)
private int	DefaultHttp2ConnectionDecoder.unconsumedBytes(Http2Stream stream)
int	DefaultHttp2LocalFlowController.unconsumedBytes(Http2Stream stream)
int	DelegatingDecompressorFrameListener.ConsumedBytesConverter.unconsumedBytes(Http2Stream stream)
int	Http2LocalFlowController.unconsumedBytes(Http2Stream stream)	The number of bytes for the given stream that have been received but not yet consumed by the application.
private static boolean	DefaultHttp2ConnectionEncoder.validateHeadersSentState(Http2Stream stream, Http2Headers headers, boolean isServer, boolean endOfStream)
private void	DefaultHttp2ConnectionDecoder.verifyContentLength(Http2Stream stream, int data, boolean isEnd)
boolean	DefaultHttp2LocalFlowController.WindowUpdateVisitor.visit(Http2Stream stream)
boolean	DefaultHttp2RemoteFlowController.ListenerWritabilityMonitor.visit(Http2Stream stream)
boolean	Http2StreamVisitor.visit(Http2Stream stream)
int	DefaultHttp2LocalFlowController.windowSize(Http2Stream stream)
int	DefaultHttp2RemoteFlowController.windowSize(Http2Stream stream)
int	DelegatingDecompressorFrameListener.ConsumedBytesConverter.windowSize(Http2Stream stream)
int	Http2FlowController.windowSize(Http2Stream stream)	Get the portion of the flow control window for the given stream that is currently available for sending/receiving frames which are subject to flow control.
float	DefaultHttp2LocalFlowController.windowUpdateRatio(Http2Stream stream)	The window update ratio is used to determine when a window update must be sent.
void	DefaultHttp2LocalFlowController.windowUpdateRatio(Http2Stream stream, float ratio)	The window update ratio is used to determine when a window update must be sent.
void	Http2FrameCodec.Http2RemoteFlowControllerListener.writabilityChanged(Http2Stream stream)
void	Http2RemoteFlowController.Listener.writabilityChanged(Http2Stream stream)	Notification that Http2RemoteFlowController.isWritable(Http2Stream) has changed for stream.
final void	DefaultHttp2RemoteFlowController.WritabilityMonitor.write(Http2Stream stream, int numBytes)
void	StreamByteDistributor.Writer.write(Http2Stream stream, int numBytes)	Writes the allocated bytes for this stream.

Constructors in io.netty.handler.codec.http2 with parameters of type Http2Stream

Modifier	Constructor	Description
(package private)	AutoRefillState(Http2Stream stream, int initialWindowSize)
(package private)	DefaultState(Http2Stream stream, int initialWindowSize)
(package private)	FlowControlledBase(Http2Stream stream, int padding, boolean endOfStream, ChannelPromise promise)
(package private)	FlowControlledData(Http2Stream stream, ByteBuf buf, int padding, boolean endOfStream, ChannelPromise promise)
(package private)	FlowControlledHeaders(Http2Stream stream, Http2Headers headers, boolean hasPriority, int streamDependency, short weight, boolean exclusive, int padding, boolean endOfStream, ChannelPromise promise)
(package private)	FlowState(Http2Stream stream)
(package private)	State(Http2Stream stream)
(package private)	State(int streamId, Http2Stream stream, int initialSize)
(package private)	State(Http2Stream stream)
(package private)	State(Http2Stream stream, int initialSize)