Go to the documentation of this file.
19 #ifndef GRPCPP_SUPPORT_CLIENT_CALLBACK_H
20 #define GRPCPP_SUPPORT_CLIENT_CALLBACK_H
37 #include <type_traits>
40 #include "absl/functional/any_invocable.h"
41 #include "absl/log/absl_check.h"
56 template <
class InputMessage,
class OutputMessage,
57 class BaseInputMessage = InputMessage,
58 class BaseOutputMessage = OutputMessage>
62 const InputMessage* request, OutputMessage* result,
64 static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value,
65 "Invalid input message specification");
66 static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value,
67 "Invalid output message specification");
69 channel, method, context, request, result, std::move(on_completion));
72 template <
class InputMessage,
class OutputMessage>
73 class CallbackUnaryCallImpl {
78 const InputMessage* request, OutputMessage* result,
81 ABSL_CHECK_NE(cq,
nullptr);
96 const size_t alloc_sz =
sizeof(OpSetAndTag);
99 auto* ops =
new (&alloced->opset) FullCallOpSet;
101 call.
call(), std::move(on_completion), ops);
109 ops->SendInitialMetadata(&context->send_initial_metadata_,
110 context->initial_metadata_flags());
111 ops->RecvInitialMetadata(context);
112 ops->RecvMessage(result);
113 ops->AllowNoMessage();
114 ops->ClientSendClose();
115 ops->ClientRecvStatus(context, tag->status_ptr());
116 ops->set_core_cq_tag(tag);
147 namespace experimental {
148 template <
class RequestType,
class ResponseType>
156 template <
class Request,
class Response>
158 template <
class Response>
160 template <
class Request>
167 template <
class Request,
class Response>
174 virtual void Read(Response* resp) = 0;
175 virtual void AddHold(
int holds) = 0;
180 reactor->BindStream(
this);
184 template <
class Response>
189 virtual void Read(Response* resp) = 0;
190 virtual void AddHold(
int holds) = 0;
195 reactor->BindReader(
this);
199 template <
class Request>
211 virtual void AddHold(
int holds) = 0;
216 reactor->BindWriter(
this);
229 namespace experimental {
256 template <
class Request,
class Response>
257 class ClientBidiReactor :
public internal::ClientReactor {
287 stream_->Write(req, options);
334 ABSL_DCHECK_GT(holds, 0);
335 stream_->AddHold(holds);
393 template <
class Response>
394 class ClientReadReactor :
public internal::ClientReactor {
401 ABSL_DCHECK_GT(holds, 0);
402 reader_->AddHold(holds);
418 template <
class Request>
419 class ClientWriteReactor :
public internal::ClientReactor {
424 writer_->Write(req, options);
433 ABSL_DCHECK_GT(holds, 0);
434 writer_->AddHold(holds);
475 reactor->BindCall(
this);
481 absl::AnyInvocable<
void()> goaway_callback);
484 namespace experimental {
492 virtual void OnSessionReady(std::shared_ptr<Channel> virtual_channel) = 0;
504 reactor->BindCall(
this);
511 template <
class Request,
class Response>
512 class ClientCallbackReaderWriterFactory;
513 template <
class Response>
514 class ClientCallbackReaderFactory;
515 template <
class Request>
516 class ClientCallbackWriterFactory;
518 template <
class Request,
class Response>
519 class ClientCallbackReaderWriterImpl
523 static void operator delete(
void* , std::size_t size) {
532 static void operator delete(
void*,
void*) { ABSL_CHECK(
false); }
534 void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_)
override {
540 if (!start_corked_) {
541 start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
542 context_->initial_metadata_flags());
550 if (backlog_.read_ops) {
553 if (backlog_.write_ops) {
556 if (backlog_.writes_done_ops) {
557 writes_done_ops_.
FillOps(&call_);
562 started_.store(
true, std::memory_order_release);
567 this->MaybeFinish(
false);
570 void Read(Response* msg)
override {
571 read_ops_.RecvMessage(msg);
572 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
573 if (
GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
575 if (
GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
576 backlog_.read_ops =
true;
584 ABSL_LOCKS_EXCLUDED(start_mu_)
override {
585 if (options.is_last_message()) {
586 options.set_buffer_hint();
587 write_ops_.ClientSendClose();
594 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
596 write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
597 context_->initial_metadata_flags());
598 corked_write_needed_ =
false;
601 if (
GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
603 if (
GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
604 backlog_.write_ops =
true;
611 writes_done_ops_.ClientSendClose();
612 writes_done_tag_.
Set(
615 reactor_->OnWritesDoneDone(ok);
618 &writes_done_ops_,
false);
620 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
622 writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
623 context_->initial_metadata_flags());
624 corked_write_needed_ =
false;
626 if (
GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
628 if (
GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
629 backlog_.writes_done_ops =
true;
633 writes_done_ops_.
FillOps(&call_);
637 callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
652 start_corked_(context_->initial_metadata_corked_),
653 corked_write_needed_(start_corked_) {
654 this->BindReactor(reactor);
660 reactor_->OnReadInitialMetadataDone(
661 ok && !reactor_->InternalTrailersOnly(call_.call()));
665 start_ops_.RecvInitialMetadata(context_);
671 reactor_->OnWriteDone(ok);
680 reactor_->OnReadDone(ok);
689 [
this](
bool ) { MaybeFinish(true); },
692 finish_ops_.ClientRecvStatus(context_, &finish_status_);
702 void MaybeFinish(
bool from_reaction) {
704 1, std::memory_order_acq_rel) == 1)) {
706 auto* reactor = reactor_;
707 auto* call = call_.
call();
708 this->~ClientCallbackReaderWriterImpl();
714 call, [reactor, s = std::move(s)]() { reactor->OnDone(s); });
723 ClientBidiReactor<Request, Response>*
const reactor_;
729 const bool start_corked_;
730 bool corked_write_needed_;
752 struct StartCallBacklog {
753 bool write_ops =
false;
754 bool writes_done_ops =
false;
755 bool read_ops =
false;
757 StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
760 std::atomic<intptr_t> callbacks_outstanding_{3};
761 std::atomic_bool started_{
false};
765 template <
class Request,
class Response>
766 class ClientCallbackReaderWriterFactory {
773 channel->CreateCall(method, context, channel->CallbackCQ());
783 template <
class Response>
787 static void operator delete(
void* , std::size_t size) {
796 static void operator delete(
void*,
void*) { ABSL_CHECK(
false); }
807 reactor_->OnReadInitialMetadataDone(
808 ok && !reactor_->InternalTrailersOnly(call_.call()));
812 start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
813 context_->initial_metadata_flags());
814 start_ops_.RecvInitialMetadata(context_);
822 reactor_->OnReadDone(ok);
830 if (backlog_.read_ops) {
833 started_.store(
true, std::memory_order_release);
838 [
this](
bool ) { MaybeFinish(true); },
839 &finish_ops_,
false);
840 finish_ops_.ClientRecvStatus(context_, &finish_status_);
845 void Read(Response* msg)
override {
846 read_ops_.RecvMessage(msg);
847 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
848 if (
GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
850 if (
GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
851 backlog_.read_ops =
true;
859 callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
866 template <
class Request>
871 : context_(context), call_(call), reactor_(reactor) {
872 this->BindReactor(reactor);
876 start_ops_.ClientSendClose();
880 void MaybeFinish(
bool from_reaction) {
882 1, std::memory_order_acq_rel) == 1)) {
884 auto* reactor = reactor_;
885 auto* call = call_.
call();
886 this->~ClientCallbackReaderImpl();
892 call, [reactor, s = std::move(s)]() { reactor->OnDone(s); });
900 ClientReadReactor<Response>*
const reactor_;
917 struct StartCallBacklog {
918 bool read_ops =
false;
920 StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
923 std::atomic<intptr_t> callbacks_outstanding_{2};
924 std::atomic_bool started_{
false};
928 template <
class Response>
929 class ClientCallbackReaderFactory {
931 template <
class Request>
937 channel->CreateCall(method, context, channel->CallbackCQ());
947 template <
class Request>
951 static void operator delete(
void* , std::size_t size) {
960 static void operator delete(
void*,
void*) { ABSL_CHECK(
false); }
962 void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_)
override {
968 if (!start_corked_) {
969 start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
970 context_->initial_metadata_flags());
977 if (backlog_.write_ops) {
980 if (backlog_.writes_done_ops) {
981 writes_done_ops_.
FillOps(&call_);
986 started_.store(
true, std::memory_order_release);
991 this->MaybeFinish(
false);
995 ABSL_LOCKS_EXCLUDED(start_mu_)
override {
997 options.set_buffer_hint();
998 write_ops_.ClientSendClose();
1005 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
1008 write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
1009 context_->initial_metadata_flags());
1010 corked_write_needed_ =
false;
1013 if (
GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
1015 if (
GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
1016 backlog_.write_ops =
true;
1024 writes_done_ops_.ClientSendClose();
1025 writes_done_tag_.
Set(
1028 reactor_->OnWritesDoneDone(ok);
1031 &writes_done_ops_,
false);
1033 callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
1036 writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
1037 context_->initial_metadata_flags());
1038 corked_write_needed_ =
false;
1041 if (
GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
1043 if (
GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
1044 backlog_.writes_done_ops =
true;
1048 writes_done_ops_.
FillOps(&call_);
1052 callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
1059 template <
class Response>
1064 : channel_(channel),
1068 start_corked_(context_->initial_metadata_corked_),
1069 corked_write_needed_(start_corked_) {
1070 this->BindReactor(reactor);
1076 reactor_->OnReadInitialMetadataDone(
1077 ok && !reactor_->InternalTrailersOnly(call_.call()));
1080 &start_ops_,
false);
1081 start_ops_.RecvInitialMetadata(context_);
1087 reactor_->OnWriteDone(ok);
1090 &write_ops_,
false);
1094 finish_ops_.RecvMessage(response);
1095 finish_ops_.AllowNoMessage();
1098 [
this](
bool ) { MaybeFinish(true); },
1101 finish_ops_.ClientRecvStatus(context_, &finish_status_);
1106 void MaybeFinish(
bool from_reaction) {
1108 1, std::memory_order_acq_rel) == 1)) {
1110 auto* reactor = reactor_;
1111 auto* call = call_.
call();
1112 this->~ClientCallbackWriterImpl();
1118 call, [reactor, s = std::move(s)]() { reactor->OnDone(s); });
1127 ClientWriteReactor<Request>*
const reactor_;
1133 const bool start_corked_;
1134 bool corked_write_needed_;
1154 struct StartCallBacklog {
1155 bool write_ops =
false;
1156 bool writes_done_ops =
false;
1158 StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
1161 std::atomic<intptr_t> callbacks_outstanding_{3};
1162 std::atomic_bool started_{
false};
1166 template <
class Request>
1167 class ClientCallbackWriterFactory {
1169 template <
class Response>
1175 channel->CreateCall(method, context, channel->CallbackCQ());
1188 static void operator delete(
void* , std::size_t size) {
1197 static void operator delete(
void*,
void*) { ABSL_CHECK(
false); }
1207 reactor_->OnReadInitialMetadataDone(
1208 ok && !reactor_->InternalTrailersOnly(call_.call()));
1211 &start_ops_,
false);
1212 start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
1213 context_->initial_metadata_flags());
1214 start_ops_.RecvInitialMetadata(context_);
1219 call_.
call(), [
this](
bool ) { MaybeFinish(); }, &finish_ops_,
1221 finish_ops_.ClientRecvStatus(context_, &finish_status_);
1229 template <
class Request,
class Response>
1234 : context_(context), call_(call), reactor_(reactor) {
1240 start_ops_.ClientSendClose();
1241 finish_ops_.RecvMessage(response);
1242 finish_ops_.AllowNoMessage();
1248 void MaybeFinish() {
1250 1, std::memory_order_acq_rel) == 1)) {
1252 auto* reactor = reactor_;
1253 auto* call = call_.
call();
1262 ClientUnaryReactor*
const reactor_;
1278 std::atomic<intptr_t> callbacks_outstanding_{2};
1283 template <
class Request,
class Response,
class BaseRequest = Request,
1284 class BaseResponse = Response>
1290 channel->CreateCall(method, context, channel->CallbackCQ());
1296 static_cast<const BaseRequest*
>(request),
1297 static_cast<BaseResponse*
>(response), reactor);
1303 namespace experimental {
1304 namespace internal {
1309 : reactor_(reactor) {}
1316 if (reactor_ !=
nullptr) {
1317 reactor_->OnGracefulShutdown();
1329 static void operator delete(
void* , std::size_t size) {
1338 static void operator delete(
void*,
void*) { ABSL_CHECK(
false); }
1341 if (tracker_ !=
nullptr) {
1342 tracker_->Invalidate();
1348 call_.
call(), [
this](
bool ok) { OnSendDone(ok); }, &send_ops_,
1351 send_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
1352 context_->initial_metadata_flags());
1358 call_.
call(), [
this](
bool ok) { OnRecvInitialMetadataDone(ok); },
1361 meta_ops_.RecvInitialMetadata(context_);
1365 call_.
call(), [
this](
bool ok) { OnFinishDone(ok); }, &finish_ops_,
1367 finish_ops_.ClientRecvStatus(context_, &status_);
1375 template <
class Request>
1379 const Request* request,
1382 : context_(context),
1385 virtual_args_(virtual_args),
1392 void OnSendDone(
bool ok) {
1395 call_, virtual_args_,
1396 [tracker = tracker_]() { tracker->OnGracefulShutdown(); });
1402 void OnRecvInitialMetadataDone(
bool ok) {
1408 void OnFinishDone(
bool ) { MaybeFinish(); }
1410 void MaybeFinish() {
1411 if (--ops_outstanding_ == 0) {
1413 auto* reactor = reactor_;
1414 auto* call = call_.
call();
1417 [reactor, s]() { reactor->
OnDone(s); });
1426 std::shared_ptr<SessionReactorTracker> tracker_;
1437 std::atomic<int> ops_outstanding_{3};
1445 template <
class Request,
class BaseRequest = Request>
1452 channel->CreateCall(method, context, channel->CallbackCQ());
1458 static_cast<const BaseRequest*
>(request),
1459 reactor, std::move(virtual_args));
1462 template <
class RequestType,
class ResponseType>
1469 #endif // GRPCPP_SUPPORT_CLIENT_CALLBACK_H
Definition: client_callback.h:1185
virtual void OnSessionReady(std::shared_ptr< Channel > virtual_channel)=0
CallbackWithSuccessTag can be reused multiple times, and will be used in this fashion for streaming o...
Definition: callback_common.h:153
virtual void OnReadInitialMetadataDone(bool)
Definition: client_callback.h:407
virtual void OnReadInitialMetadataDone(bool)
Definition: client_callback.h:439
void StartWritesDone()
Definition: client_callback.h:429
virtual ~ClientCallbackWriter()
Definition: client_callback.h:202
void Read(Response *msg) override
Definition: client_callback.h:570
void AddHold(int holds) override
Definition: client_callback.h:1051
void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override
Definition: client_callback.h:534
CallbackUnaryCallImpl(grpc::ChannelInterface *channel, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, const InputMessage *request, OutputMessage *result, std::function< void(grpc::Status)> &&on_completion)
Definition: client_callback.h:75
Definition: call_op_set.h:621
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.h:278
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.
Definition: call_op_set.h:528
void AddHold()
Holds are needed if (and only if) this stream has operations that take place on it after StartCall bu...
Definition: client_callback.h:332
Definition: client_context.h:72
virtual void OnReadDone(bool)
Definition: client_callback.h:408
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
Primary implementation of CallOpSetInterface.
Definition: completion_queue.h:97
void Write(const Request *msg, grpc::WriteOptions options) ABSL_LOCKS_EXCLUDED(start_mu_) override
Definition: client_callback.h:583
void RemoveHold() override
Definition: client_callback.h:861
Definition: call_op_set.h:287
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:156
ClientUnaryReactor is a reactor-style interface for a unary RPC.
Definition: client_callback.h:461
virtual void Read(Response *resp)=0
static void Create(grpc::ChannelInterface *channel, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, ClientBidiReactor< Request, Response > *reactor)
Definition: client_callback.h:768
void StartWrite(const Request *req, grpc::WriteOptions options)
Definition: client_callback.h:423
void FillOps(Call *call) override
Definition: call_op_set.h:895
void StartCall()
Definition: client_callback.h:421
void OnDone(const grpc::Status &) override
Definition: client_callback.h:438
virtual void OnDone(const grpc::Status &)=0
Called by the library when all operations associated with this RPC have completed and all Holds have ...
void RemoveHold() override
Definition: client_callback.h:639
void OnDone(const grpc::Status &) override
Definition: client_callback.h:406
Definition: client_callback.h:230
Straightforward wrapping of the C call object.
Definition: call.h:34
virtual void WritesDone()=0
void RemoveHold() override
Definition: client_callback.h:1054
SessionReactorTracker(ClientSessionReactor *reactor)
Definition: client_callback.h:1308
virtual void StartCall()=0
static void Create(grpc::ChannelInterface *channel, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, Response *response, ClientWriteReactor< Request > *reactor)
Definition: client_callback.h:1170
virtual void OnReadInitialMetadataDone(bool)
Notifies the application that a read of initial metadata from the server is done.
Definition: client_callback.h:359
Definition: callback_common.h:74
void BindReactor(ClientBidiReactor< Request, Response > *reactor)
Definition: client_callback.h:179
void CallbackUnaryCall(grpc::ChannelInterface *channel, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, const InputMessage *request, OutputMessage *result, std::function< void(grpc::Status)> &&on_completion)
Perform a callback-based unary call.
Definition: client_callback.h:59
bool ok() const
Is the status OK?
Definition: status.h:124
void BindReactor(ClientUnaryReactor *reactor)
Definition: client_callback.h:474
GRPCAPI void grpc_call_ref(grpc_call *call)
Ref a call.
void StartRead(Response *resp)
Initiate a read operation (or post it for later initiation if StartCall has not yet been invoked).
Definition: client_callback.h:270
void AddMultipleHolds(int holds)
Definition: client_callback.h:400
void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override
Definition: client_callback.h:962
void Write(const Request *msg, grpc::WriteOptions options) ABSL_LOCKS_EXCLUDED(start_mu_) override
Definition: client_callback.h:994
void StartWrite(const Request *req, grpc::WriteOptions options)
Initiate/post a write operation with specified options.
Definition: client_callback.h:286
void OnDone(const grpc::Status &) override
Notifies the application that all operations associated with this RPC have completed and all Holds ha...
Definition: client_callback.h:350
Options for channel creation.
Definition: channel_arguments.h:39
void StartCall()
Definition: client_callback.h:490
virtual ~ClientReactor()=default
virtual void StartCall()=0
virtual void AddHold(int holds)=0
virtual void OnReadDone(bool)
Notifies the application that a StartRead operation completed.
Definition: client_callback.h:365
Did it work? If it didn't, why?
Definition: status.h:34
virtual void WritesDone()=0
GRPCAPI void grpc_call_unref(grpc_call *call)
Unref a call.
Definition: channel_interface.h:52
void StartCall()
Definition: client_callback.h:396
virtual void OnWriteDone(bool)
Notifies the application that a StartWrite or StartWriteLast operation completed.
Definition: client_callback.h:372
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:203
void StartCall() override
Definition: client_callback.h:798
Definition: channel_interface.h:48
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:68
Definition: client_context.h:69
virtual void OnReadInitialMetadataDone(bool)
Definition: client_callback.h:465
void BindReactor(ClientWriteReactor< Request > *reactor)
Definition: client_callback.h:215
void Invalidate()
Definition: client_callback.h:1310
virtual void RemoveHold()=0
Definition: client_callback.h:168
void StartWritesDone()
Indicate that the RPC will have no more write operations.
Definition: client_callback.h:308
virtual void Read(Response *resp)=0
void StartRead(Response *resp)
Definition: client_callback.h:397
Codegen interface for grpc::Channel.
Definition: channel_interface.h:79
Definition: client_callback.h:122
~ClientCallbackSessionImpl() override
Definition: client_callback.h:1340
void StartCall() override
Definition: client_callback.h:1346
Definition: client_callback.h:1281
void Read(Response *msg) override
Definition: client_callback.h:845
void OnGracefulShutdown()
Definition: client_callback.h:1314
void StartWriteLast(const Request *req, grpc::WriteOptions options)
Definition: client_callback.h:426
Definition: client_context.h:76
virtual void Write(const Request *req, grpc::WriteOptions options)=0
Definition: client_callback.h:1306
ClientWriteReactor is the interface for a client-streaming RPC.
Definition: client_callback.h:161
void grpc_call_run_in_event_engine(const grpc_call *call, absl::AnyInvocable< void()> cb)
ClientSessionReactor is a reactor-style interface for a session RPC.
Definition: client_callback.h:488
Definition: client_callback.h:220
void AddMultipleHolds(int holds)
Definition: client_callback.h:333
virtual ~ClientCallbackSession()
Definition: client_callback.h:232
void RemoveHold()
Definition: client_callback.h:404
static void Create(grpc::ChannelInterface *channel, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, const Request *request, Response *response, ClientUnaryReactor *reactor)
Definition: client_callback.h:1285
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.h:299
Per-message write options.
Definition: call_op_set.h:79
virtual void RemoveHold()=0
virtual void OnWritesDoneDone(bool)
Notifies the application that a StartWritesDone operation completed.
Definition: client_callback.h:381
void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override
Definition: client_callback.h:1023
virtual ~ClientCallbackReader()
Definition: client_callback.h:187
Definition: client_callback.h:149
void Set(grpc_call *call, std::function< void(bool)> f, CompletionQueueTag *ops, bool can_inline)
Definition: callback_common.h:180
void AddHold(int holds) override
Definition: client_callback.h:858
void BindReactor(ClientReadReactor< Response > *reactor)
Definition: client_callback.h:194
virtual void OnGracefulShutdown()
Definition: client_callback.h:494
Definition: client_callback.h:200
virtual void AddHold(int holds)=0
void RemoveHold()
Definition: client_callback.h:337
virtual ~ClientCallbackReaderWriter()
Definition: client_callback.h:170
virtual void RemoveHold()=0
void Write(const Request *req)
Definition: client_callback.h:204
virtual void StartCall()=0
void AddHold()
Definition: client_callback.h:431
void BindReactor(ClientSessionReactor *reactor)
Definition: client_callback.h:503
grpc_call * call() const
Definition: call.h:55
void StartCall()
Definition: client_callback.h:463
virtual void StartCall()=0
Definition: async_unary_call.h:410
Definition: call_op_set.h:771
std::shared_ptr< Channel > CreateVirtualChannel(Call call, const ChannelArguments &args, absl::AnyInvocable< void()> goaway_callback)
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:104
ClientBidiReactor is the interface for a bidirectional streaming RPC.
Definition: client_callback.h:157
Definition: channel_interface.h:50
Definition: client_callback.h:1326
Definition: client_callback.h:1443
void WriteLast(const Request *req, grpc::WriteOptions options)
Definition: client_callback.h:206
Definition: client_context.h:74
virtual bool InternalTrailersOnly(const grpc_call *call) const
InternalTrailersOnly is not part of the API and is not meant to be overridden.
virtual void StartCall()=0
void StartCall() override
Definition: client_callback.h:1199
void StartWrite(const Request *req)
Definition: client_callback.h:422
virtual void OnSessionAcknowledged(bool)
Definition: client_callback.h:493
void StartCall()
Activate the RPC and initiate any reads or writes that have been Start'ed before this call.
Definition: client_callback.h:263
virtual void OnWriteDone(bool)
Definition: client_callback.h:440
Definition: call_op_set.h:427
Descriptor of an RPC method.
Definition: rpc_method.h:29
virtual void AddHold(int holds)=0
void AddMultipleHolds(int holds)
Definition: client_callback.h:432
Definition: client_callback.h:185
virtual ~ClientCallbackUnary()
Definition: client_callback.h:222
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:947
void AddHold(int holds) override
Definition: client_callback.h:636
void OnDone(const grpc::Status &) override
Called by the library when all operations associated with this RPC have completed and all Holds have ...
Definition: client_callback.h:491
void RemoveHold()
Definition: client_callback.h:436
ClientReadReactor is the interface for a server-streaming RPC.
Definition: client_callback.h:159
void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override
Definition: client_callback.h:610
void AddHold()
Definition: client_callback.h:399
void OnDone(const grpc::Status &) override
Called by the library when all operations associated with this RPC have completed and all Holds have ...
Definition: client_callback.h:464
virtual grpc_event_engine::experimental::MemoryAllocator * memory_allocator() const
Definition: channel_interface.h:113
static void Create(grpc::ChannelInterface *channel, const grpc::internal::RpcMethod &method, grpc::ClientContext *context, const Request *request, ClientReadReactor< Response > *reactor)
Definition: client_callback.h:932
virtual void OnWritesDoneDone(bool)
Definition: client_callback.h:441