io.grpc

Class ForwardingCall<ReqT,RespT>

java.lang.Object

io.grpc.Call<ReqT,RespT>

io.grpc.ForwardingCall<ReqT,RespT>

Direct Known Subclasses:

ClientInterceptors.CheckedForwardingCall, ForwardingCall.SimpleForwardingCall

public abstract class ForwardingCall<ReqT,RespT>
extends Call<ReqT,RespT>

A Call which forwards all of it's methods to another Call.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ForwardingCall.SimpleForwardingCall<ReqT,RespT> A simplified version of ForwardingCall where subclasses can pass in a Call as the delegate.

Nested classes/interfaces inherited from class io.grpc.Call

Call.Listener<T>

Constructor Summary

Constructors

Constructor and Description
ForwardingCall()

Method Summary

Modifier and Type	Method and Description
void	cancel() Prevent any further processing for this Call.
protected abstract Call<ReqT,RespT>	delegate() Returns the delegated Call.
void	halfClose() Close the call for request message sending.
boolean	isReady() If true, indicates that the call is capable of sending additional messages without requiring excessive buffering internally.
void	request(int numMessages) Requests up to the given number of messages from the call to be delivered to Call.Listener.onPayload(Object).
void	sendPayload(ReqT payload) Send a request message to the server.
void	start(Call.Listener<RespT> responseListener, Metadata.Headers headers) Start a call, using responseListener for processing response messages.

Methods inherited from class java.lang.Object

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

Constructor Detail

ForwardingCall

public ForwardingCall()

Method Detail

delegate

protected abstract Call<ReqT,RespT> delegate()

Returns the delegated Call.

start

public void start(Call.Listener<RespT> responseListener,
                  Metadata.Headers headers)

Description copied from class: Call

Start a call, using responseListener for processing response messages.

Specified by:

start in class Call<ReqT,RespT>

Parameters:

responseListener - receives response messages

headers - which can contain extra call metadata, e.g. authentication credentials.

request

public void request(int numMessages)

Description copied from class: Call

Requests up to the given number of messages from the call to be delivered to Call.Listener.onPayload(Object). No additional messages will be delivered.

Message delivery is guaranteed to be sequential in the order received. In addition, the listener methods will not be accessed concurrently. While it is not guaranteed that the same thread will always be used, it is guaranteed that only a single thread will access the listener at a time.

If it is desired to bypass inbound flow control, a very large number of messages can be specified (e.g. Integer.MAX_VALUE).

Specified by:

request in class Call<ReqT,RespT>

Parameters:

numMessages - the requested number of messages to be delivered to the listener.

cancel

public void cancel()

Description copied from class: Call

Prevent any further processing for this Call. No further messages may be sent or will be received. The server is informed of cancellations, but may not stop processing the call. Cancellation is permitted even if previously cancel()ed or Call.halfClose()d.

Specified by:

cancel in class Call<ReqT,RespT>

halfClose

public void halfClose()

Description copied from class: Call

Close the call for request message sending. Incoming response messages are unaffected.

Specified by:

halfClose in class Call<ReqT,RespT>

sendPayload

public void sendPayload(ReqT payload)

Description copied from class: Call

Send a request message to the server. May be called zero or more times depending on how many messages the server is willing to accept for the operation.

Specified by:

sendPayload in class Call<ReqT,RespT>

Parameters:

payload - message to be sent to the server.

isReady

public boolean isReady()

Description copied from class: Call

If true, indicates that the call is capable of sending additional messages without requiring excessive buffering internally. This event is just a suggestion and the application is free to ignore it, however doing so may result in excessive buffering within the call.

This implementation always returns true.

Overrides:

isReady in class Call<ReqT,RespT>