18 #ifndef GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_IMPL_H 19 #define GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_IMPL_H 23 #include <type_traits> 39 template <
class Request,
class Response>
40 class CallbackUnaryHandler;
41 template <
class Request,
class Response>
42 class CallbackClientStreamingHandler;
43 template <
class Request,
class Response>
44 class CallbackServerStreamingHandler;
45 template <
class Request,
class Response>
46 class CallbackBidiHandler;
61 template <
class Request,
class Response>
63 template <
class Request,
class Response>
65 template <
class Request,
class Response>
67 template <
class Request,
class Response>
85 if (
GPR_UNLIKELY(on_cancel_conditions_remaining_.fetch_sub(
86 1, std::memory_order_acq_rel) == 1)) {
87 CallOnCancel(reactor);
99 void Ref() { callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed); }
103 return callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel);
108 virtual void MaybeDone() = 0;
114 std::atomic_int on_cancel_conditions_remaining_{2};
115 std::atomic_int callbacks_outstanding_{
119 template <
class Request,
class Response>
133 Request request_obj_;
134 Response response_obj_;
141 template <
class Request>
143 template <
class Response>
145 template <
class Request,
class Response>
160 template <
class Reactor>
162 reactor->InternalBindCall(
this);
166 template <
class Request>
172 virtual void Read(Request* msg) = 0;
176 reactor->InternalBindReader(
this);
180 template <
class Response>
193 reactor->InternalBindWriter(
this);
197 template <
class Request,
class Response>
204 virtual void Read(Request* msg) = 0;
211 reactor->InternalBindStream(
this);
222 template <
class Request,
class Response>
238 stream_.load(std::memory_order_acquire);
239 if (stream ==
nullptr) {
241 stream = stream_.load(std::memory_order_relaxed);
242 if (stream ==
nullptr) {
243 send_initial_metadata_wanted_ =
true;
256 stream_.load(std::memory_order_acquire);
257 if (stream ==
nullptr) {
259 stream = stream_.load(std::memory_order_relaxed);
260 if (stream ==
nullptr) {
285 stream_.load(std::memory_order_acquire);
286 if (stream ==
nullptr) {
288 stream = stream_.load(std::memory_order_relaxed);
289 if (stream ==
nullptr) {
290 write_wanted_ = resp;
291 write_options_wanted_ = std::move(options);
295 stream->
Write(resp, std::move(options));
314 stream_.load(std::memory_order_acquire);
315 if (stream ==
nullptr) {
317 stream = stream_.load(std::memory_order_relaxed);
318 if (stream ==
nullptr) {
319 write_and_finish_wanted_ =
true;
320 write_wanted_ = resp;
321 write_options_wanted_ = std::move(options);
322 status_wanted_ = std::move(s);
349 stream_.load(std::memory_order_acquire);
350 if (stream ==
nullptr) {
352 stream = stream_.load(std::memory_order_relaxed);
353 if (stream ==
nullptr) {
354 finish_wanted_ =
true;
355 status_wanted_ = std::move(s);
359 stream->
Finish(std::move(s));
386 void OnDone()
override = 0;
397 virtual void InternalBindStream(
400 stream_.store(stream, std::memory_order_release);
401 if (send_initial_metadata_wanted_) {
403 send_initial_metadata_wanted_ =
false;
405 if (read_wanted_ !=
nullptr) {
406 stream->
Read(read_wanted_);
407 read_wanted_ =
nullptr;
409 if (write_and_finish_wanted_) {
412 write_and_finish_wanted_ =
false;
413 const Response* write_wanted = write_wanted_;
415 std::move(write_options_wanted_);
418 stream->
WriteAndFinish(write_wanted, std::move(write_options_wanted),
419 std::move(status_wanted));
422 if (write_wanted_ !=
nullptr) {
423 stream->
Write(write_wanted_, std::move(write_options_wanted_));
424 write_wanted_ =
nullptr;
426 if (finish_wanted_) {
427 finish_wanted_ =
false;
430 stream->
Finish(std::move(status_wanted));
437 std::atomic<ServerCallbackReaderWriter<Request, Response>*> stream_;
438 bool send_initial_metadata_wanted_ =
false;
439 bool write_and_finish_wanted_ =
false;
440 bool finish_wanted_ =
false;
441 Request* read_wanted_ =
nullptr;
442 const Response* write_wanted_ =
nullptr;
448 template <
class Request>
457 reader_.load(std::memory_order_acquire);
458 if (reader ==
nullptr) {
460 reader = reader_.load(std::memory_order_relaxed);
461 if (reader ==
nullptr) {
462 send_initial_metadata_wanted_ =
true;
470 reader_.load(std::memory_order_acquire);
471 if (reader ==
nullptr) {
473 reader = reader_.load(std::memory_order_relaxed);
474 if (reader ==
nullptr) {
483 reader_.load(std::memory_order_acquire);
484 if (reader ==
nullptr) {
486 reader = reader_.load(std::memory_order_relaxed);
487 if (reader ==
nullptr) {
488 finish_wanted_ =
true;
489 status_wanted_ = std::move(s);
493 reader->
Finish(std::move(s));
499 void OnDone()
override = 0;
509 reader_.store(reader, std::memory_order_release);
510 if (send_initial_metadata_wanted_) {
512 send_initial_metadata_wanted_ =
false;
514 if (read_wanted_ !=
nullptr) {
515 reader->
Read(read_wanted_);
516 read_wanted_ =
nullptr;
518 if (finish_wanted_) {
519 finish_wanted_ =
false;
522 reader->
Finish(std::move(status_wanted));
528 std::atomic<ServerCallbackReader<Request>*> reader_;
529 bool send_initial_metadata_wanted_ =
false;
530 bool finish_wanted_ =
false;
531 Request* read_wanted_ =
nullptr;
536 template <
class Response>
545 writer_.load(std::memory_order_acquire);
546 if (writer ==
nullptr) {
548 writer = writer_.load(std::memory_order_relaxed);
549 if (writer ==
nullptr) {
550 send_initial_metadata_wanted_ =
true;
561 writer_.load(std::memory_order_acquire);
562 if (writer ==
nullptr) {
564 writer = writer_.load(std::memory_order_relaxed);
565 if (writer ==
nullptr) {
566 write_wanted_ = resp;
567 write_options_wanted_ = std::move(options);
571 writer->
Write(resp, std::move(options));
576 writer_.load(std::memory_order_acquire);
577 if (writer ==
nullptr) {
579 writer = writer_.load(std::memory_order_relaxed);
580 if (writer ==
nullptr) {
581 write_and_finish_wanted_ =
true;
582 write_wanted_ = resp;
583 write_options_wanted_ = std::move(options);
584 status_wanted_ = std::move(s);
595 writer_.load(std::memory_order_acquire);
596 if (writer ==
nullptr) {
598 writer = writer_.load(std::memory_order_relaxed);
599 if (writer ==
nullptr) {
600 finish_wanted_ =
true;
601 status_wanted_ = std::move(s);
605 writer->
Finish(std::move(s));
611 void OnDone()
override = 0;
620 writer_.store(writer, std::memory_order_release);
621 if (send_initial_metadata_wanted_) {
623 send_initial_metadata_wanted_ =
false;
625 if (write_and_finish_wanted_) {
626 write_and_finish_wanted_ =
false;
627 const Response* write_wanted = write_wanted_;
629 std::move(write_options_wanted_);
632 writer->
WriteAndFinish(write_wanted, std::move(write_options_wanted),
633 std::move(status_wanted));
636 if (write_wanted_ !=
nullptr) {
637 writer->
Write(write_wanted_, std::move(write_options_wanted_));
638 write_wanted_ =
nullptr;
640 if (finish_wanted_) {
641 finish_wanted_ =
false;
644 writer->
Finish(std::move(status_wanted));
651 std::atomic<ServerCallbackWriter<Response>*> writer_;
652 bool send_initial_metadata_wanted_ =
false;
653 bool write_and_finish_wanted_ =
false;
654 bool finish_wanted_ =
false;
655 const Response* write_wanted_ =
nullptr;
668 if (call ==
nullptr) {
670 call = call_.load(std::memory_order_relaxed);
671 if (call ==
nullptr) {
672 send_initial_metadata_wanted_ =
true;
680 if (call ==
nullptr) {
682 call = call_.load(std::memory_order_relaxed);
683 if (call ==
nullptr) {
684 finish_wanted_ =
true;
685 status_wanted_ = std::move(s);
689 call->
Finish(std::move(s));
694 void OnDone()
override = 0;
703 call_.store(call, std::memory_order_release);
704 if (send_initial_metadata_wanted_) {
706 send_initial_metadata_wanted_ =
false;
708 if (finish_wanted_) {
709 finish_wanted_ =
false;
712 call->
Finish(std::move(status_wanted));
718 std::atomic<ServerCallbackUnary*> call_;
719 bool send_initial_metadata_wanted_ =
false;
720 bool finish_wanted_ =
false;
726 template <
class Base>
734 template <
class Request>
736 template <
class Response>
739 template <
class Request,
class Response>
746 #endif // GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_IMPL_H FinishOnlyReactor(::grpc::Status s)
Definition: server_callback_impl.h:729
Definition: byte_buffer.h:38
::grpc_impl::ServerReadReactor< Request > ServerReadReactor
Definition: server_callback.h:27
void StartWriteLast(const Response *resp, ::grpc::WriteOptions options)
Inform system of a planned write operation with specified options, but allow the library to schedule ...
Definition: server_callback_impl.h:337
ServerUnaryReactor()
Definition: server_callback_impl.h:662
void Finish(::grpc::Status s)
Indicate that the stream is to be finished and the trailing metadata and RPC status are to be sent...
Definition: server_callback_impl.h:347
virtual void Write(const Response *msg, ::grpc::WriteOptions options)=0
ServerWriteReactor is the interface for a server-streaming RPC.
Definition: server_callback_impl.h:144
ServerReadReactor()
Definition: server_callback_impl.h:451
virtual void SendInitialMetadata()=0
Definition: server_callback_impl.h:120
void StartWrite(const Response *resp)
Initiate a write operation.
Definition: server_callback_impl.h:273
virtual void SendInitialMetadata()=0
virtual ~ServerCallbackWriter()
Definition: server_callback_impl.h:183
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
Definition: server_callback_impl.h:151
void MaybeCallOnCancel(ServerReactor *reactor)
Definition: server_callback_impl.h:84
~ServerReadReactor()=default
ServerBidiReactor is the interface for a bidirectional streaming RPC.
Definition: server_callback_impl.h:146
virtual void Write(const Response *msg, ::grpc::WriteOptions options)=0
ServerBidiReactor()
Definition: server_callback_impl.h:230
void StartWrite(const Response *resp)
Definition: server_callback_impl.h:556
~ServerWriteReactor()=default
virtual void OnWriteDone(bool)
Definition: server_callback_impl.h:610
void set_response(Response *response)
Definition: message_allocator.h:51
virtual void WriteAndFinish(const Response *msg, ::grpc::WriteOptions options, ::grpc::Status s)=0
void StartWriteAndFinish(const Response *resp, ::grpc::WriteOptions options, ::grpc::Status s)
Definition: server_callback_impl.h:573
Definition: server_callback_impl.h:181
void StartSendInitialMetadata()
Send any initial metadata stored in the RPC context.
Definition: server_callback_impl.h:236
virtual void SendInitialMetadata()=0
void OnCancel() override
Definition: server_callback_impl.h:612
void OnCancel() override
Definition: server_callback_impl.h:500
The base class of ServerCallbackUnary etc.
Definition: server_callback_impl.h:72
void BindReactor(ServerBidiReactor< Request, Response > *reactor)
Definition: server_callback_impl.h:210
::grpc_impl::ServerWriteReactor< Response > ServerWriteReactor
Definition: server_callback.h:30
void StartWriteAndFinish(const Response *resp, ::grpc::WriteOptions options, ::grpc::Status s)
Initiate a write operation with specified options and final RPC Status, which also causes any trailin...
Definition: server_callback_impl.h:311
virtual void OnSendInitialMetadataDone(bool)
The following notifications are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:609
void StartSendInitialMetadata()
The following operation initiations are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:455
void StartWrite(const Response *resp, ::grpc::WriteOptions options)
Definition: server_callback_impl.h:559
virtual void SendInitialMetadata()=0
Definition: server_callback_impl.h:198
void set_request(Request *request)
Definition: message_allocator.h:50
void Finish(::grpc::Status s)
Definition: server_callback_impl.h:593
void StartSendInitialMetadata()
The following operation initiations are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:666
virtual void OnReadDone(bool)
Definition: server_callback_impl.h:498
ServerWriteReactor()
Definition: server_callback_impl.h:539
void OnCancel() override
Notifies the application that this RPC has been cancelled.
Definition: server_callback_impl.h:391
virtual bool InternalInlineable()
Definition: server_callback_impl.h:58
void BindReactor(Reactor *reactor)
Definition: server_callback_impl.h:161
virtual ~ServerCallbackUnary()
Definition: server_callback_impl.h:153
ServerReadReactor is the interface for a client-streaming RPC.
Definition: server_callback_impl.h:142
void StartSendInitialMetadata()
The following operation initiations are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:543
::grpc_impl::ServerUnaryReactor ServerUnaryReactor
Definition: server_callback.h:35
void MaybeCallOnCancel()
Definition: server_callback_impl.h:95
Definition: byte_buffer.h:36
void OnCancel() override
Definition: server_callback_impl.h:695
Definition: message_allocator.h:40
virtual void Finish(::grpc::Status s)=0
virtual void Read(Request *msg)=0
int Unref()
Decreases the reference count and returns the previous value.
Definition: server_callback_impl.h:102
DefaultMessageHolder()
Definition: server_callback_impl.h:123
Per-message write options.
Definition: call_op_set.h:79
void BindReactor(ServerWriteReactor< Response > *reactor)
Definition: server_callback_impl.h:192
void BindReactor(ServerReadReactor< Request > *reactor)
Definition: server_callback_impl.h:175
Definition: server_callback_impl.h:660
void Finish(::grpc::Status s)
Definition: server_callback_impl.h:481
virtual void OnSendInitialMetadataDone(bool)
Notifies the application that an explicit StartSendInitialMetadata operation completed.
Definition: server_callback_impl.h:368
void OnDone() override
Definition: server_callback_impl.h:730
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm_impl.h:33
Definition: server_callback_handlers.h:607
virtual ~ServerReactor()=default
void Release() override
Definition: server_callback_impl.h:127
virtual void OnSendInitialMetadataDone(bool)
The following notifications are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:693
~ServerBidiReactor()=default
virtual ~ServerCallbackReader()
Definition: server_callback_impl.h:169
void StartRead(Request *req)
Initiate a read operation.
Definition: server_callback_impl.h:254
virtual void WriteAndFinish(const Response *msg, ::grpc::WriteOptions options, ::grpc::Status s)=0
virtual void OnSendInitialMetadataDone(bool)
The following notifications are exactly like ServerBidiReactor.
Definition: server_callback_impl.h:497
void Ref()
Increases the reference count.
Definition: server_callback_impl.h:99
void StartRead(Request *req)
Definition: server_callback_impl.h:468
Did it work? If it didn't, why?
Definition: status.h:31
virtual ~ServerCallbackCall()
Definition: server_callback_impl.h:74
virtual void Finish(::grpc::Status s)=0
Definition: server_callback_impl.h:727
Definition: server_callback_impl.h:167
Definition: server_callback_handlers.h:241
virtual ~ServerCallbackReaderWriter()
Definition: server_callback_impl.h:200
void StartWriteLast(const Response *resp, ::grpc::WriteOptions options)
Definition: server_callback_impl.h:590
~ServerUnaryReactor()=default
virtual void OnReadDone(bool)
Notifies the application that a StartRead operation completed.
Definition: server_callback_impl.h:374
virtual void Read(Request *msg)=0
Definition: server_callback_impl.h:48
virtual void Finish(::grpc::Status s)=0
::grpc_impl::ServerBidiReactor< Request, Response > ServerBidiReactor
Definition: server_callback.h:33
void StartWrite(const Response *resp, ::grpc::WriteOptions options)
Initiate a write operation with specified options.
Definition: server_callback_impl.h:283
virtual void Finish(::grpc::Status s)=0
virtual void OnCancel()=0
void Finish(::grpc::Status s)
Definition: server_callback_impl.h:678
virtual void OnWriteDone(bool)
Notifies the application that a StartWrite (or StartWriteLast) operation completed.
Definition: server_callback_impl.h:381
void OnDone() override=0
Notifies the application that all operations associated with this RPC have completed.