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
54 const std::multimap<std::string, std::string>& metadata,
55 size_t* metadata_count,
const std::string& optional_error_details) {
56 *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
57 if (*metadata_count == 0) {
64 for (
auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i) {
68 if (!optional_error_details.empty()) {
69 metadata_array[i].
key =
74 return metadata_array;
84 inline void Clear() { flags_ = 0; }
87 inline uint32_t
flags()
const {
return flags_; }
157 last_message_ =
true;
164 last_message_ =
false;
184 void SetBit(
const uint32_t mask) { flags_ |= mask; }
186 void ClearBit(
const uint32_t mask) { flags_ &= ~mask; }
188 bool GetBit(
const uint32_t mask)
const {
return (flags_ & mask) != 0; }
199 template <
int Unused>
309 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
311 serializer_ =
nullptr;
314 if (msg_ !=
nullptr) {
317 serializer_ =
nullptr;
324 write_options_.
Clear();
327 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
329 if (hijacked_ && failed_send_) {
332 }
else if (!*status) {
340 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
343 interceptor_methods->
SetSendMessage(&send_buf_, &msg_, &failed_send_,
349 if (msg_ !=
nullptr || send_buf_.
Valid()) {
357 interceptor_methods->
SetSendMessage(
nullptr,
nullptr, &failed_send_,
366 const void* msg_ =
nullptr;
367 bool hijacked_ =
false;
368 bool failed_send_ =
false;
371 std::function<
Status(
const void*)> serializer_;
376 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;
513 class DeserializeFuncType final :
public DeserializeFunc {
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_);
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>
873 : core_cq_tag_(this),
876 done_intercepting_(false),
883 done_intercepting_ =
false;
889 done_intercepting_ =
false;
894 if (RunInterceptors()) {
903 if (done_intercepting_) {
905 call_.
cq()->CompleteAvalanching();
910 *status = saved_status_;
915 this->Op1::FinishOp(status);
916 this->Op2::FinishOp(status);
917 this->Op3::FinishOp(status);
918 this->Op4::FinishOp(status);
919 this->Op5::FinishOp(status);
920 this->Op6::FinishOp(status);
921 saved_status_ = *status;
922 if (RunInterceptorsPostRecv()) {
945 this->Op1::SetHijackingState(&interceptor_methods_);
946 this->Op2::SetHijackingState(&interceptor_methods_);
947 this->Op3::SetHijackingState(&interceptor_methods_);
948 this->Op4::SetHijackingState(&interceptor_methods_);
949 this->Op5::SetHijackingState(&interceptor_methods_);
950 this->Op6::SetHijackingState(&interceptor_methods_);
955 static const size_t MAX_OPS = 6;
958 this->Op1::AddOp(ops, &nops);
959 this->Op2::AddOp(ops, &nops);
960 this->Op3::AddOp(ops, &nops);
961 this->Op4::AddOp(ops, &nops);
962 this->Op5::AddOp(ops, &nops);
963 this->Op6::AddOp(ops, &nops);
981 done_intercepting_ =
true;
991 bool RunInterceptors() {
994 interceptor_methods_.
SetCall(&call_);
995 this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
996 this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
997 this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
998 this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
999 this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
1000 this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
1006 call_.
cq()->RegisterAvalanching();
1010 bool RunInterceptorsPostRecv() {
1014 this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
1015 this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
1016 this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
1017 this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
1018 this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
1019 this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
1026 bool done_intercepting_ =
false;
1027 InterceptorBatchMethodsImpl interceptor_methods_;
1034 #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:397
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:361
struct grpc_byte_buffer * send_message
This op takes ownership of the slices in send_message.
Definition: grpc_types.h:637
uint32_t flags
Write flags bitset for grpc_begin_messages.
Definition: grpc_types.h:613
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:475
grpc_call_error
Result of a grpc call.
Definition: grpc_types.h:426
WriteOptions & clear_last_message()
Clears flag indicating that this is the last message in a stream, disabling coalescing.
Definition: call_op_set.h:163
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:139
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:135
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:670
Definition: call_op_set.h:619
struct grpc_metadata grpc_metadata
A single metadata element.
grpc_status_code * status
Definition: grpc_types.h:671
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
grpc_status_code
Definition: status.h:26
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:134
@ 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: call_op_set.h:851
virtual void grpc_call_ref(grpc_call *call)=0
Definition: call_op_set.h:282
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:109
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:156
@ POST_RECV_INITIAL_METADATA
The following two are for all clients and servers.
void FinishOp(bool *status)
Definition: call_op_set.h:326
void ClientRecvStatus(::grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:774
void * reserved
Reserved for future usage.
Definition: grpc_types.h:615
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:219
void RecvMessage(R *message)
Definition: call_op_set.h:529
bool is_write_through() const
Definition: call_op_set.h:175
void FillOps(Call *call) override
Definition: call_op_set.h:888
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:284
Straightforward wrapping of the C call object.
Definition: call.h:35
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:428
WriteOptions()
Definition: call_op_set.h:81
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:170
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:204
#define GRPC_WRITE_NO_COMPRESS
Force compression to be disabled for a particular write (start_write/add_metadata).
Definition: grpc_types.h:475
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:208
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:203
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:87
void AddOp(grpc_op *, size_t *)
Definition: call_op_set.h:202
CallOpServerSendStatus()
Definition: call_op_set.h:656
void ContinueFillOpsAfterInterception() override
Definition: call_op_set.h:954
struct grpc_byte_buffer ** recv_message
Definition: grpc_types.h:662
Did it work? If it didn't, why?
Definition: status.h:31
Definition: call_op_set.h:506
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:308
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:934
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:586
bool got_message
Definition: call_op_set.h:431
@ 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:581
@ OK
Not an error; returned on success.
Definition: status_code_enum.h:26
const char kBinaryErrorDetailsKey[]
Definition: metadata_map.h:31
grpc_status_code status
Definition: grpc_types.h:642
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:676
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:192
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:586
bool is_corked() const
Definition: call_op_set.h:149
void Clear()
Remove all data.
Definition: byte_buffer.h:122
Definition: byte_buffer.h:56
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:34
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:472
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:609
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:571
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:944
#define GRPC_WRITE_THROUGH
Force this message to be written to the socket before completing it.
Definition: grpc_types.h:477
grpc_metadata * trailing_metadata
Definition: grpc_types.h:641
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.h:60
std::string error_message() const
Return the instance's error message.
Definition: status.h:112
StatusCode
Definition: status_code_enum.h:24
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::CompletionQueue * cq() const
Definition: call.h:70
grpc_op_type op
Operation type, as defined by grpc_op_type.
Definition: grpc_types.h:611
::google::protobuf::util::Status Status
Definition: config_protobuf.h:90
grpc_slice * status_details
Definition: grpc_types.h:672
DeserializeFuncType(R *message)
Definition: call_op_set.h:515
#define GRPC_SLICE_IS_EMPTY(slice)
Definition: slice.h:107
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:110
virtual void grpc_call_unref(grpc_call *call)=0
Status Deserialize(ByteBuffer *buf) override
Definition: call_op_set.h:516
void set_output_tag(void *return_tag)
Definition: call_op_set.h:932
@ GRPC_OP_RECV_MESSAGE
Receive a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:590
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:626
Per-message write options.
Definition: call_op_set.h:79
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:642
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:206
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
@ 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:567
WriteOptions & clear_corked()
Definition: call_op_set.h:144
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
grpc_call * call() const
Definition: call.h:69
virtual void gpr_free(void *p)=0
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:71
size_t trailing_metadata_count
Definition: grpc_types.h:640
bool FinalizeResult(void **tag, bool *status) override
Definition: call_op_set.h:902
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:117
virtual void grpc_slice_unref(grpc_slice slice)=0
#define GRPC_SLICE_START_PTR(slice)
Definition: slice.h:96
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:100
virtual grpc_slice grpc_empty_slice()=0
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:157
#define GRPC_SLICE_END_PTR(slice)
Definition: slice.h:105
virtual grpc_slice grpc_slice_from_static_buffer(const void *buffer, size_t length)=0
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:96
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:579
bool RunInterceptors()
Definition: interceptor_common.h:246
void Clear()
Clear all flags.
Definition: call_op_set.h:84
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
virtual Status Deserialize(ByteBuffer *buf)=0
Definition: byte_buffer.h:52
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:140
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:53
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:646
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:596
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
Status SendMessage(const M &message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:375
void FinishOp(bool *)
Definition: call_op_set.h:686
WriteOptions & set_no_compression()
Sets flag for the disabling of compression for the next message write.
Definition: call_op_set.h:92
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:940
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:347
Definition: interceptor_common.h:36
std::string error_details() const
Return the (binary) error details.
Definition: status.h:115
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:576
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:126
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:78
Default argument for CallOpSet.
Definition: call_op_set.h:200
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:131
void ContinueFinalizeResultAfterInterception() override
Definition: call_op_set.h:980
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:338
#define GPR_CODEGEN_DEBUG_ASSERT(x)
Codegen specific version of GPR_DEBUG_ASSERT.
Definition: core_codegen_interface.h:155
@ PRE_RECV_INITIAL_METADATA
The following three are for hijacked clients only.