Go to the documentation of this file.
19 #ifndef GRPCPP_IMPL_CALL_OP_SET_H
20 #define GRPCPP_IMPL_CALL_OP_SET_H
55 const std::multimap<std::string, std::string>& metadata,
56 size_t* metadata_count,
const std::string& optional_error_details) {
57 *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
58 if (*metadata_count == 0) {
64 for (
auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i) {
68 if (!optional_error_details.empty()) {
73 return metadata_array;
83 inline void Clear() { flags_ = 0; }
86 inline uint32_t
flags()
const {
return flags_; }
156 last_message_ =
true;
163 last_message_ =
false;
188 void SetBit(
const uint32_t mask) { flags_ |= mask; }
190 void ClearBit(
const uint32_t mask) { flags_ &= ~mask; }
192 bool GetBit(
const uint32_t mask)
const {
return (flags_ & mask) != 0; }
203 template <
int Unused>
313 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
315 serializer_ =
nullptr;
318 if (msg_ !=
nullptr) {
321 serializer_ =
nullptr;
328 write_options_.
Clear();
331 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
333 if (hijacked_ && failed_send_) {
336 }
else if (!*status) {
344 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
347 interceptor_methods->
SetSendMessage(&send_buf_, &msg_, &failed_send_,
353 if (msg_ !=
nullptr || send_buf_.
Valid()) {
361 interceptor_methods->
SetSendMessage(
nullptr,
nullptr, &failed_send_,
370 const void* msg_ =
nullptr;
371 bool hijacked_ =
false;
372 bool failed_send_ =
false;
375 std::function<
Status(
const void*)> serializer_;
380 write_options_ = options;
384 message, send_buf_.bbuf_ptr(), &own_buf);
400 write_options_ = options;
402 serializer_ = [
this](
const void* message) {
409 *
static_cast<const M*
>(message), send_buf_.bbuf_ptr(), &own_buf);
435 if (message_ ==
nullptr || hijacked_)
return;
444 if (message_ ==
nullptr)
return;
445 if (recv_buf_.
Valid()) {
455 }
else if (hijacked_) {
456 if (hijacked_recv_message_failed_) {
457 FinishOpRecvMessageFailureHandler(status);
464 FinishOpRecvMessageFailureHandler(status);
470 if (message_ ==
nullptr)
return;
472 &hijacked_recv_message_failed_);
477 if (message_ ==
nullptr)
return;
484 if (message_ ==
nullptr)
return;
492 void FinishOpRecvMessageFailureHandler(
bool* status) {
494 if (!allow_not_getting_message_) {
499 R* message_ =
nullptr;
500 ByteBuffer recv_buf_;
501 bool allow_not_getting_message_ =
false;
502 bool hijacked_ =
false;
503 bool hijacked_recv_message_failed_ =
false;
533 deserialize_.reset(func);
544 if (!deserialize_ || hijacked_)
return;
553 if (!deserialize_)
return;
554 if (recv_buf_.
Valid()) {
557 *status = deserialize_->Deserialize(&recv_buf_).ok();
563 }
else if (hijacked_) {
564 if (hijacked_recv_message_failed_) {
565 FinishOpRecvMessageFailureHandler(status);
573 if (!allow_not_getting_message_) {
581 if (!deserialize_)
return;
583 &hijacked_recv_message_failed_);
588 if (!deserialize_)
return;
592 deserialize_.reset();
596 if (!deserialize_)
return;
604 void FinishOpRecvMessageFailureHandler(
bool* status) {
606 if (!allow_not_getting_message_) {
611 void* message_ =
nullptr;
612 std::unique_ptr<DeserializeFunc> deserialize_;
613 ByteBuffer recv_buf_;
614 bool allow_not_getting_message_ =
false;
615 bool hijacked_ =
false;
616 bool hijacked_recv_message_failed_ =
false;
627 if (!send_ || hijacked_)
return;
650 bool hijacked_ =
false;
659 std::multimap<std::string, std::string>* trailing_metadata,
662 metadata_map_ = trailing_metadata;
663 send_status_available_ =
true;
670 if (!send_status_available_ || hijacked_)
return;
672 *metadata_map_, &trailing_metadata_count_, send_error_details_);
676 trailing_metadata_count_;
681 send_error_message_.empty() ? nullptr : &error_message_slice_;
687 if (!send_status_available_ || hijacked_)
return;
689 send_status_available_ =
false;
694 if (!send_status_available_)
return;
698 interceptor_methods->
SetSendStatus(&send_status_code_, &send_error_details_,
699 &send_error_message_);
710 bool hijacked_ =
false;
711 bool send_status_available_;
713 std::string send_error_details_;
714 std::string send_error_message_;
715 size_t trailing_metadata_count_;
716 std::multimap<std::string, std::string>* metadata_map_;
726 context->initial_metadata_received_ =
true;
727 metadata_map_ = &context->recv_initial_metadata_;
732 if (metadata_map_ ==
nullptr || hijacked_)
return;
741 if (metadata_map_ ==
nullptr || hijacked_)
return;
751 if (metadata_map_ ==
nullptr)
return;
754 metadata_map_ =
nullptr;
759 if (metadata_map_ ==
nullptr)
return;
765 bool hijacked_ =
false;
772 : recv_status_(nullptr), debug_error_string_(nullptr) {}
775 client_context_ = context;
776 metadata_map_ = &client_context_->trailing_metadata_;
777 recv_status_ = status;
783 if (recv_status_ ==
nullptr || hijacked_)
return;
795 if (recv_status_ ==
nullptr || hijacked_)
return;
807 if (debug_error_string_ !=
nullptr) {
808 client_context_->set_debug_error_string(debug_error_string_);
809 gpr_free(
const_cast<char*
>(debug_error_string_));
825 if (recv_status_ ==
nullptr)
return;
828 recv_status_ =
nullptr;
833 if (recv_status_ ==
nullptr)
return;
839 bool hijacked_ =
false;
843 const char* debug_error_string_;
848 template <
class Op1 = CallNoOp<1>,
class Op2 = CallNoOp<2>,
849 class Op3 = CallNoOp<3>,
class Op4 = CallNoOp<4>,
850 class Op5 = CallNoOp<5>,
class Op6 = CallNoOp<6>>
859 template <
class Op1,
class Op2,
class Op3,
class Op4,
class Op5,
class Op6>
860 class CallOpSet :
public CallOpSetInterface,
873 : core_cq_tag_(this),
876 done_intercepting_(false),
880 if (&other ==
this) {
886 done_intercepting_ =
false;
892 done_intercepting_ =
false;
897 if (RunInterceptors()) {
906 if (done_intercepting_) {
908 call_.
cq()->CompleteAvalanching();
913 *status = saved_status_;
918 this->Op1::FinishOp(status);
919 this->Op2::FinishOp(status);
920 this->Op3::FinishOp(status);
921 this->Op4::FinishOp(status);
922 this->Op5::FinishOp(status);
923 this->Op6::FinishOp(status);
924 saved_status_ = *status;
925 if (RunInterceptorsPostRecv()) {
948 this->Op1::SetHijackingState(&interceptor_methods_);
949 this->Op2::SetHijackingState(&interceptor_methods_);
950 this->Op3::SetHijackingState(&interceptor_methods_);
951 this->Op4::SetHijackingState(&interceptor_methods_);
952 this->Op5::SetHijackingState(&interceptor_methods_);
953 this->Op6::SetHijackingState(&interceptor_methods_);
958 static const size_t MAX_OPS = 6;
961 this->Op1::AddOp(ops, &nops);
962 this->Op2::AddOp(ops, &nops);
963 this->Op3::AddOp(ops, &nops);
964 this->Op4::AddOp(ops, &nops);
965 this->Op5::AddOp(ops, &nops);
966 this->Op6::AddOp(ops, &nops);
984 done_intercepting_ =
true;
993 bool RunInterceptors() {
996 interceptor_methods_.
SetCall(&call_);
997 this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
998 this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
999 this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
1000 this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
1001 this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
1002 this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
1008 call_.
cq()->RegisterAvalanching();
1012 bool RunInterceptorsPostRecv() {
1016 this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
1017 this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
1018 this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
1019 this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
1020 this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
1021 this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
1028 bool done_intercepting_ =
false;
1029 InterceptorBatchMethodsImpl interceptor_methods_;
1036 #endif // GRPCPP_IMPL_CALL_OP_SET_H
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:365
GPRAPI void * gpr_malloc(size_t size)
malloc.
grpc::CompletionQueue * cq() const
Definition: call.h:71
struct grpc_byte_buffer * send_message
This op takes ownership of the slices in send_message.
Definition: grpc_types.h:340
uint32_t flags
Write flags bitset for grpc_begin_messages.
Definition: grpc_types.h:316
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:475
GPRAPI grpc_slice grpc_empty_slice(void)
grpc_call_error
Result of a grpc call.
Definition: grpc_types.h:141
WriteOptions & clear_last_message()
Clears flag indicating that this is the last message in a stream, disabling coalescing.
Definition: call_op_set.h:162
WriteOptions & set_corked()
corked bit: aliases set_buffer_hint currently, with the intent that set_buffer_hint will be removed i...
Definition: call_op_set.h:138
bool get_buffer_hint() const
Get value for the flag indicating that the write may be buffered and need not go out on the wire imme...
Definition: call_op_set.h:134
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:782
grpc_metadata_array * trailing_metadata
ownership of the array is with the caller, but ownership of the elements stays with the call object (...
Definition: grpc_types.h:373
Definition: call_op_set.h:619
grpc_status_code * status
Definition: grpc_types.h:374
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:482
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:645
CallOpSet()
Definition: call_op_set.h:868
Definition: call_op_set.h:526
Definition: call_op_set.h:654
#define GRPC_SLICE_START_PTR(slice)
Definition: slice_type.h:99
void Duplicate()
Make a duplicate copy of the internals of this byte buffer so that we have our own owned version of i...
Definition: byte_buffer.h:140
@ PRE_SEND_INITIAL_METADATA
The first three in this list are for clients and servers.
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:543
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:96
#define GPR_DEBUG_ASSERT(x)
Definition: log.h:103
Definition: call_op_set.h:286
#define GRPC_SLICE_END_PTR(slice)
Definition: slice_type.h:108
struct grpc_op::grpc_op_data::grpc_op_send_initial_metadata send_initial_metadata
bool get_no_compression() const
Get value for the flag indicating whether compression for the next message write is forcefully disabl...
Definition: call_op_set.h:108
grpc_status_code
Definition: status.h:28
void SetRecvInitialMetadata(MetadataMap *map)
Definition: interceptor_common.h:173
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:155
@ POST_RECV_INITIAL_METADATA
The following two are for all clients and servers.
void FinishOp(bool *status)
Definition: call_op_set.h:330
void * reserved
Reserved for future usage.
Definition: grpc_types.h:318
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:219
void RecvMessage(R *message)
Definition: call_op_set.h:529
#define GPR_ERROR
Definition: log.h:55
bool is_write_through() const
Definition: call_op_set.h:185
void FillOps(Call *call) override
Definition: call_op_set.h:891
void SetCall(Call *call)
Definition: interceptor_common.h:215
bool InterceptorsListEmpty()
Definition: interceptor_common.h:223
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:831
void ClearState()
Definition: interceptor_common.h:201
CallOpSendMessage()
Definition: call_op_set.h:288
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
@ GRPC_CALL_OK
everything went ok
Definition: grpc_types.h:143
WriteOptions()
Definition: call_op_set.h:80
WriteOptions & set_write_through()
Guarantee that all bytes have been written to the socket before completing this write (usually writes...
Definition: call_op_set.h:175
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:823
void FinishOp(bool *)
Definition: call_op_set.h:633
void ServerSendStatus(std::multimap< std::string, std::string > *trailing_metadata, const Status &status)
Definition: call_op_set.h:658
CallOpClientRecvStatus()
Definition: call_op_set.h:771
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:208
GRPCAPI void grpc_call_ref(grpc_call *call)
Ref a call.
#define GRPC_WRITE_NO_COMPRESS
Force compression to be disabled for a particular write (start_write/add_metadata).
Definition: grpc_types.h:190
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:212
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:468
struct grpc_op::grpc_op_data::grpc_op_recv_message recv_message
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:669
union grpc_op::grpc_op_data data
void FinishOp(bool *)
Definition: call_op_set.h:207
void FinishOp(bool *status)
Definition: call_op_set.h:443
CallOpSet(const CallOpSet &other)
Definition: call_op_set.h:872
uint32_t flags() const
Returns raw flags bitset.
Definition: call_op_set.h:86
GPRAPI void gpr_free(void *ptr)
free
void AddOp(grpc_op *, size_t *)
Definition: call_op_set.h:206
CallOpServerSendStatus()
Definition: call_op_set.h:656
void ContinueFillOpsAfterInterception() override
Definition: call_op_set.h:957
struct grpc_byte_buffer ** recv_message
Definition: grpc_types.h:365
Did it work? If it didn't, why?
Definition: status.h:35
Definition: call_op_set.h:506
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:312
void SetSendStatus(grpc_status_code *code, std::string *error_details, std::string *error_message)
Definition: interceptor_common.h:156
void * core_cq_tag() override
Definition: call_op_set.h:937
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:594
@ GRPC_OP_RECV_INITIAL_METADATA
Receive initial metadata: one and only one MUST be made on the client, must not be made on the server...
Definition: grpc_types.h:289
bool got_message
Definition: call_op_set.h:431
GRPC_MUST_USE_RESULT Status SendMessage(const M &message, WriteOptions options)
Send message using options for the write.
@ GRPC_OP_SEND_STATUS_FROM_SERVER
Send status from the server: one and only one instance MUST be sent from the server unless the call w...
Definition: grpc_types.h:284
void ClientRecvStatus(grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:774
#define GRPC_SLICE_IS_EMPTY(slice)
Definition: slice_type.h:110
@ OK
Not an error; returned on success.
Definition: status_code_enum.h:28
const char kBinaryErrorDetailsKey[]
Definition: metadata_map.h:32
GRPCAPI void grpc_call_unref(grpc_call *call)
Unref a call.
grpc_status_code status
Definition: grpc_types.h:345
const char ** error_string
If this is not nullptr, it will be populated with the full fidelity error string for debugging purpos...
Definition: grpc_types.h:379
WriteOptions & clear_write_through()
Definition: call_op_set.h:180
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:586
bool is_corked() const
Definition: call_op_set.h:148
void Clear()
Remove all data.
Definition: byte_buffer.h:128
Definition: call_op_set.h:513
A sequence of bytes.
Definition: byte_buffer.h:60
GRPC_MUST_USE_RESULT Status SendMessagePtr(const M *message, WriteOptions options)
Send message using options for the write.
#define GRPC_WRITE_BUFFER_HINT
Write Flags:
Definition: grpc_types.h:187
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:817
virtual ~DeserializeFunc()
Definition: call_op_set.h:509
Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT which has no arguments)
Definition: grpc_types.h:312
void SetReverse()
Definition: interceptor_common.h:208
@ GRPC_OP_SEND_MESSAGE
Send a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:274
void SetRecvStatus(Status *status)
Definition: interceptor_common.h:177
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:635
void SetHijackingState() override
Definition: call_op_set.h:947
#define GRPC_WRITE_THROUGH
Force this message to be written to the socket before completing it.
Definition: grpc_types.h:192
grpc_metadata * trailing_metadata
Definition: grpc_types.h:344
void FinishOp(bool *)
Definition: call_op_set.h:794
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice_type.h:63
std::string error_message() const
Return the instance's error message.
Definition: status.h:120
StatusCode
Definition: status_code_enum.h:26
Defines how to serialize and deserialize some type.
Definition: serialization_traits.h:58
void FinishOp(bool *status)
Definition: call_op_set.h:552
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:434
grpc_op_type op
Operation type, as defined by grpc_op_type.
Definition: grpc_types.h:314
grpc_slice * status_details
Definition: grpc_types.h:375
DeserializeFuncType(R *message)
Definition: call_op_set.h:515
void SetRecvMessage(void *message, bool *hijacked_recv_message_failed)
Definition: interceptor_common.h:168
StatusCode error_code() const
Return the instance's error code.
Definition: status.h:118
Status Deserialize(ByteBuffer *buf) override
Definition: call_op_set.h:516
void set_output_tag(void *return_tag)
Definition: call_op_set.h:935
@ GRPC_OP_RECV_MESSAGE
Receive a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:293
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:626
Per-message write options.
Definition: call_op_set.h:78
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:642
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:210
struct grpc_op::grpc_op_data::grpc_op_send_status_from_server send_status_from_server
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:692
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:702
~DeserializeFuncType() override
Definition: call_op_set.h:520
GPRAPI grpc_slice grpc_slice_from_static_buffer(const void *source, size_t len)
Create a slice pointing to constant memory.
@ GRPC_OP_SEND_INITIAL_METADATA
Send initial metadata: one and only one instance MUST be sent for each call, unless the call was canc...
Definition: grpc_types.h:270
WriteOptions & clear_corked()
Definition: call_op_set.h:143
struct grpc_op::grpc_op_data::grpc_op_send_message send_message
void SetSendMessage(ByteBuffer *buf, const void **msg, bool *fail_send_message, std::function< Status(const void *)> serializer)
Definition: interceptor_common.h:142
GPRAPI void gpr_log(const char *file, int line, gpr_log_severity severity, const char *format,...) GPR_PRINT_FORMAT_CHECK(4
Log a message.
grpc_call * call() const
Definition: call.h:70
CallOpSet & operator=(const CallOpSet &other)
Definition: call_op_set.h:879
struct grpc_op::grpc_op_data::grpc_op_recv_status_on_client recv_status_on_client
grpc_compression_level
Compression levels allow a party with knowledge of its peer's accepted encodings to request compressi...
Definition: compression_types.h:72
size_t trailing_metadata_count
Definition: grpc_types.h:343
bool FinalizeResult(void **tag, bool *status) override
Definition: call_op_set.h:905
Definition: call_op_set.h:769
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:116
const GRPCAPI char * grpc_call_error_to_string(grpc_call_error error)
Convert grpc_call_error values to a string.
bool got_message
Definition: call_op_set.h:540
CallOpClientSendClose()
Definition: call_op_set.h:621
WriteOptions & clear_no_compression()
Clears flag for the disabling of compression for the next message write.
Definition: call_op_set.h:99
GPRAPI void grpc_slice_unref(grpc_slice s)
Decrement the ref count of s.
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:159
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:579
bool RunInterceptors()
Definition: interceptor_common.h:238
void Clear()
Clear all flags.
Definition: call_op_set.h:83
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:171
virtual Status Deserialize(ByteBuffer *buf)=0
Definition: call_op_set.h:424
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:144
grpc_metadata * FillMetadataArray(const std::multimap< std::string, std::string > &metadata, size_t *metadata_count, const std::string &optional_error_details)
Definition: call_op_set.h:54
struct grpc_op::grpc_op_data::grpc_op_recv_initial_metadata recv_initial_metadata
grpc_slice * status_details
optional: set to NULL if no details need sending, non-NULL if they do pointer will not be retained pa...
Definition: grpc_types.h:349
void ClientSendClose()
Definition: call_op_set.h:623
@ GRPC_OP_RECV_STATUS_ON_CLIENT
Receive status on the client: one and only one must be made on the client.
Definition: grpc_types.h:299
void SetRecvTrailingMetadata(MetadataMap *map)
Definition: interceptor_common.h:179
void AllowNoMessage()
Definition: call_op_set.h:538
void SetSendInitialMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:151
void FinishOp(bool *)
Definition: call_op_set.h:686
::absl::Status Status
Definition: config_protobuf.h:97
WriteOptions & set_no_compression()
Sets flag for the disabling of compression for the next message write.
Definition: call_op_set.h:91
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
GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops, size_t nops, void *tag, void *reserved)
Start a batch of operations defined in the array ops; when complete, post a completion of type 'tag' ...
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:351
Definition: interceptor_common.h:36
std::string error_details() const
Return the (binary) error details.
Definition: status.h:123
void SetSendTrailingMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:163
void RecvMessage(R *message)
Definition: call_op_set.h:426
@ GRPC_OP_SEND_CLOSE_FROM_CLIENT
Send a close from the client: one and only one instance MUST be sent from the client,...
Definition: grpc_types.h:279
WriteOptions & clear_buffer_hint()
Clears flag indicating that the write may be buffered and need not go out on the wire immediately.
Definition: call_op_set.h:125
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:78
Default argument for CallOpSet.
Definition: call_op_set.h:204
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:705
void AllowNoMessage()
Definition: call_op_set.h:429
grpc_slice SliceReferencingString(const std::string &str)
Definition: slice.h:132
void ContinueFinalizeResultAfterInterception() override
Definition: call_op_set.h:983
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:342
@ PRE_RECV_INITIAL_METADATA
The following three are for hijacked clients only.