GRPC C++  1.39.1
sync_stream.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2019 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #ifndef GRPCPP_IMPL_CODEGEN_SYNC_STREAM_H
19 #define GRPCPP_IMPL_CODEGEN_SYNC_STREAM_H
20 
29 
30 namespace grpc {
31 
32 namespace internal {
35  public:
37 
63 };
64 
67  public:
69 
76  virtual void SendInitialMetadata() = 0;
77 };
78 
80 template <class R>
82  public:
83  virtual ~ReaderInterface() {}
84 
87  virtual bool NextMessageSize(uint32_t* sz) = 0;
88 
99  virtual bool Read(R* msg) = 0;
100 };
101 
103 template <class W>
105  public:
106  virtual ~WriterInterface() {}
107 
115  virtual bool Write(const W& msg, ::grpc::WriteOptions options) = 0;
116 
123  inline bool Write(const W& msg) { return Write(msg, ::grpc::WriteOptions()); }
124 
139  void WriteLast(const W& msg, ::grpc::WriteOptions options) {
140  Write(msg, options.set_last_message());
141  }
142 };
143 
144 } // namespace internal
145 
147 template <class R>
149  public internal::ReaderInterface<R> {
150  public:
155  virtual void WaitForInitialMetadata() = 0;
156 };
157 
158 namespace internal {
159 template <class R>
161  public:
162  template <class W>
164  const ::grpc::internal::RpcMethod& method,
165  ::grpc::ClientContext* context,
166  const W& request) {
167  return new ClientReader<R>(channel, method, context, request);
168  }
169 };
170 } // namespace internal
171 
175 template <class R>
176 class ClientReader final : public ClientReaderInterface<R> {
177  public:
181  // Side effect:
185  void WaitForInitialMetadata() override {
186  GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
187 
189  ops;
190  ops.RecvInitialMetadata(context_);
191  call_.PerformOps(&ops);
192  cq_.Pluck(&ops);
193  }
194 
195  bool NextMessageSize(uint32_t* sz) override {
196  int result = call_.max_receive_message_size();
197  *sz = (result > 0) ? result : UINT32_MAX;
198  return true;
199  }
200 
206  bool Read(R* msg) override {
209  ops;
210  if (!context_->initial_metadata_received_) {
211  ops.RecvInitialMetadata(context_);
212  }
213  ops.RecvMessage(msg);
214  call_.PerformOps(&ops);
215  return cq_.Pluck(&ops) && ops.got_message;
216  }
217 
223  ::grpc::Status Finish() override {
225  ::grpc::Status status;
226  ops.ClientRecvStatus(context_, &status);
227  call_.PerformOps(&ops);
228  GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
229  return status;
230  }
231 
232  private:
233  friend class internal::ClientReaderFactory<R>;
234  ::grpc::ClientContext* context_;
237 
241  template <class W>
243  const ::grpc::internal::RpcMethod& method,
244  ::grpc::ClientContext* context, const W& request)
245  : context_(context),
248  nullptr}), // Pluckable cq
249  call_(channel->CreateCall(method, context, &cq_)) {
253  ops;
254  ops.SendInitialMetadata(&context->send_initial_metadata_,
255  context->initial_metadata_flags());
256  // TODO(ctiller): don't assert
257  GPR_CODEGEN_ASSERT(ops.SendMessagePtr(&request).ok());
258  ops.ClientSendClose();
259  call_.PerformOps(&ops);
260  cq_.Pluck(&ops);
261  }
262 };
263 
265 template <class W>
267  public internal::WriterInterface<W> {
268  public:
275  virtual bool WritesDone() = 0;
276 };
277 
278 namespace internal {
279 template <class W>
281  public:
282  template <class R>
284  const ::grpc::internal::RpcMethod& method,
285  ::grpc::ClientContext* context, R* response) {
286  return new ClientWriter<W>(channel, method, context, response);
287  }
288 };
289 } // namespace internal
290 
294 template <class W>
296  public:
300  // Side effect:
304  GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
305 
307  ops;
308  ops.RecvInitialMetadata(context_);
309  call_.PerformOps(&ops);
310  cq_.Pluck(&ops); // status ignored
311  }
312 
320  bool Write(const W& msg, ::grpc::WriteOptions options) override {
324  ops;
325 
326  if (options.is_last_message()) {
327  options.set_buffer_hint();
328  ops.ClientSendClose();
329  }
330  if (context_->initial_metadata_corked_) {
331  ops.SendInitialMetadata(&context_->send_initial_metadata_,
332  context_->initial_metadata_flags());
333  context_->set_initial_metadata_corked(false);
334  }
335  if (!ops.SendMessagePtr(&msg, options).ok()) {
336  return false;
337  }
338 
339  call_.PerformOps(&ops);
340  return cq_.Pluck(&ops);
341  }
342 
343  bool WritesDone() override {
345  ops.ClientSendClose();
346  call_.PerformOps(&ops);
347  return cq_.Pluck(&ops);
348  }
349 
356  ::grpc::Status Finish() override {
357  ::grpc::Status status;
358  if (!context_->initial_metadata_received_) {
359  finish_ops_.RecvInitialMetadata(context_);
360  }
361  finish_ops_.ClientRecvStatus(context_, &status);
362  call_.PerformOps(&finish_ops_);
363  GPR_CODEGEN_ASSERT(cq_.Pluck(&finish_ops_));
364  return status;
365  }
366 
367  private:
368  friend class internal::ClientWriterFactory<W>;
369 
375  template <class R>
377  const ::grpc::internal::RpcMethod& method,
378  ::grpc::ClientContext* context, R* response)
379  : context_(context),
382  nullptr}), // Pluckable cq
383  call_(channel->CreateCall(method, context, &cq_)) {
384  finish_ops_.RecvMessage(response);
385  finish_ops_.AllowNoMessage();
386 
387  if (!context_->initial_metadata_corked_) {
389  ops;
390  ops.SendInitialMetadata(&context->send_initial_metadata_,
391  context->initial_metadata_flags());
392  call_.PerformOps(&ops);
393  cq_.Pluck(&ops);
394  }
395  }
396 
397  ::grpc::ClientContext* context_;
401  finish_ops_;
404 };
405 
409 template <class W, class R>
411  public internal::WriterInterface<W>,
412  public internal::ReaderInterface<R> {
413  public:
418  virtual void WaitForInitialMetadata() = 0;
419 
426  virtual bool WritesDone() = 0;
427 };
428 
429 namespace internal {
430 template <class W, class R>
432  public:
434  ::grpc::ChannelInterface* channel,
435  const ::grpc::internal::RpcMethod& method,
436  ::grpc::ClientContext* context) {
437  return new ClientReaderWriter<W, R>(channel, method, context);
438  }
439 };
440 } // namespace internal
441 
446 template <class W, class R>
448  public:
455  void WaitForInitialMetadata() override {
456  GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
457 
459  ops;
460  ops.RecvInitialMetadata(context_);
461  call_.PerformOps(&ops);
462  cq_.Pluck(&ops); // status ignored
463  }
464 
465  bool NextMessageSize(uint32_t* sz) override {
466  int result = call_.max_receive_message_size();
467  *sz = (result > 0) ? result : UINT32_MAX;
468  return true;
469  }
470 
475  bool Read(R* msg) override {
478  ops;
479  if (!context_->initial_metadata_received_) {
480  ops.RecvInitialMetadata(context_);
481  }
482  ops.RecvMessage(msg);
483  call_.PerformOps(&ops);
484  return cq_.Pluck(&ops) && ops.got_message;
485  }
486 
493  bool Write(const W& msg, ::grpc::WriteOptions options) override {
497  ops;
498 
499  if (options.is_last_message()) {
500  options.set_buffer_hint();
501  ops.ClientSendClose();
502  }
503  if (context_->initial_metadata_corked_) {
504  ops.SendInitialMetadata(&context_->send_initial_metadata_,
505  context_->initial_metadata_flags());
506  context_->set_initial_metadata_corked(false);
507  }
508  if (!ops.SendMessagePtr(&msg, options).ok()) {
509  return false;
510  }
511 
512  call_.PerformOps(&ops);
513  return cq_.Pluck(&ops);
514  }
515 
516  bool WritesDone() override {
518  ops.ClientSendClose();
519  call_.PerformOps(&ops);
520  return cq_.Pluck(&ops);
521  }
522 
528  ::grpc::Status Finish() override {
531  ops;
532  if (!context_->initial_metadata_received_) {
533  ops.RecvInitialMetadata(context_);
534  }
535  ::grpc::Status status;
536  ops.ClientRecvStatus(context_, &status);
537  call_.PerformOps(&ops);
538  GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
539  return status;
540  }
541 
542  private:
543  friend class internal::ClientReaderWriterFactory<W, R>;
544 
545  ::grpc::ClientContext* context_;
548 
553  const ::grpc::internal::RpcMethod& method,
554  ::grpc::ClientContext* context)
555  : context_(context),
558  nullptr}), // Pluckable cq
559  call_(channel->CreateCall(method, context, &cq_)) {
560  if (!context_->initial_metadata_corked_) {
562  ops;
563  ops.SendInitialMetadata(&context->send_initial_metadata_,
564  context->initial_metadata_flags());
565  call_.PerformOps(&ops);
566  cq_.Pluck(&ops);
567  }
568  }
569 };
570 
572 template <class R>
574  public internal::ReaderInterface<R> {};
575 
579 template <class R>
580 class ServerReader final : public ServerReaderInterface<R> {
581  public:
585  void SendInitialMetadata() override {
586  GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
587 
589  ops;
590  ops.SendInitialMetadata(&ctx_->initial_metadata_,
591  ctx_->initial_metadata_flags());
592  if (ctx_->compression_level_set()) {
593  ops.set_compression_level(ctx_->compression_level());
594  }
595  ctx_->sent_initial_metadata_ = true;
596  call_->PerformOps(&ops);
597  call_->cq()->Pluck(&ops);
598  }
599 
600  bool NextMessageSize(uint32_t* sz) override {
601  int result = call_->max_receive_message_size();
602  *sz = (result > 0) ? result : UINT32_MAX;
603  return true;
604  }
605 
606  bool Read(R* msg) override {
608  ops.RecvMessage(msg);
609  call_->PerformOps(&ops);
610  return call_->cq()->Pluck(&ops) && ops.got_message;
611  }
612 
613  private:
614  ::grpc::internal::Call* const call_;
615  ServerContext* const ctx_;
616 
617  template <class ServiceType, class RequestType, class ResponseType>
619 
621  : call_(call), ctx_(ctx) {}
622 };
623 
625 template <class W>
627  public internal::WriterInterface<W> {};
628 
632 template <class W>
633 class ServerWriter final : public ServerWriterInterface<W> {
634  public:
639  void SendInitialMetadata() override {
640  GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
641 
643  ops;
644  ops.SendInitialMetadata(&ctx_->initial_metadata_,
645  ctx_->initial_metadata_flags());
646  if (ctx_->compression_level_set()) {
647  ops.set_compression_level(ctx_->compression_level());
648  }
649  ctx_->sent_initial_metadata_ = true;
650  call_->PerformOps(&ops);
651  call_->cq()->Pluck(&ops);
652  }
653 
660  bool Write(const W& msg, ::grpc::WriteOptions options) override {
661  if (options.is_last_message()) {
662  options.set_buffer_hint();
663  }
664 
665  if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok()) {
666  return false;
667  }
668  if (!ctx_->sent_initial_metadata_) {
669  ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
670  ctx_->initial_metadata_flags());
671  if (ctx_->compression_level_set()) {
672  ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
673  }
674  ctx_->sent_initial_metadata_ = true;
675  }
676  call_->PerformOps(&ctx_->pending_ops_);
677  // if this is the last message we defer the pluck until AFTER we start
678  // the trailing md op. This prevents hangs. See
679  // https://github.com/grpc/grpc/issues/11546
680  if (options.is_last_message()) {
681  ctx_->has_pending_ops_ = true;
682  return true;
683  }
684  ctx_->has_pending_ops_ = false;
685  return call_->cq()->Pluck(&ctx_->pending_ops_);
686  }
687 
688  private:
689  ::grpc::internal::Call* const call_;
690  ::grpc::ServerContext* const ctx_;
691 
692  template <class ServiceType, class RequestType, class ResponseType>
694 
696  : call_(call), ctx_(ctx) {}
697 };
698 
700 template <class W, class R>
702  public internal::WriterInterface<W>,
703  public internal::ReaderInterface<R> {};
704 
706 namespace internal {
707 template <class W, class R>
709  public:
711  : call_(call), ctx_(ctx) {}
712 
714  GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
715 
717  ops.SendInitialMetadata(&ctx_->initial_metadata_,
718  ctx_->initial_metadata_flags());
719  if (ctx_->compression_level_set()) {
721  }
722  ctx_->sent_initial_metadata_ = true;
723  call_->PerformOps(&ops);
724  call_->cq()->Pluck(&ops);
725  }
726 
727  bool NextMessageSize(uint32_t* sz) {
728  int result = call_->max_receive_message_size();
729  *sz = (result > 0) ? result : UINT32_MAX;
730  return true;
731  }
732 
733  bool Read(R* msg) {
735  ops.RecvMessage(msg);
736  call_->PerformOps(&ops);
737  return call_->cq()->Pluck(&ops) && ops.got_message;
738  }
739 
740  bool Write(const W& msg, ::grpc::WriteOptions options) {
741  if (options.is_last_message()) {
742  options.set_buffer_hint();
743  }
744  if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok()) {
745  return false;
746  }
747  if (!ctx_->sent_initial_metadata_) {
748  ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
749  ctx_->initial_metadata_flags());
750  if (ctx_->compression_level_set()) {
751  ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
752  }
753  ctx_->sent_initial_metadata_ = true;
754  }
755  call_->PerformOps(&ctx_->pending_ops_);
756  // if this is the last message we defer the pluck until AFTER we start
757  // the trailing md op. This prevents hangs. See
758  // https://github.com/grpc/grpc/issues/11546
759  if (options.is_last_message()) {
760  ctx_->has_pending_ops_ = true;
761  return true;
762  }
763  ctx_->has_pending_ops_ = false;
764  return call_->cq()->Pluck(&ctx_->pending_ops_);
765  }
766 
767  private:
768  grpc::internal::Call* const call_;
769  ::grpc::ServerContext* const ctx_;
770 };
771 
772 } // namespace internal
773 
778 template <class W, class R>
780  public:
784  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
785 
786  bool NextMessageSize(uint32_t* sz) override {
787  return body_.NextMessageSize(sz);
788  }
789 
790  bool Read(R* msg) override { return body_.Read(msg); }
791 
798  bool Write(const W& msg, ::grpc::WriteOptions options) override {
799  return body_.Write(msg, options);
800  }
801 
802  private:
804 
806  false>;
808  : body_(call, ctx) {}
809 };
810 
819 template <class RequestType, class ResponseType>
821  : public ServerReaderWriterInterface<ResponseType, RequestType> {
822  public:
827  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
828 
830  bool NextMessageSize(uint32_t* sz) override {
831  return body_.NextMessageSize(sz);
832  }
833 
844  bool Read(RequestType* request) override {
845  if (read_done_) {
846  return false;
847  }
848  read_done_ = true;
849  return body_.Read(request);
850  }
851 
860  bool Write(const ResponseType& response,
861  ::grpc::WriteOptions options) override {
862  if (write_done_ || !read_done_) {
863  return false;
864  }
865  write_done_ = true;
866  return body_.Write(response, options);
867  }
868 
869  private:
871  bool read_done_;
872  bool write_done_;
873 
875  ServerUnaryStreamer<RequestType, ResponseType>, true>;
877  : body_(call, ctx), read_done_(false), write_done_(false) {}
878 };
879 
885 template <class RequestType, class ResponseType>
887  : public ServerReaderWriterInterface<ResponseType, RequestType> {
888  public:
893  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
894 
896  bool NextMessageSize(uint32_t* sz) override {
897  return body_.NextMessageSize(sz);
898  }
899 
910  bool Read(RequestType* request) override {
911  if (read_done_) {
912  return false;
913  }
914  read_done_ = true;
915  return body_.Read(request);
916  }
917 
926  bool Write(const ResponseType& response,
927  ::grpc::WriteOptions options) override {
928  return read_done_ && body_.Write(response, options);
929  }
930 
931  private:
933  bool read_done_;
934 
936  ServerSplitStreamer<RequestType, ResponseType>, false>;
938  : body_(call, ctx), read_done_(false) {}
939 };
940 
941 } // namespace grpc
942 
943 #endif // GRPCPP_IMPL_CODEGEN_SYNC_STREAM_H
Codegen interface for grpc::Channel.
Definition: channel_interface.h:71
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
Synchronous (blocking) client-side API for doing server-streaming RPCs, where the stream of messages ...
Definition: sync_stream.h:176
bool Read(R *msg) override
See the ReaderInterface.Read method for semantics.
Definition: sync_stream.h:206
::grpc::Status Finish() override
See the ClientStreamingInterface.Finish method for semantics.
Definition: sync_stream.h:223
void WaitForInitialMetadata() override
See the ClientStreamingInterface.WaitForInitialMetadata method for semantics.
Definition: sync_stream.h:185
bool NextMessageSize(uint32_t *sz) override
Get an upper bound on the next message size available for reading on this stream.
Definition: sync_stream.h:195
Client-side interface for streaming reads of message of type R.
Definition: sync_stream.h:149
virtual void WaitForInitialMetadata()=0
Block to wait for initial metadata from server.
Synchronous (blocking) client-side API for bi-directional streaming RPCs, where the outgoing message ...
Definition: sync_stream.h:447
::grpc::Status Finish() override
See the ClientStreamingInterface.Finish method for semantics.
Definition: sync_stream.h:528
bool WritesDone() override
Half close writing from the client.
Definition: sync_stream.h:516
bool Write(const W &msg, ::grpc::WriteOptions options) override
Block to write msg to the stream with WriteOptions options.
Definition: sync_stream.h:493
bool NextMessageSize(uint32_t *sz) override
Get an upper bound on the next message size available for reading on this stream.
Definition: sync_stream.h:465
bool Read(R *msg) override
See the ReaderInterface.Read method for semantics.
Definition: sync_stream.h:475
void WaitForInitialMetadata() override
Block waiting to read initial metadata from the server.
Definition: sync_stream.h:455
Client-side interface for bi-directional streaming with client-to-server stream messages of type W an...
Definition: sync_stream.h:412
virtual bool WritesDone()=0
Half close writing from the client.
virtual void WaitForInitialMetadata()=0
Block to wait for initial metadata from server.
Synchronous (blocking) client-side API for doing client-streaming RPCs, where the outgoing message st...
Definition: sync_stream.h:295
::grpc::Status Finish() override
See the ClientStreamingInterface.Finish method for semantics.
Definition: sync_stream.h:356
void WaitForInitialMetadata()
See the ClientStreamingInterface.WaitForInitialMetadata method for semantics.
Definition: sync_stream.h:303
bool WritesDone() override
Half close writing from the client.
Definition: sync_stream.h:343
bool Write(const W &msg, ::grpc::WriteOptions options) override
Block to write msg to the stream with WriteOptions options.
Definition: sync_stream.h:320
Client-side interface for streaming writes of message type W.
Definition: sync_stream.h:267
virtual bool WritesDone()=0
Half close writing from the client.
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:102
A ServerContext or CallbackServerContext allows the code implementing a service handler to:
Definition: server_context.h:538
void set_compression_level(grpc_compression_level level)
Set level to be the compression level used for the server call.
Definition: server_context.h:235
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:243
grpc_compression_level compression_level() const
Return the compression algorithm to be used by the server call.
Definition: server_context.h:228
Synchronous (blocking) server-side API for doing client-streaming RPCs, where the incoming message st...
Definition: sync_stream.h:580
void SendInitialMetadata() override
See the ServerStreamingInterface.SendInitialMetadata method for semantics.
Definition: sync_stream.h:585
bool NextMessageSize(uint32_t *sz) override
Get an upper bound on the next message size available for reading on this stream.
Definition: sync_stream.h:600
bool Read(R *msg) override
Block to read a message and parse to msg.
Definition: sync_stream.h:606
Server-side interface for streaming reads of message of type R.
Definition: sync_stream.h:574
Synchronous (blocking) server-side API for a bidirectional streaming call, where the incoming message...
Definition: sync_stream.h:779
bool Write(const W &msg, ::grpc::WriteOptions options) override
Block to write msg to the stream with WriteOptions options.
Definition: sync_stream.h:798
bool NextMessageSize(uint32_t *sz) override
Get an upper bound on the next message size available for reading on this stream.
Definition: sync_stream.h:786
void SendInitialMetadata() override
See the ServerStreamingInterface.SendInitialMetadata method for semantics.
Definition: sync_stream.h:784
bool Read(R *msg) override
Block to read a message and parse to msg.
Definition: sync_stream.h:790
Server-side interface for bi-directional streaming.
Definition: sync_stream.h:703
A class to represent a flow-controlled server-side streaming call.
Definition: sync_stream.h:887
bool Read(RequestType *request) override
Read a message of type R into msg.
Definition: sync_stream.h:910
void SendInitialMetadata() override
Block to send initial metadata to client.
Definition: sync_stream.h:893
bool Write(const ResponseType &response, ::grpc::WriteOptions options) override
Definition: sync_stream.h:926
bool NextMessageSize(uint32_t *sz) override
Get an upper bound on the request message size from the client.
Definition: sync_stream.h:896
A class to represent a flow-controlled unary call.
Definition: sync_stream.h:821
bool NextMessageSize(uint32_t *sz) override
Get an upper bound on the request message size from the client.
Definition: sync_stream.h:830
bool Read(RequestType *request) override
Read a message of type R into msg.
Definition: sync_stream.h:844
bool Write(const ResponseType &response, ::grpc::WriteOptions options) override
Definition: sync_stream.h:860
void SendInitialMetadata() override
Block to send initial metadata to client.
Definition: sync_stream.h:827
Synchronous (blocking) server-side API for doing for doing a server-streaming RPCs,...
Definition: sync_stream.h:633
void SendInitialMetadata() override
See the ServerStreamingInterface.SendInitialMetadata method for semantics.
Definition: sync_stream.h:639
bool Write(const W &msg, ::grpc::WriteOptions options) override
Block to write msg to the stream with WriteOptions options.
Definition: sync_stream.h:660
Server-side interface for streaming writes of message of type W.
Definition: sync_stream.h:627
Did it work? If it didn't, why?
Definition: status.h:31
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:181
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
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:117
Straightforward wrapping of the C call object.
Definition: call.h:35
void PerformOps(CallOpSetInterface *ops)
Definition: call.h:65
::grpc::CompletionQueue * cq() const
Definition: call.h:70
int max_receive_message_size() const
Definition: call.h:72
Definition: call_op_set.h:769
Definition: call_op_set.h:619
Definition: call_op_set.h:526
Definition: call_op_set.h:721
Definition: call_op_set.h:424
void RecvMessage(R *message)
Definition: call_op_set.h:426
Definition: call_op_set.h:212
void set_compression_level(grpc_compression_level level)
Definition: call_op_set.h:226
void SendInitialMetadata(std::multimap< std::string, std::string > *metadata, uint32_t flags)
Definition: call_op_set.h:218
Definition: call_op_set.h:282
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:867
Definition: sync_stream.h:160
static ClientReader< R > * Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, const W &request)
Definition: sync_stream.h:163
Definition: sync_stream.h:431
static ClientReaderWriter< W, R > * Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context)
Definition: sync_stream.h:433
A wrapper class of an application provided client streaming handler.
Definition: method_handler.h:141
Common interface for all synchronous client side streaming.
Definition: sync_stream.h:34
virtual ~ClientStreamingInterface()
Definition: sync_stream.h:36
virtual ::grpc::Status Finish()=0
Block waiting until the stream finishes and a final status of the call is available.
Definition: sync_stream.h:280
static ClientWriter< W > * Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, R *response)
Definition: sync_stream.h:283
An interface that yields a sequence of messages of type R.
Definition: sync_stream.h:81
virtual ~ReaderInterface()
Definition: sync_stream.h:83
virtual bool NextMessageSize(uint32_t *sz)=0
Get an upper bound on the next message size available for reading on this stream.
virtual bool Read(R *msg)=0
Block to read a message and parse to msg.
Definition: sync_stream.h:708
bool Write(const W &msg, ::grpc::WriteOptions options)
Definition: sync_stream.h:740
void SendInitialMetadata()
Definition: sync_stream.h:713
bool Read(R *msg)
Definition: sync_stream.h:733
ServerReaderWriterBody(grpc::internal::Call *call, ::grpc::ServerContext *ctx)
Definition: sync_stream.h:710
bool NextMessageSize(uint32_t *sz)
Definition: sync_stream.h:727
A wrapper class of an application provided server streaming handler.
Definition: method_handler.h:189
Common interface for all synchronous server side streaming.
Definition: sync_stream.h:66
virtual ~ServerStreamingInterface()
Definition: sync_stream.h:68
virtual void SendInitialMetadata()=0
Block to send initial metadata to client.
A wrapper class of an application provided bidi-streaming handler.
Definition: method_handler.h:262
An interface that can be fed a sequence of messages of type W.
Definition: sync_stream.h:104
virtual ~WriterInterface()
Definition: sync_stream.h:106
bool Write(const W &msg)
Block to write msg to the stream with default write options.
Definition: sync_stream.h:123
virtual bool Write(const W &msg, ::grpc::WriteOptions options)=0
Block to write msg to the stream with WriteOptions options.
void WriteLast(const W &msg, ::grpc::WriteOptions options)
Write msg and coalesce it with the writing of trailing metadata, using WriteOptions options.
Definition: sync_stream.h:139
@ GRPC_CQ_PLUCK
Events are popped out by calling grpc_completion_queue_pluck() API ONLY.
Definition: grpc_types.h:747
#define GRPC_CQ_CURRENT_VERSION
Definition: grpc_types.h:776
@ GRPC_CQ_DEFAULT_POLLING
The completion queue will have an associated pollset and there is no restriction on the type of file ...
Definition: grpc_types.h:727
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
::google::protobuf::util::Status Status
Definition: config_protobuf.h:91
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
Definition: grpc_types.h:778