19 #ifndef GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
20 #define GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
54 const std::multimap<grpc::string, grpc::string>& metadata,
55 size_t* metadata_count,
const grpc::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;
83 : flags_(other.flags_), last_message_(other.last_message_) {}
89 inline void Clear() { flags_ = 0; }
92 inline uint32_t
flags()
const {
return flags_; }
162 last_message_ =
true;
169 last_message_ =
false;
189 void SetBit(
const uint32_t mask) { flags_ |= mask; }
191 void ClearBit(
const uint32_t mask) { flags_ &= ~mask; }
193 bool GetBit(
const uint32_t mask)
const {
return (flags_ & mask) != 0; }
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;
332 if (hijacked_ && failed_send_) {
335 }
else if (!*status) {
343 if (msg_ ==
nullptr && !send_buf_.
Valid())
return;
346 interceptor_methods->
SetSendMessage(&send_buf_, &msg_, &failed_send_,
352 if (msg_ !=
nullptr || send_buf_.
Valid()) {
360 interceptor_methods->
SetSendMessage(
nullptr,
nullptr, &failed_send_,
369 const void* msg_ =
nullptr;
370 bool hijacked_ =
false;
371 bool failed_send_ =
false;
374 std::function<
Status(
const void*)> serializer_;
379 write_options_ = options;
380 serializer_ = [
this](
const void* message) {
388 *
static_cast<const M*
>(message), send_buf_.bbuf_ptr(), &own_buf);
395 if (msg_ ==
nullptr) {
396 Status result = serializer_(&message);
397 serializer_ =
nullptr;
427 allow_not_getting_message_(false) {}
438 if (message_ ==
nullptr || hijacked_)
return;
447 if (message_ ==
nullptr || hijacked_)
return;
448 if (recv_buf_.
Valid()) {
460 if (!allow_not_getting_message_) {
468 if (message_ ==
nullptr)
return;
474 if (message_ ==
nullptr)
return;
481 if (message_ ==
nullptr)
return;
490 bool allow_not_getting_message_;
491 bool hijacked_ =
false;
517 :
got_message(false), allow_not_getting_message_(false) {}
524 deserialize_.reset(func);
535 if (!deserialize_ || hijacked_)
return;
544 if (!deserialize_ || hijacked_)
return;
545 if (recv_buf_.
Valid()) {
548 *status = deserialize_->Deserialize(&recv_buf_).ok();
556 if (!allow_not_getting_message_) {
564 if (!deserialize_)
return;
570 if (!deserialize_)
return;
574 deserialize_.reset();
578 if (!deserialize_)
return;
586 bool hijacked_ =
false;
587 std::unique_ptr<DeserializeFunc> deserialize_;
589 bool allow_not_getting_message_;
600 if (!send_ || hijacked_)
return;
623 bool hijacked_ =
false;
632 std::multimap<grpc::string, grpc::string>* trailing_metadata,
635 metadata_map_ = trailing_metadata;
636 send_status_available_ =
true;
643 if (!send_status_available_ || hijacked_)
return;
645 *metadata_map_, &trailing_metadata_count_, send_error_details_);
649 trailing_metadata_count_;
654 send_error_message_.empty() ? nullptr : &error_message_slice_;
660 if (!send_status_available_ || hijacked_)
return;
662 send_status_available_ =
false;
667 if (!send_status_available_)
return;
671 interceptor_methods->
SetSendStatus(&send_status_code_, &send_error_details_,
672 &send_error_message_);
683 bool hijacked_ =
false;
684 bool send_status_available_;
688 size_t trailing_metadata_count_;
689 std::multimap<grpc::string, grpc::string>* metadata_map_;
699 context->initial_metadata_received_ =
true;
700 metadata_map_ = &context->recv_initial_metadata_;
705 if (metadata_map_ ==
nullptr || hijacked_)
return;
714 if (metadata_map_ ==
nullptr || hijacked_)
return;
724 if (metadata_map_ ==
nullptr)
return;
727 metadata_map_ =
nullptr;
732 if (metadata_map_ ==
nullptr)
return;
738 bool hijacked_ =
false;
745 : recv_status_(nullptr), debug_error_string_(nullptr) {}
748 client_context_ = context;
749 metadata_map_ = &client_context_->trailing_metadata_;
750 recv_status_ = status;
756 if (recv_status_ ==
nullptr || hijacked_)
return;
768 if (recv_status_ ==
nullptr || hijacked_)
return;
780 if (debug_error_string_ !=
nullptr) {
781 client_context_->set_debug_error_string(debug_error_string_);
798 if (recv_status_ ==
nullptr)
return;
801 recv_status_ =
nullptr;
806 if (recv_status_ ==
nullptr)
return;
812 bool hijacked_ =
false;
816 const char* debug_error_string_;
821 template <
class Op1 = CallNoOp<1>,
class Op2 = CallNoOp<2>,
822 class Op3 = CallNoOp<3>,
class Op4 = CallNoOp<4>,
823 class Op5 = CallNoOp<5>,
class Op6 = CallNoOp<6>>
832 template <
class Op1,
class Op2,
class Op3,
class Op4,
class Op5,
class Op6>
846 : core_cq_tag_(this),
849 done_intercepting_(false),
856 done_intercepting_ =
false;
862 done_intercepting_ =
false;
867 if (RunInterceptors()) {
876 if (done_intercepting_) {
878 call_.
cq()->CompleteAvalanching();
883 *status = saved_status_;
888 this->Op1::FinishOp(status);
889 this->Op2::FinishOp(status);
890 this->Op3::FinishOp(status);
891 this->Op4::FinishOp(status);
892 this->Op5::FinishOp(status);
893 this->Op6::FinishOp(status);
894 saved_status_ = *status;
895 if (RunInterceptorsPostRecv()) {
918 this->Op1::SetHijackingState(&interceptor_methods_);
919 this->Op2::SetHijackingState(&interceptor_methods_);
920 this->Op3::SetHijackingState(&interceptor_methods_);
921 this->Op4::SetHijackingState(&interceptor_methods_);
922 this->Op5::SetHijackingState(&interceptor_methods_);
923 this->Op6::SetHijackingState(&interceptor_methods_);
928 static const size_t MAX_OPS = 6;
931 this->Op1::AddOp(ops, &nops);
932 this->Op2::AddOp(ops, &nops);
933 this->Op3::AddOp(ops, &nops);
934 this->Op4::AddOp(ops, &nops);
935 this->Op5::AddOp(ops, &nops);
936 this->Op6::AddOp(ops, &nops);
954 done_intercepting_ =
true;
964 bool RunInterceptors() {
967 interceptor_methods_.
SetCall(&call_);
968 this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
969 this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
970 this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
971 this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
972 this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
973 this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
979 call_.
cq()->RegisterAvalanching();
983 bool RunInterceptorsPostRecv() {
987 this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
988 this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
989 this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
990 this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
991 this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
992 this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
999 bool done_intercepting_ =
false;
1000 InterceptorBatchMethodsImpl interceptor_methods_;
A sequence of bytes.
Definition: byte_buffer.h:67
void Clear()
Remove all data.
Definition: byte_buffer.h:128
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
void Release()
Forget underlying byte buffer without destroying Use this only for un-owned byte buffers.
Definition: byte_buffer.h:146
bool Valid() const
Is this ByteBuffer valid?
Definition: byte_buffer.h:163
virtual void grpc_call_unref(grpc_call *call)=0
virtual grpc_slice grpc_empty_slice()=0
virtual void grpc_slice_unref(grpc_slice slice)=0
virtual void grpc_call_ref(grpc_call *call)=0
virtual void gpr_free(void *p)=0
virtual grpc_slice grpc_slice_from_static_buffer(const void *buffer, size_t length)=0
virtual void * gpr_malloc(size_t size)=0
virtual grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops, size_t nops, void *tag, void *reserved)=0
Defines how to serialize and deserialize some type.
Definition: serialization_traits.h:58
Did it work? If it didn't, why?
Definition: status.h:31
StatusCode error_code() const
Return the instance's error code.
Definition: status.h:110
grpc::string error_message() const
Return the instance's error message.
Definition: status.h:112
grpc::string error_details() const
Return the (binary) error details.
Definition: status.h:115
Per-message write options.
Definition: call_op_set.h:79
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:114
bool is_write_through() const
Definition: call_op_set.h:180
bool is_corked() const
Definition: call_op_set.h:154
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:140
WriteOptions & operator=(const WriteOptions &other)=default
Default assignment operator.
WriteOptions(const WriteOptions &other)
Definition: call_op_set.h:82
WriteOptions()
Definition: call_op_set.h:81
WriteOptions & clear_no_compression()
Clears flag for the disabling of compression for the next message write.
Definition: call_op_set.h:105
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:186
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:131
void Clear()
Clear all flags.
Definition: call_op_set.h:89
WriteOptions & clear_last_message()
Clears flag indicating that this is the last message in a stream, disabling coalescing.
Definition: call_op_set.h:168
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
WriteOptions & clear_corked()
Definition: call_op_set.h:149
uint32_t flags() const
Returns raw flags bitset.
Definition: call_op_set.h:92
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:144
WriteOptions & set_last_message()
last-message bit: indicates this is the last message in a stream client-side: makes Write the equival...
Definition: call_op_set.h:161
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:122
WriteOptions & set_no_compression()
Sets flag for the disabling of compression for the next message write.
Definition: call_op_set.h:97
Straightforward wrapping of the C call object.
Definition: call.h:38
grpc_call * call() const
Definition: call.h:72
::grpc_impl::CompletionQueue * cq() const
Definition: call.h:73
Default argument for CallOpSet.
Definition: call_op_set.h:204
void AddOp(grpc_op *, size_t *)
Definition: call_op_set.h:206
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:208
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:212
void FinishOp(bool *)
Definition: call_op_set.h:207
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:210
Definition: call_op_set.h:742
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:790
void ClientRecvStatus(::grpc_impl::ClientContext *context, Status *status)
Definition: call_op_set.h:747
void FinishOp(bool *)
Definition: call_op_set.h:767
CallOpClientRecvStatus()
Definition: call_op_set.h:744
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:796
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:755
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:804
Definition: call_op_set.h:592
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:618
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:599
CallOpClientSendClose()
Definition: call_op_set.h:594
void ClientSendClose()
Definition: call_op_set.h:596
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:608
void FinishOp(bool *)
Definition: call_op_set.h:606
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:615
Definition: call_op_set.h:514
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:576
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:568
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:534
CallOpGenericRecvMessage()
Definition: call_op_set.h:516
bool got_message
Definition: call_op_set.h:531
void FinishOp(bool *status)
Definition: call_op_set.h:543
void RecvMessage(R *message)
Definition: call_op_set.h:520
void AllowNoMessage()
Definition: call_op_set.h:529
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:562
Definition: call_op_set.h:422
CallOpRecvMessage()
Definition: call_op_set.h:424
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:479
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:466
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:437
void RecvMessage(R *message)
Definition: call_op_set.h:429
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:472
bool got_message
Definition: call_op_set.h:434
void FinishOp(bool *status)
Definition: call_op_set.h:446
void AllowNoMessage()
Definition: call_op_set.h:432
Definition: call_op_set.h:286
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:350
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:364
Status SendMessagePtr(const M *message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:409
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:312
void FinishOp(bool *status)
Definition: call_op_set.h:330
CallOpSendMessage()
Definition: call_op_set.h:288
Status SendMessage(const M &message, WriteOptions options) GRPC_MUST_USE_RESULT
Send message using options for the write.
Definition: call_op_set.h:378
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:341
Definition: call_op_set.h:627
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:675
void FinishOp(bool *)
Definition: call_op_set.h:659
CallOpServerSendStatus()
Definition: call_op_set.h:629
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:642
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:665
void ServerSendStatus(std::multimap< grpc::string, grpc::string > *trailing_metadata, const Status &status)
Definition: call_op_set.h:631
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:678
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:839
CallOpSet(const CallOpSet &other)
Definition: call_op_set.h:845
bool FinalizeResult(void **tag, bool *status) override
FinalizeResult must be called before informing user code that the operation bound to the underlying c...
Definition: call_op_set.h:875
void ContinueFinalizeResultAfterInterception() override
Definition: call_op_set.h:953
CallOpSet & operator=(const CallOpSet &other)
Definition: call_op_set.h:852
void * core_cq_tag() override
Get the tag to be used at the core completion queue.
Definition: call_op_set.h:907
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:913
void set_output_tag(void *return_tag)
Definition: call_op_set.h:905
CallOpSet()
Definition: call_op_set.h:841
void ContinueFillOpsAfterInterception() override
Definition: call_op_set.h:927
void FillOps(Call *call) override
Fills in grpc_op, starting from ops[*nops] and moving upwards.
Definition: call_op_set.h:861
void SetHijackingState() override
Definition: call_op_set.h:917
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
Definition: call_op_set.h:494
virtual ~DeserializeFunc()
Definition: call_op_set.h:497
virtual Status Deserialize(ByteBuffer *buf)=0
Definition: call_op_set.h:501
~DeserializeFuncType() override
Definition: call_op_set.h:508
Status Deserialize(ByteBuffer *buf) override
Definition: call_op_set.h:504
DeserializeFuncType(R *message)
Definition: call_op_set.h:503
Definition: interceptor_common.h:37
void SetSendInitialMetadata(std::multimap< grpc::string, grpc::string > *metadata)
Definition: interceptor_common.h:152
bool RunInterceptors()
Definition: interceptor_common.h:247
void SetSendStatus(grpc_status_code *code, grpc::string *error_details, grpc::string *error_message)
Definition: interceptor_common.h:157
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:220
void SetSendTrailingMetadata(std::multimap< grpc::string, grpc::string > *metadata)
Definition: interceptor_common.h:164
void SetRecvTrailingMetadata(MetadataMap *map)
Definition: interceptor_common.h:180
void ClearState()
Definition: interceptor_common.h:202
void SetReverse()
Definition: interceptor_common.h:209
void SetSendMessage(ByteBuffer *buf, const void **msg, bool *fail_send_message, std::function< Status(const void *)> serializer)
Definition: interceptor_common.h:143
void SetRecvInitialMetadata(MetadataMap *map)
Definition: interceptor_common.h:174
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:78
bool InterceptorsListEmpty()
Definition: interceptor_common.h:224
void SetCall(Call *call)
Definition: interceptor_common.h:216
void SetRecvStatus(Status *status)
Definition: interceptor_common.h:178
void SetRecvMessage(void *message, bool *got_message)
Definition: interceptor_common.h:169
A ClientContext allows the person implementing a service client to:
Definition: client_context_impl.h:184
grpc_compression_level
Compression levels allow a party with knowledge of its peer's accepted encodings to request compressi...
Definition: compression_types.h:71
#define GRPC_SLICE_IS_EMPTY(slice)
Definition: slice.h:107
#define GRPC_SLICE_START_PTR(slice)
Definition: slice.h:96
#define GRPC_SLICE_END_PTR(slice)
Definition: slice.h:105
grpc_status_code
Definition: status.h:26
grpc_call_error
Result of a grpc call.
Definition: grpc_types.h:407
@ GRPC_CALL_OK
everything went ok
Definition: grpc_types.h:409
struct grpc_metadata grpc_metadata
A single metadata element.
@ 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:562
@ 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:577
@ 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:557
@ GRPC_OP_SEND_MESSAGE
Send a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:552
@ 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:567
@ 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:548
@ GRPC_OP_RECV_MESSAGE
Receive a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:571
#define GRPC_WRITE_THROUGH
Force this message to be written to the socket before completing it.
Definition: grpc_types.h:458
#define GRPC_WRITE_BUFFER_HINT
Write Flags:
Definition: grpc_types.h:453
#define GRPC_WRITE_NO_COMPRESS
Force compression to be disabled for a particular write (start_write/add_metadata).
Definition: grpc_types.h:456
#define GPR_CODEGEN_ASSERT(x)
Codegen specific version of GPR_ASSERT.
Definition: core_codegen_interface.h:146
#define GPR_CODEGEN_DEBUG_ASSERT(x)
Codegen specific version of GPR_DEBUG_ASSERT.
Definition: core_codegen_interface.h:155
@ POST_RECV_INITIAL_METADATA
The following two are for all clients and servers.
@ PRE_SEND_INITIAL_METADATA
The first three in this list are for clients and servers.
@ PRE_RECV_INITIAL_METADATA
The following three are for hijacked clients only.
const char kBinaryErrorDetailsKey[]
Definition: metadata_map.h:31
grpc_metadata * FillMetadataArray(const std::multimap< grpc::string, grpc::string > &metadata, size_t *metadata_count, const grpc::string &optional_error_details)
Definition: call_op_set.h:53
::google::protobuf::util::Status Status
Definition: config_protobuf.h:90
This header provides an object that reads bytes directly from a grpc::ByteBuffer, via the ZeroCopyInp...
Definition: alarm.h:24
grpc_slice SliceReferencingString(const grpc::string &str)
Definition: slice.h:131
std::string string
Definition: config.h:35
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue_impl.h:90
StatusCode
Definition: status_code_enum.h:24
@ OK
Not an error; returned on success.
Definition: status_code_enum.h:26
struct grpc_byte_buffer ** recv_message
Definition: grpc_types.h:643
grpc_status_code * status
Definition: grpc_types.h:652
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:657
grpc_slice * status_details
Definition: grpc_types.h:653
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:651
struct grpc_byte_buffer * send_message
This op takes ownership of the slices in send_message.
Definition: grpc_types.h:618
grpc_metadata * trailing_metadata
Definition: grpc_types.h:622
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:627
size_t trailing_metadata_count
Definition: grpc_types.h:621
grpc_status_code status
Definition: grpc_types.h:623
Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT which has no arguments)
Definition: grpc_types.h:590
union grpc_op::grpc_op_data data
void * reserved
Reserved for future usage.
Definition: grpc_types.h:596
uint32_t flags
Write flags bitset for grpc_begin_messages.
Definition: grpc_types.h:594
grpc_op_type op
Operation type, as defined by grpc_op_type.
Definition: grpc_types.h:592
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:60
struct grpc_op::grpc_op_data::grpc_op_recv_message recv_message
struct grpc_op::grpc_op_data::grpc_op_recv_initial_metadata recv_initial_metadata
struct grpc_op::grpc_op_data::grpc_op_send_initial_metadata send_initial_metadata
struct grpc_op::grpc_op_data::grpc_op_send_message send_message
struct grpc_op::grpc_op_data::grpc_op_recv_status_on_client recv_status_on_client
struct grpc_op::grpc_op_data::grpc_op_send_status_from_server send_status_from_server