18 #ifndef GRPCPP_IMPL_CODEGEN_CLIENT_CALLBACK_IMPL_H
19 #define GRPCPP_IMPL_CODEGEN_CLIENT_CALLBACK_IMPL_H
45 template <
class InputMessage,
class OutputMessage>
47 const ::grpc::internal::RpcMethod& method,
49 const InputMessage* request, OutputMessage* result,
52 channel, method, context, request, result, on_completion);
55 template <
class InputMessage,
class OutputMessage>
59 const ::grpc::internal::RpcMethod& method,
61 const InputMessage* request, OutputMessage* result,
79 const size_t alloc_sz =
sizeof(OpSetAndTag);
80 auto*
const alloced =
static_cast<OpSetAndTag*
>(
83 auto* ops =
new (&alloced->opset) FullCallOpSet;
84 auto* tag =
new (&alloced->tag)
93 ops->SendInitialMetadata(&context->send_initial_metadata_,
94 context->initial_metadata_flags());
95 ops->RecvInitialMetadata(context);
96 ops->RecvMessage(result);
97 ops->AllowNoMessage();
98 ops->ClientSendClose();
99 ops->ClientRecvStatus(context, tag->status_ptr());
100 ops->set_core_cq_tag(tag);
107 template <
class Request,
class Response>
109 template <
class Response>
111 template <
class Request>
118 template <
class Request,
class Response>
125 virtual void Read(Response* resp) = 0;
131 reactor->BindStream(
this);
135 template <
class Response>
140 virtual void Read(Response* resp) = 0;
146 reactor->BindReader(
this);
150 template <
class Request>
167 reactor->BindWriter(
this);
191 template <
class Request,
class Response>
226 stream_->Write(req, std::move(options));
319 template <
class Response>
343 template <
class Request>
353 writer_->Write(req, std::move(options));
402 reactor->BindCall(
this);
408 template <
class Request,
class Response>
409 class ClientCallbackReaderWriterFactory;
410 template <
class Response>
411 class ClientCallbackReaderFactory;
412 template <
class Request>
413 class ClientCallbackWriterFactory;
415 template <
class Request,
class Response>
420 static void operator delete(
void* , std::size_t size) {
433 1, std::memory_order_acq_rel) == 1)) {
435 auto* reactor = reactor_;
436 auto* call = call_.
call();
453 reactor_->OnReadInitialMetadataDone(ok);
457 if (!start_corked_) {
459 context_->initial_metadata_flags());
469 reactor_->OnWriteDone(ok);
477 reactor_->OnReadDone(ok);
482 if (read_ops_at_start_) {
486 if (write_ops_at_start_) {
490 if (writes_done_ops_at_start_) {
494 finish_tag_.
Set(call_.
call(), [
this](
bool ) { MaybeFinish(); },
495 &finish_ops_,
false);
501 void Read(Response* msg)
override {
503 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
507 read_ops_at_start_ =
true;
514 context_->initial_metadata_flags());
515 start_corked_ =
false;
524 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
528 write_ops_at_start_ =
true;
534 context_->initial_metadata_flags());
535 start_corked_ =
false;
538 writes_done_tag_.
Set(call_.
call(),
540 reactor_->OnWritesDoneDone(ok);
543 &writes_done_ops_,
false);
545 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
549 writes_done_ops_at_start_ =
true;
554 callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
567 start_corked_(context_->initial_metadata_corked_) {
590 bool write_ops_at_start_{
false};
596 bool writes_done_ops_at_start_{
false};
601 bool read_ops_at_start_{
false};
604 std::atomic<intptr_t> callbacks_outstanding_{2};
605 bool started_{
false};
608 template <
class Request,
class Response>
612 const ::grpc::internal::RpcMethod& method,
616 channel->CreateCall(method, context, channel->CallbackCQ());
626 template <
class Response>
630 static void operator delete(
void* , std::size_t size) {
643 1, std::memory_order_acq_rel) == 1)) {
645 auto* reactor = reactor_;
646 auto* call = call_.
call();
662 reactor_->OnReadInitialMetadataDone(ok);
667 context_->initial_metadata_flags());
675 reactor_->OnReadDone(ok);
680 if (read_ops_at_start_) {
684 finish_tag_.
Set(call_.
call(), [
this](
bool ) { MaybeFinish(); },
685 &finish_ops_,
false);
691 void Read(Response* msg)
override {
693 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
697 read_ops_at_start_ =
true;
702 callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
709 template <
class Request>
714 : context_(context), call_(call), reactor_(reactor) {
739 bool read_ops_at_start_{
false};
742 std::atomic<intptr_t> callbacks_outstanding_{2};
743 bool started_{
false};
746 template <
class Response>
749 template <
class Request>
751 const ::grpc::internal::RpcMethod& method,
753 const Request* request,
756 channel->CreateCall(method, context, channel->CallbackCQ());
765 template <
class Request>
769 static void operator delete(
void* , std::size_t size) {
782 1, std::memory_order_acq_rel) == 1)) {
784 auto* reactor = reactor_;
785 auto* call = call_.
call();
801 reactor_->OnReadInitialMetadataDone(ok);
805 if (!start_corked_) {
807 context_->initial_metadata_flags());
817 reactor_->OnWriteDone(ok);
823 if (write_ops_at_start_) {
827 if (writes_done_ops_at_start_) {
831 finish_tag_.
Set(call_.
call(), [
this](
bool ) { MaybeFinish(); },
832 &finish_ops_,
false);
841 context_->initial_metadata_flags());
842 start_corked_ =
false;
851 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
855 write_ops_at_start_ =
true;
861 context_->initial_metadata_flags());
862 start_corked_ =
false;
865 writes_done_tag_.
Set(call_.
call(),
867 reactor_->OnWritesDoneDone(ok);
870 &writes_done_ops_,
false);
872 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
876 writes_done_ops_at_start_ =
true;
881 callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
888 template <
class Response>
896 start_corked_(context_->initial_metadata_corked_) {
923 bool write_ops_at_start_{
false};
929 bool writes_done_ops_at_start_{
false};
932 std::atomic<intptr_t> callbacks_outstanding_{2};
933 bool started_{
false};
936 template <
class Request>
939 template <
class Response>
941 const ::grpc::internal::RpcMethod& method,
945 channel->CreateCall(method, context, channel->CallbackCQ());
957 static void operator delete(
void* , std::size_t size) {
976 reactor_->OnReadInitialMetadataDone(ok);
981 context_->initial_metadata_flags());
986 finish_tag_.
Set(call_.
call(), [
this](
bool ) { MaybeFinish(); },
987 &finish_ops_,
false);
995 1, std::memory_order_acq_rel) == 1)) {
997 auto* reactor = reactor_;
998 auto* call = call_.
call();
1008 template <
class Request,
class Response>
1012 : context_(context), call_(call), reactor_(reactor) {
1039 std::atomic<intptr_t> callbacks_outstanding_{2};
1040 bool started_{
false};
1045 template <
class Request,
class Response>
1047 const ::grpc::internal::RpcMethod& method,
1049 const Request* request, Response* response,
1052 channel->CreateCall(method, context, channel->CallbackCQ());
Codegen interface for grpc::Channel.
Definition: channel_interface.h:74
virtual void grpc_call_unref(grpc_call *call)=0
virtual void grpc_call_ref(grpc_call *call)=0
virtual void * grpc_call_arena_alloc(grpc_call *call, size_t length)=0
Did it work? If it didn't, why?
Definition: status.h:31
bool ok() const
Is the status OK?
Definition: status.h:118
Per-message write options.
Definition: call_op_set.h:79
bool is_last_message() const
Get value for the flag indicating that this is the last message, and should be coalesced with trailin...
Definition: call_op_set.h:186
WriteOptions & set_last_message()
last-message bit: indicates this is the last message in a stream client-side: makes Write the equival...
Definition: call_op_set.h:161
WriteOptions & set_buffer_hint()
Sets flag indicating that the write may be buffered and need not go out on the wire immediately.
Definition: call_op_set.h:122
Straightforward wrapping of the C call object.
Definition: call.h:38
grpc_call * call() const
Definition: call.h:72
void PerformOps(CallOpSetInterface *ops)
Definition: call.h:68
Definition: call_op_set.h:742
void ClientRecvStatus(::grpc_impl::ClientContext *context, Status *status)
Definition: call_op_set.h:747
Definition: call_op_set.h:592
void ClientSendClose()
Definition: call_op_set.h:596
Definition: call_op_set.h:514
void RecvMessage(R *message)
Definition: call_op_set.h:520
void AllowNoMessage()
Definition: call_op_set.h:529
Definition: call_op_set.h:422
void RecvMessage(R *message)
Definition: call_op_set.h:429
Definition: call_op_set.h:286
Status SendMessagePtr(const M *message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:409
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:839
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:913
Definition: callback_common.h:69
CallbackWithSuccessTag can be reused multiple times, and will be used in this fashion for streaming o...
Definition: callback_common.h:137
void Set(grpc_call *call, std::function< void(bool)> f, CompletionQueueTag *ops, bool can_inline)
Definition: callback_common.h:169
ClientBidiReactor is the interface for a bidirectional streaming RPC.
Definition: client_callback_impl.h:192
void StartWriteLast(const Request *req, ::grpc::WriteOptions options)
Initiate/post a write operation with specified options and an indication that this is the last write ...
Definition: client_callback_impl.h:238
void RemoveHold()
Definition: client_callback_impl.h:272
virtual void OnReadDone(bool)
Notifies the application that a StartRead operation completed.
Definition: client_callback_impl.h:293
void StartCall()
Activate the RPC and initiate any reads or writes that have been Start'ed before this call.
Definition: client_callback_impl.h:200
virtual ~ClientBidiReactor()
Definition: client_callback_impl.h:194
virtual void OnWriteDone(bool)
Notifies the application that a StartWrite operation completed.
Definition: client_callback_impl.h:299
friend class ClientCallbackReaderWriter< Request, Response >
Definition: client_callback_impl.h:310
void StartWrite(const Request *req, ::grpc::WriteOptions options)
Initiate/post a write operation with specified options.
Definition: client_callback_impl.h:225
void StartWrite(const Request *req)
Initiate a write operation (or post it for later initiation if StartCall has not yet been invoked).
Definition: client_callback_impl.h:215
void AddHold()
Holds are needed if (and only if) this stream has operations that take place on it after StartCall bu...
Definition: client_callback_impl.h:270
void StartRead(Response *resp)
Initiate a read operation (or post it for later initiation if StartCall has not yet been invoked).
Definition: client_callback_impl.h:207
void AddMultipleHolds(int holds)
Definition: client_callback_impl.h:271
virtual void OnDone(const ::grpc::Status &)
Notifies the application that all operations associated with this RPC have completed and provides the...
Definition: client_callback_impl.h:278
virtual void OnReadInitialMetadataDone(bool)
Notifies the application that a read of initial metadata from the server is done.
Definition: client_callback_impl.h:287
void StartWritesDone()
Indicate that the RPC will have no more write operations.
Definition: client_callback_impl.h:247
virtual void OnWritesDoneDone(bool)
Notifies the application that a StartWritesDone operation completed.
Definition: client_callback_impl.h:307
Definition: client_callback_impl.h:136
virtual void StartCall()=0
virtual void RemoveHold()=0
virtual void AddHold(int holds)=0
virtual ~ClientCallbackReader()
Definition: client_callback_impl.h:138
virtual void Read(Response *resp)=0
void BindReactor(ClientReadReactor< Response > *reactor)
Definition: client_callback_impl.h:145
Definition: client_callback_impl.h:119
void BindReactor(ClientBidiReactor< Request, Response > *reactor)
Definition: client_callback_impl.h:130
virtual void Read(Response *resp)=0
virtual ~ClientCallbackReaderWriter()
Definition: client_callback_impl.h:121
virtual void Write(const Request *req, ::grpc::WriteOptions options)=0
virtual void StartCall()=0
virtual void RemoveHold()=0
virtual void WritesDone()=0
virtual void AddHold(int holds)=0
Definition: client_callback_impl.h:171
virtual ~ClientCallbackUnary()
Definition: client_callback_impl.h:173
void BindReactor(ClientUnaryReactor *reactor)
Definition: client_callback_impl.h:401
virtual void StartCall()=0
Definition: client_callback_impl.h:151
virtual void StartCall()=0
void WriteLast(const Request *req, ::grpc::WriteOptions options)
Definition: client_callback_impl.h:157
virtual void Write(const Request *req, ::grpc::WriteOptions options)=0
virtual void RemoveHold()=0
virtual ~ClientCallbackWriter()
Definition: client_callback_impl.h:153
virtual void WritesDone()=0
virtual void AddHold(int holds)=0
void Write(const Request *req)
Definition: client_callback_impl.h:155
void BindReactor(ClientWriteReactor< Request > *reactor)
Definition: client_callback_impl.h:166
A ClientContext allows the person implementing a service client to:
Definition: client_context_impl.h:184
ClientReadReactor is the interface for a server-streaming RPC.
Definition: client_callback_impl.h:320
virtual void OnReadInitialMetadataDone(bool)
Definition: client_callback_impl.h:332
void RemoveHold()
Definition: client_callback_impl.h:329
virtual void OnReadDone(bool)
Definition: client_callback_impl.h:333
void AddMultipleHolds(int holds)
Definition: client_callback_impl.h:328
void StartRead(Response *resp)
Definition: client_callback_impl.h:325
void StartCall()
Definition: client_callback_impl.h:324
virtual void OnDone(const ::grpc::Status &)
Definition: client_callback_impl.h:331
void AddHold()
Definition: client_callback_impl.h:327
virtual ~ClientReadReactor()
Definition: client_callback_impl.h:322
friend class ClientCallbackReader< Response >
Definition: client_callback_impl.h:336
ClientUnaryReactor is a reactor-style interface for a unary RPC.
Definition: client_callback_impl.h:386
virtual ~ClientUnaryReactor()
Definition: client_callback_impl.h:388
void StartCall()
Definition: client_callback_impl.h:390
virtual void OnReadInitialMetadataDone(bool)
Definition: client_callback_impl.h:392
virtual void OnDone(const ::grpc::Status &)
Definition: client_callback_impl.h:391
ClientWriteReactor is the interface for a client-streaming RPC.
Definition: client_callback_impl.h:344
virtual void OnReadInitialMetadataDone(bool)
Definition: client_callback_impl.h:365
void StartWriteLast(const Request *req, ::grpc::WriteOptions options)
Definition: client_callback_impl.h:355
virtual void OnWritesDoneDone(bool)
Definition: client_callback_impl.h:367
virtual void OnWriteDone(bool)
Definition: client_callback_impl.h:366
friend class ClientCallbackWriter< Request >
Definition: client_callback_impl.h:370
virtual ~ClientWriteReactor()
Definition: client_callback_impl.h:346
void RemoveHold()
Definition: client_callback_impl.h:362
virtual void OnDone(const ::grpc::Status &)
Definition: client_callback_impl.h:364
void AddMultipleHolds(int holds)
Definition: client_callback_impl.h:361
void StartCall()
Definition: client_callback_impl.h:348
void AddHold()
Definition: client_callback_impl.h:360
void StartWritesDone()
Definition: client_callback_impl.h:358
void StartWrite(const Request *req, ::grpc::WriteOptions options)
Definition: client_callback_impl.h:352
void StartWrite(const Request *req)
Definition: client_callback_impl.h:349
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue_impl.h:100
Definition: client_callback_impl.h:56
CallbackUnaryCallImpl(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc_impl::ClientContext *context, const InputMessage *request, OutputMessage *result, std::function< void(::grpc::Status)> on_completion)
Definition: client_callback_impl.h:58
Definition: client_callback_impl.h:747
static void Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc_impl::ClientContext *context, const Request *request, ClientReadReactor< Response > *reactor)
Definition: client_callback_impl.h:750
Definition: client_callback_impl.h:627
void AddHold(int holds) override
Definition: client_callback_impl.h:701
void RemoveHold() override
Definition: client_callback_impl.h:704
void Read(Response *msg) override
Definition: client_callback_impl.h:691
void StartCall() override
Definition: client_callback_impl.h:653
void MaybeFinish()
Definition: client_callback_impl.h:641
Definition: client_callback_impl.h:609
static void Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc_impl::ClientContext *context, ClientBidiReactor< Request, Response > *reactor)
Definition: client_callback_impl.h:611
Definition: client_callback_impl.h:417
void MaybeFinish()
Definition: client_callback_impl.h:431
void WritesDone() override
Definition: client_callback_impl.h:531
void RemoveHold() override
Definition: client_callback_impl.h:556
void Write(const Request *msg, ::grpc::WriteOptions options) override
Definition: client_callback_impl.h:511
void Read(Response *msg) override
Definition: client_callback_impl.h:501
void AddHold(int holds) override
Definition: client_callback_impl.h:553
void StartCall() override
Definition: client_callback_impl.h:443
Definition: client_callback_impl.h:1043
static void Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc_impl::ClientContext *context, const Request *request, Response *response, ClientUnaryReactor *reactor)
Definition: client_callback_impl.h:1046
Definition: client_callback_impl.h:954
void StartCall() override
Definition: client_callback_impl.h:968
void MaybeFinish()
Definition: client_callback_impl.h:993
Definition: client_callback_impl.h:937
static void Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc_impl::ClientContext *context, Response *response, ClientWriteReactor< Request > *reactor)
Definition: client_callback_impl.h:940
Definition: client_callback_impl.h:766
void AddHold(int holds) override
Definition: client_callback_impl.h:880
void Write(const Request *msg, ::grpc::WriteOptions options) override
Definition: client_callback_impl.h:838
void WritesDone() override
Definition: client_callback_impl.h:858
void RemoveHold() override
Definition: client_callback_impl.h:883
void StartCall() override
Definition: client_callback_impl.h:792
void MaybeFinish()
Definition: client_callback_impl.h:780
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
::grpc_impl::ClientUnaryReactor ClientUnaryReactor
Definition: client_callback.h:46
::grpc_impl::ClientWriteReactor< Request > ClientWriteReactor
Definition: client_callback.h:41
::grpc_impl::ClientBidiReactor< Request, Response > ClientBidiReactor
Definition: client_callback.h:44
::grpc_impl::ClientReadReactor< Response > ClientReadReactor
Definition: client_callback.h:38
::google::protobuf::util::Status Status
Definition: config_protobuf.h:90
void CallbackUnaryCall(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc_impl::ClientContext *context, const InputMessage *request, OutputMessage *result, std::function< void(::grpc::Status)> on_completion)
Perform a callback-based unary call TODO(vjpai): Combine as much as possible with the blocking unary ...
Definition: client_callback_impl.h:46
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm_impl.h:33
This header provides an object that reads bytes directly from a grpc::ByteBuffer, via the ZeroCopyInp...
Definition: alarm.h:24
::grpc_impl::ClientContext ClientContext
Definition: client_context.h:26
::grpc_impl::Channel Channel
Definition: channel.h:26
CoreCodegenInterface * g_core_codegen_interface
Null-initializes the global gRPC variables for the codegen library.
Definition: completion_queue_impl.h:90