ClientCall (grpc-all 0.8.0 API)

java.lang.Object
- io.grpc.ClientCall<RequestT,ResponseT>

Type Parameters:

RequestT - type of message sent one or more times to the server.

ResponseT - type of message received one or more times from the server.

Direct Known Subclasses:

ForwardingClientCall
```
public abstract class ClientCall<RequestT,ResponseT>
extends Object
```
An instance of a call to to a remote method. A call will send zero or more request messages to the server and receive zero or more response messages back.
Instances are created by a Channel and used by stubs to invoke their remote behavior.
More advanced usages may consume this interface directly as opposed to using a stub. Common reasons for doing so would be the need to interact with flow-control or when acting as a generic proxy for arbitrary operations.
start(io.grpc.ClientCall.Listener<ResponseT>, io.grpc.Metadata.Headers) must be called prior to calling any other methods.
No generic method for determining message receipt or providing acknowledgement is provided. Applications are expected to utilize normal payload messages for such signals, as a response naturally acknowledges its request.
Methods are guaranteed to be non-blocking. Implementations are not required to be thread-safe.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ClientCall.Listener<T>
Callbacks for receiving metadata, response messages and completion status from the server.

Nested Classes
Modifier and Type	Class and Description
`static class`	`ClientCall.Listener<T>` Callbacks for receiving metadata, response messages and completion status from the server.

Constructor Summary

Constructors
Constructor and Description

ClientCall()

Constructors
Constructor and Description
`ClientCall()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract void`	`cancel()` Prevent any further processing for this ClientCall.
`abstract 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.
`abstract void`	`request(int numMessages)` Requests up to the given number of messages from the call to be delivered to `ClientCall.Listener.onMessage(Object)`.
`abstract void`	`sendMessage(RequestT message)` Send a request message to the server.
`abstract void`	`start(ClientCall.Listener<ResponseT> 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
  - ClientCall
```
public ClientCall()
```
- Method Detail
  - start
```
public abstract void start(ClientCall.Listener<ResponseT> responseListener,
                           Metadata.Headers headers)
```
    Start a call, using responseListener for processing response messages.
    
    Parameters:
    
    responseListener - receives response messages
    
    headers - which can contain extra call metadata, e.g. authentication credentials.
    
    Throws:
    
    IllegalStateException - if call is already started
  - request
```
public abstract void request(int numMessages)
```
    Requests up to the given number of messages from the call to be delivered to ClientCall.Listener.onMessage(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).
    
    Parameters:
    
    numMessages - the requested number of messages to be delivered to the listener.
  - cancel
```
public abstract void cancel()
```
    Prevent any further processing for this ClientCall. 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 halfClose()d.
  - halfClose
```
public abstract void halfClose()
```
    Close the call for request message sending. Incoming response messages are unaffected.
    
    Throws:
    
    IllegalStateException - if call is already halfClose()d or cancel()ed
  - sendMessage
```
public abstract void sendMessage(RequestT message)
```
    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.
    
    Parameters:
    
    message - message to be sent to the server.
    
    Throws:
    
    IllegalStateException - if call is halfClose()d or explicitly cancel()ed
  - isReady
```
public boolean isReady()
```
    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.

Class ClientCall<RequestT,ResponseT>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ClientCall

Method Detail

start

request

cancel

halfClose

sendMessage

isReady