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;
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_);
810 const_cast<char*
>(debug_error_string_));
826 if (recv_status_ ==
nullptr)
return;
829 recv_status_ =
nullptr;
834 if (recv_status_ ==
nullptr)
return;
840 bool hijacked_ =
false;
844 const char* debug_error_string_;
849 template <
class Op1 = CallNoOp<1>,
class Op2 = CallNoOp<2>,
850 class Op3 = CallNoOp<3>,
class Op4 = CallNoOp<4>,
851 class Op5 = CallNoOp<5>,
class Op6 = CallNoOp<6>>
860 template <
class Op1,
class Op2,
class Op3,
class Op4,
class Op5,
class Op6>
874 : core_cq_tag_(this),
877 done_intercepting_(false),
881 if (&other ==
this) {
887 done_intercepting_ =
false;
893 done_intercepting_ =
false;
898 if (RunInterceptors()) {
907 if (done_intercepting_) {
909 call_.
cq()->CompleteAvalanching();
914 *status = saved_status_;
919 this->Op1::FinishOp(status);
920 this->Op2::FinishOp(status);
921 this->Op3::FinishOp(status);
922 this->Op4::FinishOp(status);
923 this->Op5::FinishOp(status);
924 this->Op6::FinishOp(status);
925 saved_status_ = *status;
926 if (RunInterceptorsPostRecv()) {
949 this->Op1::SetHijackingState(&interceptor_methods_);
950 this->Op2::SetHijackingState(&interceptor_methods_);
951 this->Op3::SetHijackingState(&interceptor_methods_);
952 this->Op4::SetHijackingState(&interceptor_methods_);
953 this->Op5::SetHijackingState(&interceptor_methods_);
954 this->Op6::SetHijackingState(&interceptor_methods_);
959 static const size_t MAX_OPS = 6;
962 this->Op1::AddOp(ops, &nops);
963 this->Op2::AddOp(ops, &nops);
964 this->Op3::AddOp(ops, &nops);
965 this->Op4::AddOp(ops, &nops);
966 this->Op5::AddOp(ops, &nops);
967 this->Op6::AddOp(ops, &nops);
985 done_intercepting_ =
true;
995 bool RunInterceptors() {
998 interceptor_methods_.
SetCall(&call_);
999 this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
1000 this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
1001 this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
1002 this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
1003 this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
1004 this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
1010 call_.
cq()->RegisterAvalanching();
1014 bool RunInterceptorsPostRecv() {
1018 this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
1019 this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
1020 this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
1021 this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
1022 this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
1023 this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
1030 bool done_intercepting_ =
false;
1031 InterceptorBatchMethodsImpl interceptor_methods_;
A sequence of bytes.
Definition: byte_buffer.h:60
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
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
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
std::string error_message() const
Return the instance's error message.
Definition: status.h:112
StatusCode error_code() const
Return the instance's error code.
Definition: status.h:110
std::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:109
bool is_write_through() const
Definition: call_op_set.h:175
bool is_corked() const
Definition: call_op_set.h:149
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
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:100
bool is_last_message() const
Get value for the flag indicating that this is the last message, and should be coalesced with trailin...
Definition: call_op_set.h:181
WriteOptions & 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 Clear()
Clear all flags.
Definition: call_op_set.h:84
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_write_through()
Guarantee that all bytes have been written to the socket before completing this write (usually writes...
Definition: call_op_set.h:170
WriteOptions & clear_corked()
Definition: call_op_set.h:144
uint32_t flags() const
Returns raw flags bitset.
Definition: call_op_set.h:87
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
WriteOptions & set_last_message()
last-message bit: indicates this is the last message in a stream client-side: makes Write the equival...
Definition: call_op_set.h:156
WriteOptions & set_buffer_hint()
Sets flag indicating that the write may be buffered and need not go out on the wire immediately.
Definition: call_op_set.h:117
WriteOptions & set_no_compression()
Sets flag for the disabling of compression for the next message write.
Definition: call_op_set.h:92
Straightforward wrapping of the C call object.
Definition: call.h:35
grpc_call * call() const
Definition: call.h:69
::grpc::CompletionQueue * cq() const
Definition: call.h:70
Default argument for CallOpSet.
Definition: call_op_set.h:200
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:208
void FinishOp(bool *)
Definition: call_op_set.h:203
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:206
void AddOp(grpc_op *, size_t *)
Definition: call_op_set.h:202
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:204
Definition: call_op_set.h:769
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:818
void FinishOp(bool *)
Definition: call_op_set.h:794
CallOpClientRecvStatus()
Definition: call_op_set.h:771
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:824
void ClientRecvStatus(::grpc::ClientContext *context, Status *status)
Definition: call_op_set.h:774
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:782
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:832
Definition: call_op_set.h:619
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:645
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:626
CallOpClientSendClose()
Definition: call_op_set.h:621
void ClientSendClose()
Definition: call_op_set.h:623
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:635
void FinishOp(bool *)
Definition: call_op_set.h:633
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:642
Definition: call_op_set.h:526
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:594
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:586
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:543
bool got_message
Definition: call_op_set.h:540
void FinishOp(bool *status)
Definition: call_op_set.h:552
void RecvMessage(R *message)
Definition: call_op_set.h:529
void AllowNoMessage()
Definition: call_op_set.h:538
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:579
Definition: call_op_set.h:424
void SetHijackingState(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:482
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:468
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:434
void RecvMessage(R *message)
Definition: call_op_set.h:426
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:475
bool got_message
Definition: call_op_set.h:431
void FinishOp(bool *status)
Definition: call_op_set.h:443
void AllowNoMessage()
Definition: call_op_set.h:429
Definition: call_op_set.h:282
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:347
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:361
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 AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:308
void FinishOp(bool *status)
Definition: call_op_set.h:326
CallOpSendMessage()
Definition: call_op_set.h:284
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 SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:338
Definition: call_op_set.h:654
void ServerSendStatus(std::multimap< std::string, std::string > *trailing_metadata, const Status &status)
Definition: call_op_set.h:658
void SetFinishInterceptionHookPoint(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:702
void FinishOp(bool *)
Definition: call_op_set.h:686
CallOpServerSendStatus()
Definition: call_op_set.h:656
void AddOp(grpc_op *ops, size_t *nops)
Definition: call_op_set.h:669
void SetInterceptionHookPoint(InterceptorBatchMethodsImpl *interceptor_methods)
Definition: call_op_set.h:692
void SetHijackingState(InterceptorBatchMethodsImpl *)
Definition: call_op_set.h:705
Primary implementation of CallOpSetInterface.
Definition: call_op_set.h:867
CallOpSet(const CallOpSet &other)
Definition: call_op_set.h:873
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:906
void ContinueFinalizeResultAfterInterception() override
Definition: call_op_set.h:984
CallOpSet & operator=(const CallOpSet &other)
Definition: call_op_set.h:880
void * core_cq_tag() override
Get the tag to be used at the core completion queue.
Definition: call_op_set.h:938
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:944
void set_output_tag(void *return_tag)
Definition: call_op_set.h:936
CallOpSet()
Definition: call_op_set.h:869
void ContinueFillOpsAfterInterception() override
Definition: call_op_set.h:958
void FillOps(Call *call) override
Fills in grpc_op, starting from ops[*nops] and moving upwards.
Definition: call_op_set.h:892
void SetHijackingState() override
Definition: call_op_set.h:948
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:506
virtual ~DeserializeFunc()
Definition: call_op_set.h:509
virtual Status Deserialize(ByteBuffer *buf)=0
Definition: call_op_set.h:513
~DeserializeFuncType() override
Definition: call_op_set.h:520
Status Deserialize(ByteBuffer *buf) override
Definition: call_op_set.h:516
DeserializeFuncType(R *message)
Definition: call_op_set.h:515
Definition: interceptor_common.h:37
bool RunInterceptors()
Definition: interceptor_common.h:238
void SetCallOpSetInterface(CallOpSetInterface *ops)
Definition: interceptor_common.h:219
void SetRecvTrailingMetadata(MetadataMap *map)
Definition: interceptor_common.h:179
void ClearState()
Definition: interceptor_common.h:201
void SetSendTrailingMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:163
void SetReverse()
Definition: interceptor_common.h:208
void SetSendMessage(ByteBuffer *buf, const void **msg, bool *fail_send_message, std::function< Status(const void *)> serializer)
Definition: interceptor_common.h:142
void SetRecvInitialMetadata(MetadataMap *map)
Definition: interceptor_common.h:173
void SetSendStatus(grpc_status_code *code, std::string *error_details, std::string *error_message)
Definition: interceptor_common.h:156
void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
Definition: interceptor_common.h:78
bool InterceptorsListEmpty()
Definition: interceptor_common.h:223
void SetCall(Call *call)
Definition: interceptor_common.h:215
void SetRecvMessage(void *message, bool *hijacked_recv_message_failed)
Definition: interceptor_common.h:168
void SetRecvStatus(Status *status)
Definition: interceptor_common.h:177
void SetSendInitialMetadata(std::multimap< std::string, std::string > *metadata)
Definition: interceptor_common.h:151
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:441
@ GRPC_CALL_OK
everything went ok
Definition: grpc_types.h:443
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:596
@ 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:611
@ 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:591
@ GRPC_OP_SEND_MESSAGE
Send a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:586
@ 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:601
@ 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:582
@ GRPC_OP_RECV_MESSAGE
Receive a message: 0 or more of these operations can occur for each call.
Definition: grpc_types.h:605
#define GRPC_WRITE_THROUGH
Force this message to be written to the socket before completing it.
Definition: grpc_types.h:492
#define GRPC_WRITE_BUFFER_HINT
Write Flags:
Definition: grpc_types.h:487
#define GRPC_WRITE_NO_COMPRESS
Force compression to be disabled for a particular write (start_write/add_metadata).
Definition: grpc_types.h:490
#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< std::string, std::string > &metadata, size_t *metadata_count, const std::string &optional_error_details)
Definition: call_op_set.h:53
::google::protobuf::util::Status Status
Definition: config_protobuf.h:91
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
grpc_slice SliceReferencingString(const std::string &str)
Definition: slice.h:143
CoreCodegenInterface * g_core_codegen_interface
Definition: completion_queue.h:96
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:677
grpc_status_code * status
Definition: grpc_types.h:686
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:691
grpc_slice * status_details
Definition: grpc_types.h:687
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:685
struct grpc_byte_buffer * send_message
This op takes ownership of the slices in send_message.
Definition: grpc_types.h:652
grpc_metadata * trailing_metadata
Definition: grpc_types.h:656
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:661
size_t trailing_metadata_count
Definition: grpc_types.h:655
grpc_status_code status
Definition: grpc_types.h:657
Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT which has no arguments)
Definition: grpc_types.h:624
union grpc_op::grpc_op_data data
void * reserved
Reserved for future usage.
Definition: grpc_types.h:630
uint32_t flags
Write flags bitset for grpc_begin_messages.
Definition: grpc_types.h:628
grpc_op_type op
Operation type, as defined by grpc_op_type.
Definition: grpc_types.h:626
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