Go to the documentation of this file.
19 #ifndef GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
20 #define GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
37 class ClientAsyncResponseReader;
92 template <
class R,
class W,
class BaseR = R,
class BaseW = W>
101 SetupRequest<BaseR, BaseW>(
102 call.
call(), &result->single_buf_, &result->read_initial_metadata_,
103 &result->finish_,
static_cast<const BaseW&
>(request));
110 template <
class R,
class W>
116 read_initial_metadata,
122 using SingleBufType =
129 SingleBufType* single_buf =
131 *single_buf_ptr = single_buf;
133 GPR_ASSERT(single_buf->SendMessage(request).ok());
134 single_buf->ClientSendClose();
141 *read_initial_metadata =
144 auto* single_buf =
static_cast<SingleBufType*
>(single_buf_view);
145 single_buf->set_output_tag(tag);
146 single_buf->RecvInitialMetadata(context);
147 call->PerformOps(single_buf);
158 bool initial_metadata_read,
161 Status* status,
void* tag) {
162 if (initial_metadata_read) {
163 using FinishBufType =
166 FinishBufType* finish_buf =
169 *finish_buf_ptr = finish_buf;
170 finish_buf->set_output_tag(tag);
171 finish_buf->RecvMessage(
static_cast<R*
>(msg));
172 finish_buf->AllowNoMessage();
174 call->PerformOps(finish_buf);
176 auto* single_buf =
static_cast<SingleBufType*
>(single_buf_view);
177 single_buf->set_output_tag(tag);
178 single_buf->RecvInitialMetadata(context);
179 single_buf->RecvMessage(
static_cast<R*
>(msg));
180 single_buf->AllowNoMessage();
181 single_buf->ClientRecvStatus(context, status);
182 call->PerformOps(single_buf);
190 context->initial_metadata_flags());
203 const W& request,
bool start) {
204 auto* result = ClientAsyncResponseReaderHelper::Create<R>(
205 channel, cq, method, context, request);
218 class ClientAsyncResponseReader final
219 :
public ClientAsyncResponseReaderInterface<R> {
222 static void operator delete(
void* , std::size_t size) {
231 static void operator delete(
void*,
void*) {
GPR_ASSERT(
false); }
248 read_initial_metadata_(context_, &call_, single_buf_, tag);
249 initial_metadata_read_ =
true;
259 finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_,
260 static_cast<void*
>(msg), status, tag);
267 bool started_ =
false;
268 bool initial_metadata_read_ =
false;
272 : context_(context), call_(call) {}
275 static void*
operator new(std::size_t size);
276 static void*
operator new(std::size_t ,
void* p) {
return p; }
278 internal::CallOpSendInitialMetadata* single_buf_;
279 internal::CallOpSetInterface* finish_buf_ =
nullptr;
280 std::function<void(ClientContext*, internal::Call*,
281 internal::CallOpSendInitialMetadata*,
void*)>
282 read_initial_metadata_;
283 std::function<void(ClientContext*, internal::Call*,
284 bool initial_metadata_read,
285 internal::CallOpSendInitialMetadata*,
286 internal::CallOpSetInterface**,
void*,
Status*,
void*)>
293 class ServerAsyncResponseWriter final
297 : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
310 meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
311 ctx_->initial_metadata_flags());
315 ctx_->sent_initial_metadata_ =
true;
341 if (!ctx_->sent_initial_metadata_) {
342 finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
343 ctx_->initial_metadata_flags());
347 ctx_->sent_initial_metadata_ =
true;
351 finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_,
352 finish_buf_.SendMessage(msg));
354 finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
378 if (!ctx_->sent_initial_metadata_) {
379 finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
380 ctx_->initial_metadata_flags());
384 ctx_->sent_initial_metadata_ =
true;
386 finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
407 class default_delete<
grpc::ClientAsyncResponseReader<R>> {
412 class default_delete<
grpc::ClientAsyncResponseReaderInterface<R>> {
418 #endif // GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
void StartCall() override
Definition: async_unary_call.h:233
Definition: service_type.h:37
Definition: call_op_set.h:619
GRPCAPI void * grpc_call_arena_alloc(grpc_call *call, size_t size)
Allocate memory in the grpc_call arena: this memory is automatically discarded at call completion.
A ServerContext or CallbackServerContext allows the code implementing a service handler to:
Definition: server_context.h:571
Definition: call_op_set.h:654
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:32
Primary implementation of CallOpSetInterface.
Definition: completion_queue.h:96
#define GPR_DEBUG_ASSERT(x)
Definition: log.h:103
Definition: call_op_set.h:286
static ClientAsyncResponseReader< R > * Create(grpc::ChannelInterface *channel, grpc::CompletionQueue *cq, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, const W &request)
Start a call and write the request out if start is set.
Definition: async_unary_call.h:93
Definition: async_unary_call.h:197
Straightforward wrapping of the C call object.
Definition: call.h:36
#define GPR_ASSERT(x)
abort() the process if x is zero, having written a line to the log.
Definition: log.h:95
bool ok() const
Is the status OK?
Definition: status.h:126
void Finish(const W &msg, const grpc::Status &status, void *tag)
Indicate that the stream is to be finished and request notification when the server has sent the appr...
Definition: async_unary_call.h:338
void operator()(void *)
Definition: async_unary_call.h:409
virtual void Finish(R *msg, grpc::Status *status, void *tag)=0
Request to receive the server's response msg and final status for the call, and to notify tag on this...
Did it work? If it didn't, why?
Definition: status.h:35
An interface relevant for async client side unary RPCs (which send one request message to a server an...
Definition: async_unary_call.h:42
virtual void StartCall()=0
Start the call that was set up by the constructor, but only if the constructor was invoked through th...
virtual void ReadInitialMetadata(void *tag)=0
Request notification of the reading of initial metadata.
grpc_compression_level compression_level() const
Return the compression algorithm to be used by the server call.
Definition: server_context.h:234
void ClientRecvStatus(grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:774
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
Async API for client-side unary RPCs, where the message response received from the server is of type ...
Definition: client_context.h:91
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:69
void operator()(void *)
Definition: async_unary_call.h:414
An abstract collection of call ops, used to generate the grpc_call_op structure to pass down to the l...
Definition: call_op_set_interface.h:36
ServerAsyncResponseWriter(grpc::ServerContext *ctx)
Definition: async_unary_call.h:296
Codegen interface for grpc::Channel.
Definition: channel_interface.h:71
void FinishWithError(const grpc::Status &status, void *tag)
Indicate that the stream is to be finished with a non-OK status, and request notification for when th...
Definition: async_unary_call.h:375
Definition: async_unary_call.h:78
static void SetupRequest(grpc_call *call, grpc::internal::CallOpSendInitialMetadata **single_buf_ptr, std::function< void(ClientContext *, internal::Call *, internal::CallOpSendInitialMetadata *, void *)> *read_initial_metadata, std::function< void(ClientContext *, internal::Call *, bool initial_metadata_read, internal::CallOpSendInitialMetadata *, internal::CallOpSetInterface **, void *, Status *, void *)> *finish, const W &request)
Definition: async_unary_call.h:111
virtual ~ClientAsyncResponseReaderInterface()
Definition: async_unary_call.h:44
::google::protobuf::util::Status Status
Definition: config_protobuf.h:93
void Finish(R *msg, grpc::Status *status, void *tag) override
See ClientAsyncResponseReaderInterface::Finish for semantics.
Definition: async_unary_call.h:257
void ReadInitialMetadata(void *tag) override
See ClientAsyncResponseReaderInterface::ReadInitialMetadata for semantics.
Definition: async_unary_call.h:245
void set_output_tag(void *return_tag)
Definition: call_op_set.h:935
static ClientAsyncResponseReader< R > * Create(grpc::ChannelInterface *channel, grpc::CompletionQueue *cq, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, const W &request, bool start)
Definition: async_unary_call.h:200
static void StartCall(grpc::ClientContext *context, grpc::internal::CallOpSendInitialMetadata *single_buf)
Definition: async_unary_call.h:187
void SendInitialMetadata(void *tag) override
See ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
Definition: async_unary_call.h:306
void PerformOps(CallOpSetInterface *ops)
Definition: call.h:66
grpc_call * call() const
Definition: call.h:70
Definition: async_unary_call.h:405
bool compression_level_set() const
Return a bool indicating whether the compression level for this call has been set (either implicitly ...
Definition: server_context.h:249
Definition: call_op_set.h:769
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:103
Definition: call_op_set.h:424
Descriptor of an RPC method.
Definition: rpc_method.h:29
void set_core_cq_tag(void *core_cq_tag)
set_core_cq_tag is used to provide a different core CQ tag than "this".
Definition: call_op_set.h:943