Go to the documentation of this file.
19 #ifndef GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
20 #define GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
56 const std::multimap<std::string, std::string>& metadata,
57 size_t* metadata_count,
const std::string& optional_error_details) {
58 *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
59 if (*metadata_count == 0) {
66 for (
auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i) {
70 if (!optional_error_details.empty()) {
71 metadata_array[i].
key =
76 return metadata_array;
86 inline void Clear() { flags_ = 0; }
89 inline uint32_t
flags()
const {
return flags_; }
159 last_message_ =
true;
166 last_message_ =
false;
191 void SetBit(
const uint32_t mask) { flags_ |= mask; }
193 void ClearBit(
const uint32_t mask) { flags_ &= ~mask; }
195 bool GetBit(
const uint32_t mask)
const {
return (flags_ & mask) != 0; }
206 template <
int Unused>
316 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
318 serializer_ =
nullptr;
321 if (msg_ !=
nullptr) {
324 serializer_ =
nullptr;
331 write_options_.
Clear();
334 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
336 if (hijacked_ && failed_send_) {
339 }
else if (!*status) {
347 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
350 interceptor_methods->
SetSendMessage(&send_buf_, &msg_, &failed_send_,
356 if (msg_ !=
nullptr || send_buf_.
Valid()) {
364 interceptor_methods->
SetSendMessage(
nullptr,
nullptr, &failed_send_,
373 const void* msg_ =
nullptr;
374 bool hijacked_ =
false;
375 bool failed_send_ =
false;
378 std::function<
Status(
const void*)> serializer_;
383 write_options_ = options;
391 message, send_buf_.bbuf_ptr(), &own_buf);
407 write_options_ = options;
409 serializer_ = [
this](
const void* message) {
416 *
static_cast<const M*
>(message), send_buf_.bbuf_ptr(), &own_buf);
442 if (message_ ==
nullptr || hijacked_)
return;
451 if (message_ ==
nullptr)
return;
452 if (recv_buf_.
Valid()) {
462 }
else if (hijacked_) {
463 if (hijacked_recv_message_failed_) {
464 FinishOpRecvMessageFailureHandler(status);
471 FinishOpRecvMessageFailureHandler(status);
477 if (message_ ==
nullptr)
return;
479 &hijacked_recv_message_failed_);
484 if (message_ ==
nullptr)
return;
491 if (message_ ==
nullptr)
return;
499 void FinishOpRecvMessageFailureHandler(
bool* status) {
501 if (!allow_not_getting_message_) {
506 R* message_ =
nullptr;
507 ByteBuffer recv_buf_;
508 bool allow_not_getting_message_ =
false;
509 bool hijacked_ =
false;
510 bool hijacked_recv_message_failed_ =
false;
540 deserialize_.reset(func);
551 if (!deserialize_ || hijacked_)
return;
560 if (!deserialize_)
return;
561 if (recv_buf_.
Valid()) {
564 *status = deserialize_->Deserialize(&recv_buf_).ok();
570 }
else if (hijacked_) {
571 if (hijacked_recv_message_failed_) {
572 FinishOpRecvMessageFailureHandler(status);
580 if (!allow_not_getting_message_) {
588 if (!deserialize_)
return;
590 &hijacked_recv_message_failed_);
595 if (!deserialize_)
return;
599 deserialize_.reset();
603 if (!deserialize_)
return;
611 void FinishOpRecvMessageFailureHandler(
bool* status) {
613 if (!allow_not_getting_message_) {
618 void* message_ =
nullptr;
619 std::unique_ptr<DeserializeFunc> deserialize_;
620 ByteBuffer recv_buf_;
621 bool allow_not_getting_message_ =
false;
622 bool hijacked_ =
false;
623 bool hijacked_recv_message_failed_ =
false;
634 if (!send_ || hijacked_)
return;
657 bool hijacked_ =
false;
666 std::multimap<std::string, std::string>* trailing_metadata,
669 metadata_map_ = trailing_metadata;
670 send_status_available_ =
true;
677 if (!send_status_available_ || hijacked_)
return;
679 *metadata_map_, &trailing_metadata_count_, send_error_details_);
683 trailing_metadata_count_;
688 send_error_message_.empty() ? nullptr : &error_message_slice_;
694 if (!send_status_available_ || hijacked_)
return;
696 send_status_available_ =
false;
701 if (!send_status_available_)
return;
705 interceptor_methods->
SetSendStatus(&send_status_code_, &send_error_details_,
706 &send_error_message_);
717 bool hijacked_ =
false;
718 bool send_status_available_;
720 std::string send_error_details_;
721 std::string send_error_message_;
722 size_t trailing_metadata_count_;
723 std::multimap<std::string, std::string>* metadata_map_;
733 context->initial_metadata_received_ =
true;
734 metadata_map_ = &context->recv_initial_metadata_;
739 if (metadata_map_ ==
nullptr || hijacked_)
return;
748 if (metadata_map_ ==
nullptr || hijacked_)
return;
758 if (metadata_map_ ==
nullptr)
return;
761 metadata_map_ =
nullptr;
766 if (metadata_map_ ==
nullptr)
return;
772 bool hijacked_ =
false;
779 : recv_status_(nullptr), debug_error_string_(nullptr) {}
782 client_context_ = context;
783 metadata_map_ = &client_context_->trailing_metadata_;
784 recv_status_ = status;
790 if (recv_status_ ==
nullptr || hijacked_)
return;
802 if (recv_status_ ==
nullptr || hijacked_)
return;
814 if (debug_error_string_ !=
nullptr) {
815 client_context_->set_debug_error_string(debug_error_string_);
817 const_cast<char*
>(debug_error_string_));
833 if (recv_status_ ==
nullptr)
return;
836 recv_status_ =
nullptr;
841 if (recv_status_ ==
nullptr)
return;
847 bool hijacked_ =
false;
851 const char* debug_error_string_;
856 template <
class Op1 = CallNoOp<1>,
class Op2 = CallNoOp<2>,
857 class Op3 = CallNoOp<3>,
class Op4 = CallNoOp<4>,
858 class Op5 = CallNoOp<5>,
class Op6 = CallNoOp<6>>
867 template <
class Op1,
class Op2,
class Op3,
class Op4,
class Op5,
class Op6>
881 : core_cq_tag_(this),
884 done_intercepting_(false),
888 if (&other ==
this) {
894 done_intercepting_ =
false;
900 done_intercepting_ =
false;
905 if (RunInterceptors()) {
914 if (done_intercepting_) {
916 call_.
cq()->CompleteAvalanching();
921 *status = saved_status_;
926 this->Op1::FinishOp(status);
927 this->Op2::FinishOp(status);
928 this->Op3::FinishOp(status);
929 this->Op4::FinishOp(status);
930 this->Op5::FinishOp(status);
931 this->Op6::FinishOp(status);
932 saved_status_ = *status;
933 if (RunInterceptorsPostRecv()) {
956 this->Op1::SetHijackingState(&interceptor_methods_);
957 this->Op2::SetHijackingState(&interceptor_methods_);
958 this->Op3::SetHijackingState(&interceptor_methods_);
959 this->Op4::SetHijackingState(&interceptor_methods_);
960 this->Op5::SetHijackingState(&interceptor_methods_);
961 this->Op6::SetHijackingState(&interceptor_methods_);
966 static const size_t MAX_OPS = 6;
969 this->Op1::AddOp(ops, &nops);
970 this->Op2::AddOp(ops, &nops);
971 this->Op3::AddOp(ops, &nops);
972 this->Op4::AddOp(ops, &nops);
973 this->Op5::AddOp(ops, &nops);
974 this->Op6::AddOp(ops, &nops);
992 done_intercepting_ =
true;
1002 bool RunInterceptors() {
1005 interceptor_methods_.
SetCall(&call_);
1006 this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
1007 this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
1008 this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
1009 this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
1010 this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
1011 this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
1017 call_.
cq()->RegisterAvalanching();
1021 bool RunInterceptorsPostRecv() {
1025 this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
1026 this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
1027 this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
1028 this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
1029 this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
1030 this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
1037 bool done_intercepting_ =
false;
1038 InterceptorBatchMethodsImpl interceptor_methods_;
1045 #endif // GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
Status SendMessagePtr(const M *message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:404
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:368
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:669
uint32_t flags
Write flags bitset for grpc_begin_messages.
Definition: grpc_types.h:645
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:482
grpc_call_error
Result of a grpc call.
Definition: grpc_types.h:470
WriteOptions & clear_last_message()
Clears flag indicating that this is the last message in a stream, disabling coalescing.
Definition: call_op_set.h:165
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:141
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:137
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:789
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:702
Definition: call_op_set.h:626
struct grpc_metadata grpc_metadata
A single metadata element.
grpc_status_code * status
Definition: grpc_types.h:703
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:489
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:652
CallOpSet()
Definition: call_op_set.h:876
Definition: call_op_set.h:533
Definition: call_op_set.h:661
grpc_status_code
Definition: status.h:28
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:141
@ 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:550
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: call_op_set.h:859
virtual void grpc_call_ref(grpc_call *call)=0
Definition: call_op_set.h:289
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:111
void SetRecvInitialMetadata(MetadataMap *map)
Definition: interceptor_common.h:174
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:158
@ POST_RECV_INITIAL_METADATA
The following two are for all clients and servers.
void FinishOp(bool *status)
Definition: call_op_set.h:333
void * reserved
Reserved for future usage.
Definition: grpc_types.h:647
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:220
void RecvMessage(R *message)
Definition: call_op_set.h:536
bool is_write_through() const
Definition: call_op_set.h:188
void FillOps(Call *call) override
Definition: call_op_set.h:899
void SetCall(Call *call)
Definition: interceptor_common.h:216
bool InterceptorsListEmpty()
Definition: interceptor_common.h:224
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:839
void ClearState()
Definition: interceptor_common.h:202
CallOpSendMessage()
Definition: call_op_set.h:291
Straightforward wrapping of the C call object.
Definition: call.h:36
virtual grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops, size_t nops, void *tag, void *reserved)=0
@ GRPC_CALL_OK
everything went ok
Definition: grpc_types.h:472
WriteOptions()
Definition: call_op_set.h:83
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:178
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:831
void FinishOp(bool *)
Definition: call_op_set.h:640
void ServerSendStatus(std::multimap< std::string, std::string > *trailing_metadata, const Status &status)
Definition: call_op_set.h:665
CallOpClientRecvStatus()
Definition: call_op_set.h:778
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:211
#define GRPC_WRITE_NO_COMPRESS
Force compression to be disabled for a particular write (start_write/add_metadata).
Definition: grpc_types.h:519
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:215
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:475
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:676
union grpc_op::grpc_op_data data
void FinishOp(bool *)
Definition: call_op_set.h:210
void FinishOp(bool *status)
Definition: call_op_set.h:450
CallOpSet(const CallOpSet &other)
Definition: call_op_set.h:880
uint32_t flags() const
Returns raw flags bitset.
Definition: call_op_set.h:89
void AddOp(grpc_op *, size_t *)
Definition: call_op_set.h:209
CallOpServerSendStatus()
Definition: call_op_set.h:663
void ContinueFillOpsAfterInterception() override
Definition: call_op_set.h:965
struct grpc_byte_buffer ** recv_message
Definition: grpc_types.h:694
Did it work? If it didn't, why?
Definition: status.h:35
Definition: call_op_set.h:513
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:315
void SetSendStatus(grpc_status_code *code, std::string *error_details, std::string *error_message)
Definition: interceptor_common.h:157
void * core_cq_tag() override
Definition: call_op_set.h:945
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:601
@ 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:618
bool got_message
Definition: call_op_set.h:438
@ 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:613
void ClientRecvStatus(grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:781
@ OK
Not an error; returned on success.
Definition: status_code_enum.h:28
const char kBinaryErrorDetailsKey[]
Definition: metadata_map.h:33
grpc_status_code status
Definition: grpc_types.h:674
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:708
WriteOptions & clear_write_through()
Definition: call_op_set.h:183
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:195
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:593
bool is_corked() const
Definition: call_op_set.h:151
void Clear()
Remove all data.
Definition: byte_buffer.h:129
Definition: call_op_set.h:520
An abstract collection of call ops, used to generate the grpc_call_op structure to pass down to the l...
Definition: call_op_set_interface.h:36
A sequence of bytes.
Definition: byte_buffer.h:61
virtual void * gpr_malloc(size_t size)=0
#define GRPC_WRITE_BUFFER_HINT
Write Flags:
Definition: grpc_types.h:516
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:825
virtual ~DeserializeFunc()
Definition: call_op_set.h:516
Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT which has no arguments)
Definition: grpc_types.h:641
void SetReverse()
Definition: interceptor_common.h:209
@ GRPC_OP_SEND_MESSAGE
Send a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:603
void SetRecvStatus(Status *status)
Definition: interceptor_common.h:178
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:642
void SetHijackingState() override
Definition: call_op_set.h:955
#define GRPC_WRITE_THROUGH
Force this message to be written to the socket before completing it.
Definition: grpc_types.h:521
grpc_metadata * trailing_metadata
Definition: grpc_types.h:673
void FinishOp(bool *)
Definition: call_op_set.h:801
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:65
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:60
void FinishOp(bool *status)
Definition: call_op_set.h:559
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:441
grpc_op_type op
Operation type, as defined by grpc_op_type.
Definition: grpc_types.h:643
::google::protobuf::util::Status Status
Definition: config_protobuf.h:93
grpc_slice * status_details
Definition: grpc_types.h:704
DeserializeFuncType(R *message)
Definition: call_op_set.h:522
#define GRPC_SLICE_IS_EMPTY(slice)
Definition: slice.h:112
void SetRecvMessage(void *message, bool *hijacked_recv_message_failed)
Definition: interceptor_common.h:169
StatusCode error_code() const
Return the instance's error code.
Definition: status.h:118
virtual void grpc_call_unref(grpc_call *call)=0
Status Deserialize(ByteBuffer *buf) override
Definition: call_op_set.h:523
void set_output_tag(void *return_tag)
Definition: call_op_set.h:943
@ GRPC_OP_RECV_MESSAGE
Receive a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:622
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:633
Per-message write options.
Definition: call_op_set.h:81
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:649
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:213
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:699
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:709
~DeserializeFuncType() override
Definition: call_op_set.h:527
@ 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:599
WriteOptions & clear_corked()
Definition: call_op_set.h:146
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:143
grpc_call * call() const
Definition: call.h:70
virtual void gpr_free(void *p)=0
CallOpSet & operator=(const CallOpSet &other)
Definition: call_op_set.h:887
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:672
bool FinalizeResult(void **tag, bool *status) override
Definition: call_op_set.h:913
Definition: call_op_set.h:776
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:119
virtual void grpc_slice_unref(grpc_slice slice)=0
#define GRPC_SLICE_START_PTR(slice)
Definition: slice.h:101
bool got_message
Definition: call_op_set.h:547
CallOpClientSendClose()
Definition: call_op_set.h:628
WriteOptions & clear_no_compression()
Clears flag for the disabling of compression for the next message write.
Definition: call_op_set.h:102
virtual grpc_slice grpc_empty_slice()=0
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:164
#define GRPC_SLICE_END_PTR(slice)
Definition: slice.h:110
virtual grpc_slice grpc_slice_from_static_buffer(const void *buffer, size_t length)=0
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:98
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:151
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:586
bool RunInterceptors()
Definition: interceptor_common.h:239
void Clear()
Clear all flags.
Definition: call_op_set.h:86
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:174
virtual Status Deserialize(ByteBuffer *buf)=0
Definition: call_op_set.h:431
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:147
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:55
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:678
void ClientSendClose()
Definition: call_op_set.h:630
@ 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:628
void SetRecvTrailingMetadata(MetadataMap *map)
Definition: interceptor_common.h:180
void AllowNoMessage()
Definition: call_op_set.h:545
void SetSendInitialMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:152
Status SendMessage(const M &message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:382
void FinishOp(bool *)
Definition: call_op_set.h:693
WriteOptions & set_no_compression()
Sets flag for the disabling of compression for the next message write.
Definition: call_op_set.h:94
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:951
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:354
Definition: interceptor_common.h:37
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:164
void RecvMessage(R *message)
Definition: call_op_set.h:433
@ 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:608
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:128
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:79
Default argument for CallOpSet.
Definition: call_op_set.h:207
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:712
void AllowNoMessage()
Definition: call_op_set.h:436
grpc_slice SliceReferencingString(const std::string &str)
Definition: slice.h:144
void ContinueFinalizeResultAfterInterception() override
Definition: call_op_set.h:991
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:345
#define GPR_CODEGEN_DEBUG_ASSERT(x)
Codegen specific version of GPR_DEBUG_ASSERT.
Definition: core_codegen_interface.h:160
@ PRE_RECV_INITIAL_METADATA
The following three are for hijacked clients only.