1 /* This file was generated by upb_generator from the input file:
2 *
3 * src/proto/grpc/gcp/handshaker.proto
4 *
5 * Do not edit -- your changes will be discarded when the file is
6 * regenerated.
7 * NO CHECKED-IN PROTOBUF GENCODE */
8
9 #ifndef SRC_PROTO_GRPC_GCP_HANDSHAKER_PROTO_UPB_H__UPB_H_
10 #define SRC_PROTO_GRPC_GCP_HANDSHAKER_PROTO_UPB_H__UPB_H_
11
12 #include "upb/generated_code_support.h"
13
14 #include "src/proto/grpc/gcp/handshaker.upb_minitable.h"
15
16 #include "src/proto/grpc/gcp/transport_security_common.upb_minitable.h"
17
18 // Must be last.
19 #include "upb/port/def.inc"
20
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 typedef struct grpc_gcp_Endpoint { upb_Message UPB_PRIVATE(base); } grpc_gcp_Endpoint;
26 typedef struct grpc_gcp_Identity { upb_Message UPB_PRIVATE(base); } grpc_gcp_Identity;
27 typedef struct grpc_gcp_Identity_AttributesEntry { upb_Message UPB_PRIVATE(base); } grpc_gcp_Identity_AttributesEntry;
28 typedef struct grpc_gcp_StartClientHandshakeReq { upb_Message UPB_PRIVATE(base); } grpc_gcp_StartClientHandshakeReq;
29 typedef struct grpc_gcp_ServerHandshakeParameters { upb_Message UPB_PRIVATE(base); } grpc_gcp_ServerHandshakeParameters;
30 typedef struct grpc_gcp_StartServerHandshakeReq { upb_Message UPB_PRIVATE(base); } grpc_gcp_StartServerHandshakeReq;
31 typedef struct grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry { upb_Message UPB_PRIVATE(base); } grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry;
32 typedef struct grpc_gcp_NextHandshakeMessageReq { upb_Message UPB_PRIVATE(base); } grpc_gcp_NextHandshakeMessageReq;
33 typedef struct grpc_gcp_HandshakerReq { upb_Message UPB_PRIVATE(base); } grpc_gcp_HandshakerReq;
34 typedef struct grpc_gcp_HandshakerResult { upb_Message UPB_PRIVATE(base); } grpc_gcp_HandshakerResult;
35 typedef struct grpc_gcp_HandshakerStatus { upb_Message UPB_PRIVATE(base); } grpc_gcp_HandshakerStatus;
36 typedef struct grpc_gcp_HandshakerResp { upb_Message UPB_PRIVATE(base); } grpc_gcp_HandshakerResp;
37 struct grpc_gcp_RpcProtocolVersions;
38
39 typedef enum {
40 grpc_gcp_HANDSHAKE_PROTOCOL_UNSPECIFIED = 0,
41 grpc_gcp_TLS = 1,
42 grpc_gcp_ALTS = 2
43 } grpc_gcp_HandshakeProtocol;
44
45 typedef enum {
46 grpc_gcp_NETWORK_PROTOCOL_UNSPECIFIED = 0,
47 grpc_gcp_TCP = 1,
48 grpc_gcp_UDP = 2
49 } grpc_gcp_NetworkProtocol;
50
51
52
53 /* grpc.gcp.Endpoint */
54
grpc_gcp_Endpoint_new(upb_Arena * arena)55 UPB_INLINE grpc_gcp_Endpoint* grpc_gcp_Endpoint_new(upb_Arena* arena) {
56 return (grpc_gcp_Endpoint*)_upb_Message_New(&grpc__gcp__Endpoint_msg_init, arena);
57 }
grpc_gcp_Endpoint_parse(const char * buf,size_t size,upb_Arena * arena)58 UPB_INLINE grpc_gcp_Endpoint* grpc_gcp_Endpoint_parse(const char* buf, size_t size, upb_Arena* arena) {
59 grpc_gcp_Endpoint* ret = grpc_gcp_Endpoint_new(arena);
60 if (!ret) return NULL;
61 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__Endpoint_msg_init, NULL, 0, arena) !=
62 kUpb_DecodeStatus_Ok) {
63 return NULL;
64 }
65 return ret;
66 }
grpc_gcp_Endpoint_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)67 UPB_INLINE grpc_gcp_Endpoint* grpc_gcp_Endpoint_parse_ex(const char* buf, size_t size,
68 const upb_ExtensionRegistry* extreg,
69 int options, upb_Arena* arena) {
70 grpc_gcp_Endpoint* ret = grpc_gcp_Endpoint_new(arena);
71 if (!ret) return NULL;
72 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__Endpoint_msg_init, extreg, options,
73 arena) != kUpb_DecodeStatus_Ok) {
74 return NULL;
75 }
76 return ret;
77 }
grpc_gcp_Endpoint_serialize(const grpc_gcp_Endpoint * msg,upb_Arena * arena,size_t * len)78 UPB_INLINE char* grpc_gcp_Endpoint_serialize(const grpc_gcp_Endpoint* msg, upb_Arena* arena, size_t* len) {
79 char* ptr;
80 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__Endpoint_msg_init, 0, arena, &ptr, len);
81 return ptr;
82 }
grpc_gcp_Endpoint_serialize_ex(const grpc_gcp_Endpoint * msg,int options,upb_Arena * arena,size_t * len)83 UPB_INLINE char* grpc_gcp_Endpoint_serialize_ex(const grpc_gcp_Endpoint* msg, int options,
84 upb_Arena* arena, size_t* len) {
85 char* ptr;
86 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__Endpoint_msg_init, options, arena, &ptr, len);
87 return ptr;
88 }
grpc_gcp_Endpoint_clear_ip_address(grpc_gcp_Endpoint * msg)89 UPB_INLINE void grpc_gcp_Endpoint_clear_ip_address(grpc_gcp_Endpoint* msg) {
90 const upb_MiniTableField field = {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
91 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
92 }
grpc_gcp_Endpoint_ip_address(const grpc_gcp_Endpoint * msg)93 UPB_INLINE upb_StringView grpc_gcp_Endpoint_ip_address(const grpc_gcp_Endpoint* msg) {
94 upb_StringView default_val = upb_StringView_FromString("");
95 upb_StringView ret;
96 const upb_MiniTableField field = {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
97 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
98 &default_val, &ret);
99 return ret;
100 }
grpc_gcp_Endpoint_clear_port(grpc_gcp_Endpoint * msg)101 UPB_INLINE void grpc_gcp_Endpoint_clear_port(grpc_gcp_Endpoint* msg) {
102 const upb_MiniTableField field = {2, 8, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
103 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
104 }
grpc_gcp_Endpoint_port(const grpc_gcp_Endpoint * msg)105 UPB_INLINE int32_t grpc_gcp_Endpoint_port(const grpc_gcp_Endpoint* msg) {
106 int32_t default_val = (int32_t)0;
107 int32_t ret;
108 const upb_MiniTableField field = {2, 8, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
109 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
110 &default_val, &ret);
111 return ret;
112 }
grpc_gcp_Endpoint_clear_protocol(grpc_gcp_Endpoint * msg)113 UPB_INLINE void grpc_gcp_Endpoint_clear_protocol(grpc_gcp_Endpoint* msg) {
114 const upb_MiniTableField field = {3, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
115 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
116 }
grpc_gcp_Endpoint_protocol(const grpc_gcp_Endpoint * msg)117 UPB_INLINE int32_t grpc_gcp_Endpoint_protocol(const grpc_gcp_Endpoint* msg) {
118 int32_t default_val = 0;
119 int32_t ret;
120 const upb_MiniTableField field = {3, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
121 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
122 &default_val, &ret);
123 return ret;
124 }
125
grpc_gcp_Endpoint_set_ip_address(grpc_gcp_Endpoint * msg,upb_StringView value)126 UPB_INLINE void grpc_gcp_Endpoint_set_ip_address(grpc_gcp_Endpoint *msg, upb_StringView value) {
127 const upb_MiniTableField field = {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
128 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
129 }
grpc_gcp_Endpoint_set_port(grpc_gcp_Endpoint * msg,int32_t value)130 UPB_INLINE void grpc_gcp_Endpoint_set_port(grpc_gcp_Endpoint *msg, int32_t value) {
131 const upb_MiniTableField field = {2, 8, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
132 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
133 }
grpc_gcp_Endpoint_set_protocol(grpc_gcp_Endpoint * msg,int32_t value)134 UPB_INLINE void grpc_gcp_Endpoint_set_protocol(grpc_gcp_Endpoint *msg, int32_t value) {
135 const upb_MiniTableField field = {3, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
136 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
137 }
138
139 /* grpc.gcp.Identity */
140
grpc_gcp_Identity_new(upb_Arena * arena)141 UPB_INLINE grpc_gcp_Identity* grpc_gcp_Identity_new(upb_Arena* arena) {
142 return (grpc_gcp_Identity*)_upb_Message_New(&grpc__gcp__Identity_msg_init, arena);
143 }
grpc_gcp_Identity_parse(const char * buf,size_t size,upb_Arena * arena)144 UPB_INLINE grpc_gcp_Identity* grpc_gcp_Identity_parse(const char* buf, size_t size, upb_Arena* arena) {
145 grpc_gcp_Identity* ret = grpc_gcp_Identity_new(arena);
146 if (!ret) return NULL;
147 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__Identity_msg_init, NULL, 0, arena) !=
148 kUpb_DecodeStatus_Ok) {
149 return NULL;
150 }
151 return ret;
152 }
grpc_gcp_Identity_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)153 UPB_INLINE grpc_gcp_Identity* grpc_gcp_Identity_parse_ex(const char* buf, size_t size,
154 const upb_ExtensionRegistry* extreg,
155 int options, upb_Arena* arena) {
156 grpc_gcp_Identity* ret = grpc_gcp_Identity_new(arena);
157 if (!ret) return NULL;
158 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__Identity_msg_init, extreg, options,
159 arena) != kUpb_DecodeStatus_Ok) {
160 return NULL;
161 }
162 return ret;
163 }
grpc_gcp_Identity_serialize(const grpc_gcp_Identity * msg,upb_Arena * arena,size_t * len)164 UPB_INLINE char* grpc_gcp_Identity_serialize(const grpc_gcp_Identity* msg, upb_Arena* arena, size_t* len) {
165 char* ptr;
166 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__Identity_msg_init, 0, arena, &ptr, len);
167 return ptr;
168 }
grpc_gcp_Identity_serialize_ex(const grpc_gcp_Identity * msg,int options,upb_Arena * arena,size_t * len)169 UPB_INLINE char* grpc_gcp_Identity_serialize_ex(const grpc_gcp_Identity* msg, int options,
170 upb_Arena* arena, size_t* len) {
171 char* ptr;
172 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__Identity_msg_init, options, arena, &ptr, len);
173 return ptr;
174 }
175 typedef enum {
176 grpc_gcp_Identity_identity_oneof_service_account = 1,
177 grpc_gcp_Identity_identity_oneof_hostname = 2,
178 grpc_gcp_Identity_identity_oneof_NOT_SET = 0
179 } grpc_gcp_Identity_identity_oneof_oneofcases;
grpc_gcp_Identity_identity_oneof_case(const grpc_gcp_Identity * msg)180 UPB_INLINE grpc_gcp_Identity_identity_oneof_oneofcases grpc_gcp_Identity_identity_oneof_case(const grpc_gcp_Identity* msg) {
181 const upb_MiniTableField field = {1, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
182 return (grpc_gcp_Identity_identity_oneof_oneofcases)upb_Message_WhichOneofFieldNumber(
183 UPB_UPCAST(msg), &field);
184 }
grpc_gcp_Identity_clear_service_account(grpc_gcp_Identity * msg)185 UPB_INLINE void grpc_gcp_Identity_clear_service_account(grpc_gcp_Identity* msg) {
186 const upb_MiniTableField field = {1, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
187 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
188 }
grpc_gcp_Identity_service_account(const grpc_gcp_Identity * msg)189 UPB_INLINE upb_StringView grpc_gcp_Identity_service_account(const grpc_gcp_Identity* msg) {
190 upb_StringView default_val = upb_StringView_FromString("");
191 upb_StringView ret;
192 const upb_MiniTableField field = {1, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
193 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
194 &default_val, &ret);
195 return ret;
196 }
grpc_gcp_Identity_has_service_account(const grpc_gcp_Identity * msg)197 UPB_INLINE bool grpc_gcp_Identity_has_service_account(const grpc_gcp_Identity* msg) {
198 const upb_MiniTableField field = {1, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
199 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
200 }
grpc_gcp_Identity_clear_hostname(grpc_gcp_Identity * msg)201 UPB_INLINE void grpc_gcp_Identity_clear_hostname(grpc_gcp_Identity* msg) {
202 const upb_MiniTableField field = {2, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
203 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
204 }
grpc_gcp_Identity_hostname(const grpc_gcp_Identity * msg)205 UPB_INLINE upb_StringView grpc_gcp_Identity_hostname(const grpc_gcp_Identity* msg) {
206 upb_StringView default_val = upb_StringView_FromString("");
207 upb_StringView ret;
208 const upb_MiniTableField field = {2, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
209 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
210 &default_val, &ret);
211 return ret;
212 }
grpc_gcp_Identity_has_hostname(const grpc_gcp_Identity * msg)213 UPB_INLINE bool grpc_gcp_Identity_has_hostname(const grpc_gcp_Identity* msg) {
214 const upb_MiniTableField field = {2, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
215 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
216 }
grpc_gcp_Identity_clear_attributes(grpc_gcp_Identity * msg)217 UPB_INLINE void grpc_gcp_Identity_clear_attributes(grpc_gcp_Identity* msg) {
218 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
219 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
220 }
grpc_gcp_Identity_attributes_size(const grpc_gcp_Identity * msg)221 UPB_INLINE size_t grpc_gcp_Identity_attributes_size(const grpc_gcp_Identity* msg) {
222 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
223 const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
224 return map ? _upb_Map_Size(map) : 0;
225 }
grpc_gcp_Identity_attributes_get(const grpc_gcp_Identity * msg,upb_StringView key,upb_StringView * val)226 UPB_INLINE bool grpc_gcp_Identity_attributes_get(const grpc_gcp_Identity* msg, upb_StringView key, upb_StringView* val) {
227 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
228 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity__AttributesEntry_msg_init);
229 const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
230 if (!map) return false;
231 return _upb_Map_Get(map, &key, 0, val, 0);
232 }
grpc_gcp_Identity_attributes_next(const grpc_gcp_Identity * msg,size_t * iter)233 UPB_INLINE const grpc_gcp_Identity_AttributesEntry* grpc_gcp_Identity_attributes_next(const grpc_gcp_Identity* msg, size_t* iter) {
234 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
235 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity__AttributesEntry_msg_init);
236 const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
237 if (!map) return NULL;
238 return (const grpc_gcp_Identity_AttributesEntry*)_upb_map_next(map, iter);
239 }
_grpc_gcp_Identity_attributes_upb_map(grpc_gcp_Identity * msg)240 UPB_INLINE const upb_Map* _grpc_gcp_Identity_attributes_upb_map(grpc_gcp_Identity* msg) {
241 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
242 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity__AttributesEntry_msg_init);
243 return upb_Message_GetMap(UPB_UPCAST(msg), &field);
244 }
_grpc_gcp_Identity_attributes_mutable_upb_map(grpc_gcp_Identity * msg,upb_Arena * a)245 UPB_INLINE upb_Map* _grpc_gcp_Identity_attributes_mutable_upb_map(grpc_gcp_Identity* msg, upb_Arena* a) {
246 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
247 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity__AttributesEntry_msg_init);
248 return _upb_Message_GetOrCreateMutableMap(UPB_UPCAST(msg), &field, 0, 0, a);
249 }
250
grpc_gcp_Identity_set_service_account(grpc_gcp_Identity * msg,upb_StringView value)251 UPB_INLINE void grpc_gcp_Identity_set_service_account(grpc_gcp_Identity *msg, upb_StringView value) {
252 const upb_MiniTableField field = {1, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
253 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
254 }
grpc_gcp_Identity_set_hostname(grpc_gcp_Identity * msg,upb_StringView value)255 UPB_INLINE void grpc_gcp_Identity_set_hostname(grpc_gcp_Identity *msg, upb_StringView value) {
256 const upb_MiniTableField field = {2, 16, -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
257 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
258 }
grpc_gcp_Identity_attributes_clear(grpc_gcp_Identity * msg)259 UPB_INLINE void grpc_gcp_Identity_attributes_clear(grpc_gcp_Identity* msg) {
260 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
261 upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
262 if (!map) return;
263 _upb_Map_Clear(map);
264 }
grpc_gcp_Identity_attributes_set(grpc_gcp_Identity * msg,upb_StringView key,upb_StringView val,upb_Arena * a)265 UPB_INLINE bool grpc_gcp_Identity_attributes_set(grpc_gcp_Identity* msg, upb_StringView key, upb_StringView val, upb_Arena* a) {
266 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
267 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity__AttributesEntry_msg_init);
268 upb_Map* map = _upb_Message_GetOrCreateMutableMap(UPB_UPCAST(msg),
269 &field, 0, 0, a);
270 return _upb_Map_Insert(map, &key, 0, &val, 0, a) !=
271 kUpb_MapInsertStatus_OutOfMemory;
272 }
grpc_gcp_Identity_attributes_delete(grpc_gcp_Identity * msg,upb_StringView key)273 UPB_INLINE bool grpc_gcp_Identity_attributes_delete(grpc_gcp_Identity* msg, upb_StringView key) {
274 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
275 upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
276 if (!map) return false;
277 return _upb_Map_Delete(map, &key, 0, NULL);
278 }
grpc_gcp_Identity_attributes_nextmutable(grpc_gcp_Identity * msg,size_t * iter)279 UPB_INLINE grpc_gcp_Identity_AttributesEntry* grpc_gcp_Identity_attributes_nextmutable(grpc_gcp_Identity* msg, size_t* iter) {
280 const upb_MiniTableField field = {3, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
281 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity__AttributesEntry_msg_init);
282 upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
283 if (!map) return NULL;
284 return (grpc_gcp_Identity_AttributesEntry*)_upb_map_next(map, iter);
285 }
286
287 /* grpc.gcp.Identity.AttributesEntry */
288
grpc_gcp_Identity_AttributesEntry_key(const grpc_gcp_Identity_AttributesEntry * msg)289 UPB_INLINE upb_StringView grpc_gcp_Identity_AttributesEntry_key(const grpc_gcp_Identity_AttributesEntry* msg) {
290 upb_StringView ret;
291 _upb_msg_map_key(msg, &ret, 0);
292 return ret;
293 }
grpc_gcp_Identity_AttributesEntry_value(const grpc_gcp_Identity_AttributesEntry * msg)294 UPB_INLINE upb_StringView grpc_gcp_Identity_AttributesEntry_value(const grpc_gcp_Identity_AttributesEntry* msg) {
295 upb_StringView ret;
296 _upb_msg_map_value(msg, &ret, 0);
297 return ret;
298 }
299
grpc_gcp_Identity_AttributesEntry_set_value(grpc_gcp_Identity_AttributesEntry * msg,upb_StringView value)300 UPB_INLINE void grpc_gcp_Identity_AttributesEntry_set_value(grpc_gcp_Identity_AttributesEntry *msg, upb_StringView value) {
301 _upb_msg_map_set_value(msg, &value, 0);
302 }
303
304 /* grpc.gcp.StartClientHandshakeReq */
305
grpc_gcp_StartClientHandshakeReq_new(upb_Arena * arena)306 UPB_INLINE grpc_gcp_StartClientHandshakeReq* grpc_gcp_StartClientHandshakeReq_new(upb_Arena* arena) {
307 return (grpc_gcp_StartClientHandshakeReq*)_upb_Message_New(&grpc__gcp__StartClientHandshakeReq_msg_init, arena);
308 }
grpc_gcp_StartClientHandshakeReq_parse(const char * buf,size_t size,upb_Arena * arena)309 UPB_INLINE grpc_gcp_StartClientHandshakeReq* grpc_gcp_StartClientHandshakeReq_parse(const char* buf, size_t size, upb_Arena* arena) {
310 grpc_gcp_StartClientHandshakeReq* ret = grpc_gcp_StartClientHandshakeReq_new(arena);
311 if (!ret) return NULL;
312 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__StartClientHandshakeReq_msg_init, NULL, 0, arena) !=
313 kUpb_DecodeStatus_Ok) {
314 return NULL;
315 }
316 return ret;
317 }
grpc_gcp_StartClientHandshakeReq_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)318 UPB_INLINE grpc_gcp_StartClientHandshakeReq* grpc_gcp_StartClientHandshakeReq_parse_ex(const char* buf, size_t size,
319 const upb_ExtensionRegistry* extreg,
320 int options, upb_Arena* arena) {
321 grpc_gcp_StartClientHandshakeReq* ret = grpc_gcp_StartClientHandshakeReq_new(arena);
322 if (!ret) return NULL;
323 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__StartClientHandshakeReq_msg_init, extreg, options,
324 arena) != kUpb_DecodeStatus_Ok) {
325 return NULL;
326 }
327 return ret;
328 }
grpc_gcp_StartClientHandshakeReq_serialize(const grpc_gcp_StartClientHandshakeReq * msg,upb_Arena * arena,size_t * len)329 UPB_INLINE char* grpc_gcp_StartClientHandshakeReq_serialize(const grpc_gcp_StartClientHandshakeReq* msg, upb_Arena* arena, size_t* len) {
330 char* ptr;
331 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__StartClientHandshakeReq_msg_init, 0, arena, &ptr, len);
332 return ptr;
333 }
grpc_gcp_StartClientHandshakeReq_serialize_ex(const grpc_gcp_StartClientHandshakeReq * msg,int options,upb_Arena * arena,size_t * len)334 UPB_INLINE char* grpc_gcp_StartClientHandshakeReq_serialize_ex(const grpc_gcp_StartClientHandshakeReq* msg, int options,
335 upb_Arena* arena, size_t* len) {
336 char* ptr;
337 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__StartClientHandshakeReq_msg_init, options, arena, &ptr, len);
338 return ptr;
339 }
grpc_gcp_StartClientHandshakeReq_clear_handshake_security_protocol(grpc_gcp_StartClientHandshakeReq * msg)340 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_handshake_security_protocol(grpc_gcp_StartClientHandshakeReq* msg) {
341 const upb_MiniTableField field = {1, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
342 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
343 }
grpc_gcp_StartClientHandshakeReq_handshake_security_protocol(const grpc_gcp_StartClientHandshakeReq * msg)344 UPB_INLINE int32_t grpc_gcp_StartClientHandshakeReq_handshake_security_protocol(const grpc_gcp_StartClientHandshakeReq* msg) {
345 int32_t default_val = 0;
346 int32_t ret;
347 const upb_MiniTableField field = {1, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
348 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
349 &default_val, &ret);
350 return ret;
351 }
grpc_gcp_StartClientHandshakeReq_clear_application_protocols(grpc_gcp_StartClientHandshakeReq * msg)352 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_application_protocols(grpc_gcp_StartClientHandshakeReq* msg) {
353 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
354 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
355 }
grpc_gcp_StartClientHandshakeReq_application_protocols(const grpc_gcp_StartClientHandshakeReq * msg,size_t * size)356 UPB_INLINE upb_StringView const* grpc_gcp_StartClientHandshakeReq_application_protocols(const grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
357 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
358 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
359 if (arr) {
360 if (size) *size = arr->UPB_PRIVATE(size);
361 return (upb_StringView const*)upb_Array_DataPtr(arr);
362 } else {
363 if (size) *size = 0;
364 return NULL;
365 }
366 }
_grpc_gcp_StartClientHandshakeReq_application_protocols_upb_array(const grpc_gcp_StartClientHandshakeReq * msg,size_t * size)367 UPB_INLINE const upb_Array* _grpc_gcp_StartClientHandshakeReq_application_protocols_upb_array(const grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
368 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
369 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
370 if (size) {
371 *size = arr ? arr->UPB_PRIVATE(size) : 0;
372 }
373 return arr;
374 }
_grpc_gcp_StartClientHandshakeReq_application_protocols_mutable_upb_array(grpc_gcp_StartClientHandshakeReq * msg,size_t * size,upb_Arena * arena)375 UPB_INLINE upb_Array* _grpc_gcp_StartClientHandshakeReq_application_protocols_mutable_upb_array(grpc_gcp_StartClientHandshakeReq* msg, size_t* size, upb_Arena* arena) {
376 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
377 upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
378 &field, arena);
379 if (size) {
380 *size = arr ? arr->UPB_PRIVATE(size) : 0;
381 }
382 return arr;
383 }
grpc_gcp_StartClientHandshakeReq_clear_record_protocols(grpc_gcp_StartClientHandshakeReq * msg)384 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_record_protocols(grpc_gcp_StartClientHandshakeReq* msg) {
385 const upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
386 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
387 }
grpc_gcp_StartClientHandshakeReq_record_protocols(const grpc_gcp_StartClientHandshakeReq * msg,size_t * size)388 UPB_INLINE upb_StringView const* grpc_gcp_StartClientHandshakeReq_record_protocols(const grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
389 const upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
390 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
391 if (arr) {
392 if (size) *size = arr->UPB_PRIVATE(size);
393 return (upb_StringView const*)upb_Array_DataPtr(arr);
394 } else {
395 if (size) *size = 0;
396 return NULL;
397 }
398 }
_grpc_gcp_StartClientHandshakeReq_record_protocols_upb_array(const grpc_gcp_StartClientHandshakeReq * msg,size_t * size)399 UPB_INLINE const upb_Array* _grpc_gcp_StartClientHandshakeReq_record_protocols_upb_array(const grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
400 const upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
401 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
402 if (size) {
403 *size = arr ? arr->UPB_PRIVATE(size) : 0;
404 }
405 return arr;
406 }
_grpc_gcp_StartClientHandshakeReq_record_protocols_mutable_upb_array(grpc_gcp_StartClientHandshakeReq * msg,size_t * size,upb_Arena * arena)407 UPB_INLINE upb_Array* _grpc_gcp_StartClientHandshakeReq_record_protocols_mutable_upb_array(grpc_gcp_StartClientHandshakeReq* msg, size_t* size, upb_Arena* arena) {
408 const upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
409 upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
410 &field, arena);
411 if (size) {
412 *size = arr ? arr->UPB_PRIVATE(size) : 0;
413 }
414 return arr;
415 }
grpc_gcp_StartClientHandshakeReq_clear_target_identities(grpc_gcp_StartClientHandshakeReq * msg)416 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_target_identities(grpc_gcp_StartClientHandshakeReq* msg) {
417 const upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
418 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
419 }
grpc_gcp_StartClientHandshakeReq_target_identities(const grpc_gcp_StartClientHandshakeReq * msg,size_t * size)420 UPB_INLINE const grpc_gcp_Identity* const* grpc_gcp_StartClientHandshakeReq_target_identities(const grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
421 const upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
422 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
423 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
424 if (arr) {
425 if (size) *size = arr->UPB_PRIVATE(size);
426 return (const grpc_gcp_Identity* const*)upb_Array_DataPtr(arr);
427 } else {
428 if (size) *size = 0;
429 return NULL;
430 }
431 }
_grpc_gcp_StartClientHandshakeReq_target_identities_upb_array(const grpc_gcp_StartClientHandshakeReq * msg,size_t * size)432 UPB_INLINE const upb_Array* _grpc_gcp_StartClientHandshakeReq_target_identities_upb_array(const grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
433 const upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
434 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
435 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
436 if (size) {
437 *size = arr ? arr->UPB_PRIVATE(size) : 0;
438 }
439 return arr;
440 }
_grpc_gcp_StartClientHandshakeReq_target_identities_mutable_upb_array(grpc_gcp_StartClientHandshakeReq * msg,size_t * size,upb_Arena * arena)441 UPB_INLINE upb_Array* _grpc_gcp_StartClientHandshakeReq_target_identities_mutable_upb_array(grpc_gcp_StartClientHandshakeReq* msg, size_t* size, upb_Arena* arena) {
442 const upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
443 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
444 upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
445 &field, arena);
446 if (size) {
447 *size = arr ? arr->UPB_PRIVATE(size) : 0;
448 }
449 return arr;
450 }
grpc_gcp_StartClientHandshakeReq_clear_local_identity(grpc_gcp_StartClientHandshakeReq * msg)451 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_local_identity(grpc_gcp_StartClientHandshakeReq* msg) {
452 const upb_MiniTableField field = {5, UPB_SIZE(28, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
453 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
454 }
grpc_gcp_StartClientHandshakeReq_local_identity(const grpc_gcp_StartClientHandshakeReq * msg)455 UPB_INLINE const grpc_gcp_Identity* grpc_gcp_StartClientHandshakeReq_local_identity(const grpc_gcp_StartClientHandshakeReq* msg) {
456 const grpc_gcp_Identity* default_val = NULL;
457 const grpc_gcp_Identity* ret;
458 const upb_MiniTableField field = {5, UPB_SIZE(28, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
459 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
460 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
461 &default_val, &ret);
462 return ret;
463 }
grpc_gcp_StartClientHandshakeReq_has_local_identity(const grpc_gcp_StartClientHandshakeReq * msg)464 UPB_INLINE bool grpc_gcp_StartClientHandshakeReq_has_local_identity(const grpc_gcp_StartClientHandshakeReq* msg) {
465 const upb_MiniTableField field = {5, UPB_SIZE(28, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
466 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
467 }
grpc_gcp_StartClientHandshakeReq_clear_local_endpoint(grpc_gcp_StartClientHandshakeReq * msg)468 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_local_endpoint(grpc_gcp_StartClientHandshakeReq* msg) {
469 const upb_MiniTableField field = {6, UPB_SIZE(32, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
470 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
471 }
grpc_gcp_StartClientHandshakeReq_local_endpoint(const grpc_gcp_StartClientHandshakeReq * msg)472 UPB_INLINE const grpc_gcp_Endpoint* grpc_gcp_StartClientHandshakeReq_local_endpoint(const grpc_gcp_StartClientHandshakeReq* msg) {
473 const grpc_gcp_Endpoint* default_val = NULL;
474 const grpc_gcp_Endpoint* ret;
475 const upb_MiniTableField field = {6, UPB_SIZE(32, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
476 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
477 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
478 &default_val, &ret);
479 return ret;
480 }
grpc_gcp_StartClientHandshakeReq_has_local_endpoint(const grpc_gcp_StartClientHandshakeReq * msg)481 UPB_INLINE bool grpc_gcp_StartClientHandshakeReq_has_local_endpoint(const grpc_gcp_StartClientHandshakeReq* msg) {
482 const upb_MiniTableField field = {6, UPB_SIZE(32, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
483 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
484 }
grpc_gcp_StartClientHandshakeReq_clear_remote_endpoint(grpc_gcp_StartClientHandshakeReq * msg)485 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_remote_endpoint(grpc_gcp_StartClientHandshakeReq* msg) {
486 const upb_MiniTableField field = {7, UPB_SIZE(36, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
487 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
488 }
grpc_gcp_StartClientHandshakeReq_remote_endpoint(const grpc_gcp_StartClientHandshakeReq * msg)489 UPB_INLINE const grpc_gcp_Endpoint* grpc_gcp_StartClientHandshakeReq_remote_endpoint(const grpc_gcp_StartClientHandshakeReq* msg) {
490 const grpc_gcp_Endpoint* default_val = NULL;
491 const grpc_gcp_Endpoint* ret;
492 const upb_MiniTableField field = {7, UPB_SIZE(36, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
493 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
494 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
495 &default_val, &ret);
496 return ret;
497 }
grpc_gcp_StartClientHandshakeReq_has_remote_endpoint(const grpc_gcp_StartClientHandshakeReq * msg)498 UPB_INLINE bool grpc_gcp_StartClientHandshakeReq_has_remote_endpoint(const grpc_gcp_StartClientHandshakeReq* msg) {
499 const upb_MiniTableField field = {7, UPB_SIZE(36, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
500 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
501 }
grpc_gcp_StartClientHandshakeReq_clear_target_name(grpc_gcp_StartClientHandshakeReq * msg)502 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_target_name(grpc_gcp_StartClientHandshakeReq* msg) {
503 const upb_MiniTableField field = {8, UPB_SIZE(48, 72), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
504 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
505 }
grpc_gcp_StartClientHandshakeReq_target_name(const grpc_gcp_StartClientHandshakeReq * msg)506 UPB_INLINE upb_StringView grpc_gcp_StartClientHandshakeReq_target_name(const grpc_gcp_StartClientHandshakeReq* msg) {
507 upb_StringView default_val = upb_StringView_FromString("");
508 upb_StringView ret;
509 const upb_MiniTableField field = {8, UPB_SIZE(48, 72), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
510 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
511 &default_val, &ret);
512 return ret;
513 }
grpc_gcp_StartClientHandshakeReq_clear_rpc_versions(grpc_gcp_StartClientHandshakeReq * msg)514 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_rpc_versions(grpc_gcp_StartClientHandshakeReq* msg) {
515 const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 67, 4, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
516 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
517 }
grpc_gcp_StartClientHandshakeReq_rpc_versions(const grpc_gcp_StartClientHandshakeReq * msg)518 UPB_INLINE const struct grpc_gcp_RpcProtocolVersions* grpc_gcp_StartClientHandshakeReq_rpc_versions(const grpc_gcp_StartClientHandshakeReq* msg) {
519 const struct grpc_gcp_RpcProtocolVersions* default_val = NULL;
520 const struct grpc_gcp_RpcProtocolVersions* ret;
521 const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 67, 4, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
522 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__RpcProtocolVersions_msg_init);
523 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
524 &default_val, &ret);
525 return ret;
526 }
grpc_gcp_StartClientHandshakeReq_has_rpc_versions(const grpc_gcp_StartClientHandshakeReq * msg)527 UPB_INLINE bool grpc_gcp_StartClientHandshakeReq_has_rpc_versions(const grpc_gcp_StartClientHandshakeReq* msg) {
528 const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 67, 4, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
529 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
530 }
grpc_gcp_StartClientHandshakeReq_clear_max_frame_size(grpc_gcp_StartClientHandshakeReq * msg)531 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_clear_max_frame_size(grpc_gcp_StartClientHandshakeReq* msg) {
532 const upb_MiniTableField field = {10, UPB_SIZE(44, 16), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
533 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
534 }
grpc_gcp_StartClientHandshakeReq_max_frame_size(const grpc_gcp_StartClientHandshakeReq * msg)535 UPB_INLINE uint32_t grpc_gcp_StartClientHandshakeReq_max_frame_size(const grpc_gcp_StartClientHandshakeReq* msg) {
536 uint32_t default_val = (uint32_t)0u;
537 uint32_t ret;
538 const upb_MiniTableField field = {10, UPB_SIZE(44, 16), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
539 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
540 &default_val, &ret);
541 return ret;
542 }
543
grpc_gcp_StartClientHandshakeReq_set_handshake_security_protocol(grpc_gcp_StartClientHandshakeReq * msg,int32_t value)544 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_handshake_security_protocol(grpc_gcp_StartClientHandshakeReq *msg, int32_t value) {
545 const upb_MiniTableField field = {1, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
546 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
547 }
grpc_gcp_StartClientHandshakeReq_mutable_application_protocols(grpc_gcp_StartClientHandshakeReq * msg,size_t * size)548 UPB_INLINE upb_StringView* grpc_gcp_StartClientHandshakeReq_mutable_application_protocols(grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
549 upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
550 upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
551 if (arr) {
552 if (size) *size = arr->UPB_PRIVATE(size);
553 return (upb_StringView*)upb_Array_MutableDataPtr(arr);
554 } else {
555 if (size) *size = 0;
556 return NULL;
557 }
558 }
grpc_gcp_StartClientHandshakeReq_resize_application_protocols(grpc_gcp_StartClientHandshakeReq * msg,size_t size,upb_Arena * arena)559 UPB_INLINE upb_StringView* grpc_gcp_StartClientHandshakeReq_resize_application_protocols(grpc_gcp_StartClientHandshakeReq* msg, size_t size, upb_Arena* arena) {
560 upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
561 return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
562 &field, size, arena);
563 }
grpc_gcp_StartClientHandshakeReq_add_application_protocols(grpc_gcp_StartClientHandshakeReq * msg,upb_StringView val,upb_Arena * arena)564 UPB_INLINE bool grpc_gcp_StartClientHandshakeReq_add_application_protocols(grpc_gcp_StartClientHandshakeReq* msg, upb_StringView val, upb_Arena* arena) {
565 upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
566 upb_Array* arr = upb_Message_GetOrCreateMutableArray(
567 UPB_UPCAST(msg), &field, arena);
568 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
569 arr, arr->UPB_PRIVATE(size) + 1, arena)) {
570 return false;
571 }
572 UPB_PRIVATE(_upb_Array_Set)
573 (arr, arr->UPB_PRIVATE(size) - 1, &val, sizeof(val));
574 return true;
575 }
grpc_gcp_StartClientHandshakeReq_mutable_record_protocols(grpc_gcp_StartClientHandshakeReq * msg,size_t * size)576 UPB_INLINE upb_StringView* grpc_gcp_StartClientHandshakeReq_mutable_record_protocols(grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
577 upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
578 upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
579 if (arr) {
580 if (size) *size = arr->UPB_PRIVATE(size);
581 return (upb_StringView*)upb_Array_MutableDataPtr(arr);
582 } else {
583 if (size) *size = 0;
584 return NULL;
585 }
586 }
grpc_gcp_StartClientHandshakeReq_resize_record_protocols(grpc_gcp_StartClientHandshakeReq * msg,size_t size,upb_Arena * arena)587 UPB_INLINE upb_StringView* grpc_gcp_StartClientHandshakeReq_resize_record_protocols(grpc_gcp_StartClientHandshakeReq* msg, size_t size, upb_Arena* arena) {
588 upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
589 return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
590 &field, size, arena);
591 }
grpc_gcp_StartClientHandshakeReq_add_record_protocols(grpc_gcp_StartClientHandshakeReq * msg,upb_StringView val,upb_Arena * arena)592 UPB_INLINE bool grpc_gcp_StartClientHandshakeReq_add_record_protocols(grpc_gcp_StartClientHandshakeReq* msg, upb_StringView val, upb_Arena* arena) {
593 upb_MiniTableField field = {3, UPB_SIZE(20, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
594 upb_Array* arr = upb_Message_GetOrCreateMutableArray(
595 UPB_UPCAST(msg), &field, arena);
596 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
597 arr, arr->UPB_PRIVATE(size) + 1, arena)) {
598 return false;
599 }
600 UPB_PRIVATE(_upb_Array_Set)
601 (arr, arr->UPB_PRIVATE(size) - 1, &val, sizeof(val));
602 return true;
603 }
grpc_gcp_StartClientHandshakeReq_mutable_target_identities(grpc_gcp_StartClientHandshakeReq * msg,size_t * size)604 UPB_INLINE grpc_gcp_Identity** grpc_gcp_StartClientHandshakeReq_mutable_target_identities(grpc_gcp_StartClientHandshakeReq* msg, size_t* size) {
605 upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
606 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
607 upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
608 if (arr) {
609 if (size) *size = arr->UPB_PRIVATE(size);
610 return (grpc_gcp_Identity**)upb_Array_MutableDataPtr(arr);
611 } else {
612 if (size) *size = 0;
613 return NULL;
614 }
615 }
grpc_gcp_StartClientHandshakeReq_resize_target_identities(grpc_gcp_StartClientHandshakeReq * msg,size_t size,upb_Arena * arena)616 UPB_INLINE grpc_gcp_Identity** grpc_gcp_StartClientHandshakeReq_resize_target_identities(grpc_gcp_StartClientHandshakeReq* msg, size_t size, upb_Arena* arena) {
617 upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
618 return (grpc_gcp_Identity**)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
619 &field, size, arena);
620 }
grpc_gcp_StartClientHandshakeReq_add_target_identities(grpc_gcp_StartClientHandshakeReq * msg,upb_Arena * arena)621 UPB_INLINE struct grpc_gcp_Identity* grpc_gcp_StartClientHandshakeReq_add_target_identities(grpc_gcp_StartClientHandshakeReq* msg, upb_Arena* arena) {
622 upb_MiniTableField field = {4, UPB_SIZE(24, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
623 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
624 upb_Array* arr = upb_Message_GetOrCreateMutableArray(
625 UPB_UPCAST(msg), &field, arena);
626 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
627 arr, arr->UPB_PRIVATE(size) + 1, arena)) {
628 return NULL;
629 }
630 struct grpc_gcp_Identity* sub = (struct grpc_gcp_Identity*)_upb_Message_New(&grpc__gcp__Identity_msg_init, arena);
631 if (!arr || !sub) return NULL;
632 UPB_PRIVATE(_upb_Array_Set)
633 (arr, arr->UPB_PRIVATE(size) - 1, &sub, sizeof(sub));
634 return sub;
635 }
grpc_gcp_StartClientHandshakeReq_set_local_identity(grpc_gcp_StartClientHandshakeReq * msg,grpc_gcp_Identity * value)636 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_local_identity(grpc_gcp_StartClientHandshakeReq *msg, grpc_gcp_Identity* value) {
637 const upb_MiniTableField field = {5, UPB_SIZE(28, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
638 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
639 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
640 }
grpc_gcp_StartClientHandshakeReq_mutable_local_identity(grpc_gcp_StartClientHandshakeReq * msg,upb_Arena * arena)641 UPB_INLINE struct grpc_gcp_Identity* grpc_gcp_StartClientHandshakeReq_mutable_local_identity(grpc_gcp_StartClientHandshakeReq* msg, upb_Arena* arena) {
642 struct grpc_gcp_Identity* sub = (struct grpc_gcp_Identity*)grpc_gcp_StartClientHandshakeReq_local_identity(msg);
643 if (sub == NULL) {
644 sub = (struct grpc_gcp_Identity*)_upb_Message_New(&grpc__gcp__Identity_msg_init, arena);
645 if (sub) grpc_gcp_StartClientHandshakeReq_set_local_identity(msg, sub);
646 }
647 return sub;
648 }
grpc_gcp_StartClientHandshakeReq_set_local_endpoint(grpc_gcp_StartClientHandshakeReq * msg,grpc_gcp_Endpoint * value)649 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_local_endpoint(grpc_gcp_StartClientHandshakeReq *msg, grpc_gcp_Endpoint* value) {
650 const upb_MiniTableField field = {6, UPB_SIZE(32, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
651 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
652 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
653 }
grpc_gcp_StartClientHandshakeReq_mutable_local_endpoint(grpc_gcp_StartClientHandshakeReq * msg,upb_Arena * arena)654 UPB_INLINE struct grpc_gcp_Endpoint* grpc_gcp_StartClientHandshakeReq_mutable_local_endpoint(grpc_gcp_StartClientHandshakeReq* msg, upb_Arena* arena) {
655 struct grpc_gcp_Endpoint* sub = (struct grpc_gcp_Endpoint*)grpc_gcp_StartClientHandshakeReq_local_endpoint(msg);
656 if (sub == NULL) {
657 sub = (struct grpc_gcp_Endpoint*)_upb_Message_New(&grpc__gcp__Endpoint_msg_init, arena);
658 if (sub) grpc_gcp_StartClientHandshakeReq_set_local_endpoint(msg, sub);
659 }
660 return sub;
661 }
grpc_gcp_StartClientHandshakeReq_set_remote_endpoint(grpc_gcp_StartClientHandshakeReq * msg,grpc_gcp_Endpoint * value)662 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_remote_endpoint(grpc_gcp_StartClientHandshakeReq *msg, grpc_gcp_Endpoint* value) {
663 const upb_MiniTableField field = {7, UPB_SIZE(36, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
664 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
665 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
666 }
grpc_gcp_StartClientHandshakeReq_mutable_remote_endpoint(grpc_gcp_StartClientHandshakeReq * msg,upb_Arena * arena)667 UPB_INLINE struct grpc_gcp_Endpoint* grpc_gcp_StartClientHandshakeReq_mutable_remote_endpoint(grpc_gcp_StartClientHandshakeReq* msg, upb_Arena* arena) {
668 struct grpc_gcp_Endpoint* sub = (struct grpc_gcp_Endpoint*)grpc_gcp_StartClientHandshakeReq_remote_endpoint(msg);
669 if (sub == NULL) {
670 sub = (struct grpc_gcp_Endpoint*)_upb_Message_New(&grpc__gcp__Endpoint_msg_init, arena);
671 if (sub) grpc_gcp_StartClientHandshakeReq_set_remote_endpoint(msg, sub);
672 }
673 return sub;
674 }
grpc_gcp_StartClientHandshakeReq_set_target_name(grpc_gcp_StartClientHandshakeReq * msg,upb_StringView value)675 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_target_name(grpc_gcp_StartClientHandshakeReq *msg, upb_StringView value) {
676 const upb_MiniTableField field = {8, UPB_SIZE(48, 72), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
677 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
678 }
grpc_gcp_StartClientHandshakeReq_set_rpc_versions(grpc_gcp_StartClientHandshakeReq * msg,struct grpc_gcp_RpcProtocolVersions * value)679 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_rpc_versions(grpc_gcp_StartClientHandshakeReq *msg, struct grpc_gcp_RpcProtocolVersions* value) {
680 const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 67, 4, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
681 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__RpcProtocolVersions_msg_init);
682 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
683 }
grpc_gcp_StartClientHandshakeReq_mutable_rpc_versions(grpc_gcp_StartClientHandshakeReq * msg,upb_Arena * arena)684 UPB_INLINE struct grpc_gcp_RpcProtocolVersions* grpc_gcp_StartClientHandshakeReq_mutable_rpc_versions(grpc_gcp_StartClientHandshakeReq* msg, upb_Arena* arena) {
685 struct grpc_gcp_RpcProtocolVersions* sub = (struct grpc_gcp_RpcProtocolVersions*)grpc_gcp_StartClientHandshakeReq_rpc_versions(msg);
686 if (sub == NULL) {
687 sub = (struct grpc_gcp_RpcProtocolVersions*)_upb_Message_New(&grpc__gcp__RpcProtocolVersions_msg_init, arena);
688 if (sub) grpc_gcp_StartClientHandshakeReq_set_rpc_versions(msg, sub);
689 }
690 return sub;
691 }
grpc_gcp_StartClientHandshakeReq_set_max_frame_size(grpc_gcp_StartClientHandshakeReq * msg,uint32_t value)692 UPB_INLINE void grpc_gcp_StartClientHandshakeReq_set_max_frame_size(grpc_gcp_StartClientHandshakeReq *msg, uint32_t value) {
693 const upb_MiniTableField field = {10, UPB_SIZE(44, 16), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
694 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
695 }
696
697 /* grpc.gcp.ServerHandshakeParameters */
698
grpc_gcp_ServerHandshakeParameters_new(upb_Arena * arena)699 UPB_INLINE grpc_gcp_ServerHandshakeParameters* grpc_gcp_ServerHandshakeParameters_new(upb_Arena* arena) {
700 return (grpc_gcp_ServerHandshakeParameters*)_upb_Message_New(&grpc__gcp__ServerHandshakeParameters_msg_init, arena);
701 }
grpc_gcp_ServerHandshakeParameters_parse(const char * buf,size_t size,upb_Arena * arena)702 UPB_INLINE grpc_gcp_ServerHandshakeParameters* grpc_gcp_ServerHandshakeParameters_parse(const char* buf, size_t size, upb_Arena* arena) {
703 grpc_gcp_ServerHandshakeParameters* ret = grpc_gcp_ServerHandshakeParameters_new(arena);
704 if (!ret) return NULL;
705 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__ServerHandshakeParameters_msg_init, NULL, 0, arena) !=
706 kUpb_DecodeStatus_Ok) {
707 return NULL;
708 }
709 return ret;
710 }
grpc_gcp_ServerHandshakeParameters_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)711 UPB_INLINE grpc_gcp_ServerHandshakeParameters* grpc_gcp_ServerHandshakeParameters_parse_ex(const char* buf, size_t size,
712 const upb_ExtensionRegistry* extreg,
713 int options, upb_Arena* arena) {
714 grpc_gcp_ServerHandshakeParameters* ret = grpc_gcp_ServerHandshakeParameters_new(arena);
715 if (!ret) return NULL;
716 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__ServerHandshakeParameters_msg_init, extreg, options,
717 arena) != kUpb_DecodeStatus_Ok) {
718 return NULL;
719 }
720 return ret;
721 }
grpc_gcp_ServerHandshakeParameters_serialize(const grpc_gcp_ServerHandshakeParameters * msg,upb_Arena * arena,size_t * len)722 UPB_INLINE char* grpc_gcp_ServerHandshakeParameters_serialize(const grpc_gcp_ServerHandshakeParameters* msg, upb_Arena* arena, size_t* len) {
723 char* ptr;
724 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__ServerHandshakeParameters_msg_init, 0, arena, &ptr, len);
725 return ptr;
726 }
grpc_gcp_ServerHandshakeParameters_serialize_ex(const grpc_gcp_ServerHandshakeParameters * msg,int options,upb_Arena * arena,size_t * len)727 UPB_INLINE char* grpc_gcp_ServerHandshakeParameters_serialize_ex(const grpc_gcp_ServerHandshakeParameters* msg, int options,
728 upb_Arena* arena, size_t* len) {
729 char* ptr;
730 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__ServerHandshakeParameters_msg_init, options, arena, &ptr, len);
731 return ptr;
732 }
grpc_gcp_ServerHandshakeParameters_clear_record_protocols(grpc_gcp_ServerHandshakeParameters * msg)733 UPB_INLINE void grpc_gcp_ServerHandshakeParameters_clear_record_protocols(grpc_gcp_ServerHandshakeParameters* msg) {
734 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
735 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
736 }
grpc_gcp_ServerHandshakeParameters_record_protocols(const grpc_gcp_ServerHandshakeParameters * msg,size_t * size)737 UPB_INLINE upb_StringView const* grpc_gcp_ServerHandshakeParameters_record_protocols(const grpc_gcp_ServerHandshakeParameters* msg, size_t* size) {
738 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
739 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
740 if (arr) {
741 if (size) *size = arr->UPB_PRIVATE(size);
742 return (upb_StringView const*)upb_Array_DataPtr(arr);
743 } else {
744 if (size) *size = 0;
745 return NULL;
746 }
747 }
_grpc_gcp_ServerHandshakeParameters_record_protocols_upb_array(const grpc_gcp_ServerHandshakeParameters * msg,size_t * size)748 UPB_INLINE const upb_Array* _grpc_gcp_ServerHandshakeParameters_record_protocols_upb_array(const grpc_gcp_ServerHandshakeParameters* msg, size_t* size) {
749 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
750 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
751 if (size) {
752 *size = arr ? arr->UPB_PRIVATE(size) : 0;
753 }
754 return arr;
755 }
_grpc_gcp_ServerHandshakeParameters_record_protocols_mutable_upb_array(grpc_gcp_ServerHandshakeParameters * msg,size_t * size,upb_Arena * arena)756 UPB_INLINE upb_Array* _grpc_gcp_ServerHandshakeParameters_record_protocols_mutable_upb_array(grpc_gcp_ServerHandshakeParameters* msg, size_t* size, upb_Arena* arena) {
757 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
758 upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
759 &field, arena);
760 if (size) {
761 *size = arr ? arr->UPB_PRIVATE(size) : 0;
762 }
763 return arr;
764 }
grpc_gcp_ServerHandshakeParameters_clear_local_identities(grpc_gcp_ServerHandshakeParameters * msg)765 UPB_INLINE void grpc_gcp_ServerHandshakeParameters_clear_local_identities(grpc_gcp_ServerHandshakeParameters* msg) {
766 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
767 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
768 }
grpc_gcp_ServerHandshakeParameters_local_identities(const grpc_gcp_ServerHandshakeParameters * msg,size_t * size)769 UPB_INLINE const grpc_gcp_Identity* const* grpc_gcp_ServerHandshakeParameters_local_identities(const grpc_gcp_ServerHandshakeParameters* msg, size_t* size) {
770 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
771 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
772 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
773 if (arr) {
774 if (size) *size = arr->UPB_PRIVATE(size);
775 return (const grpc_gcp_Identity* const*)upb_Array_DataPtr(arr);
776 } else {
777 if (size) *size = 0;
778 return NULL;
779 }
780 }
_grpc_gcp_ServerHandshakeParameters_local_identities_upb_array(const grpc_gcp_ServerHandshakeParameters * msg,size_t * size)781 UPB_INLINE const upb_Array* _grpc_gcp_ServerHandshakeParameters_local_identities_upb_array(const grpc_gcp_ServerHandshakeParameters* msg, size_t* size) {
782 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
783 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
784 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
785 if (size) {
786 *size = arr ? arr->UPB_PRIVATE(size) : 0;
787 }
788 return arr;
789 }
_grpc_gcp_ServerHandshakeParameters_local_identities_mutable_upb_array(grpc_gcp_ServerHandshakeParameters * msg,size_t * size,upb_Arena * arena)790 UPB_INLINE upb_Array* _grpc_gcp_ServerHandshakeParameters_local_identities_mutable_upb_array(grpc_gcp_ServerHandshakeParameters* msg, size_t* size, upb_Arena* arena) {
791 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
792 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
793 upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
794 &field, arena);
795 if (size) {
796 *size = arr ? arr->UPB_PRIVATE(size) : 0;
797 }
798 return arr;
799 }
800
grpc_gcp_ServerHandshakeParameters_mutable_record_protocols(grpc_gcp_ServerHandshakeParameters * msg,size_t * size)801 UPB_INLINE upb_StringView* grpc_gcp_ServerHandshakeParameters_mutable_record_protocols(grpc_gcp_ServerHandshakeParameters* msg, size_t* size) {
802 upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
803 upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
804 if (arr) {
805 if (size) *size = arr->UPB_PRIVATE(size);
806 return (upb_StringView*)upb_Array_MutableDataPtr(arr);
807 } else {
808 if (size) *size = 0;
809 return NULL;
810 }
811 }
grpc_gcp_ServerHandshakeParameters_resize_record_protocols(grpc_gcp_ServerHandshakeParameters * msg,size_t size,upb_Arena * arena)812 UPB_INLINE upb_StringView* grpc_gcp_ServerHandshakeParameters_resize_record_protocols(grpc_gcp_ServerHandshakeParameters* msg, size_t size, upb_Arena* arena) {
813 upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
814 return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
815 &field, size, arena);
816 }
grpc_gcp_ServerHandshakeParameters_add_record_protocols(grpc_gcp_ServerHandshakeParameters * msg,upb_StringView val,upb_Arena * arena)817 UPB_INLINE bool grpc_gcp_ServerHandshakeParameters_add_record_protocols(grpc_gcp_ServerHandshakeParameters* msg, upb_StringView val, upb_Arena* arena) {
818 upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
819 upb_Array* arr = upb_Message_GetOrCreateMutableArray(
820 UPB_UPCAST(msg), &field, arena);
821 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
822 arr, arr->UPB_PRIVATE(size) + 1, arena)) {
823 return false;
824 }
825 UPB_PRIVATE(_upb_Array_Set)
826 (arr, arr->UPB_PRIVATE(size) - 1, &val, sizeof(val));
827 return true;
828 }
grpc_gcp_ServerHandshakeParameters_mutable_local_identities(grpc_gcp_ServerHandshakeParameters * msg,size_t * size)829 UPB_INLINE grpc_gcp_Identity** grpc_gcp_ServerHandshakeParameters_mutable_local_identities(grpc_gcp_ServerHandshakeParameters* msg, size_t* size) {
830 upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
831 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
832 upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
833 if (arr) {
834 if (size) *size = arr->UPB_PRIVATE(size);
835 return (grpc_gcp_Identity**)upb_Array_MutableDataPtr(arr);
836 } else {
837 if (size) *size = 0;
838 return NULL;
839 }
840 }
grpc_gcp_ServerHandshakeParameters_resize_local_identities(grpc_gcp_ServerHandshakeParameters * msg,size_t size,upb_Arena * arena)841 UPB_INLINE grpc_gcp_Identity** grpc_gcp_ServerHandshakeParameters_resize_local_identities(grpc_gcp_ServerHandshakeParameters* msg, size_t size, upb_Arena* arena) {
842 upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
843 return (grpc_gcp_Identity**)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
844 &field, size, arena);
845 }
grpc_gcp_ServerHandshakeParameters_add_local_identities(grpc_gcp_ServerHandshakeParameters * msg,upb_Arena * arena)846 UPB_INLINE struct grpc_gcp_Identity* grpc_gcp_ServerHandshakeParameters_add_local_identities(grpc_gcp_ServerHandshakeParameters* msg, upb_Arena* arena) {
847 upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
848 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
849 upb_Array* arr = upb_Message_GetOrCreateMutableArray(
850 UPB_UPCAST(msg), &field, arena);
851 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
852 arr, arr->UPB_PRIVATE(size) + 1, arena)) {
853 return NULL;
854 }
855 struct grpc_gcp_Identity* sub = (struct grpc_gcp_Identity*)_upb_Message_New(&grpc__gcp__Identity_msg_init, arena);
856 if (!arr || !sub) return NULL;
857 UPB_PRIVATE(_upb_Array_Set)
858 (arr, arr->UPB_PRIVATE(size) - 1, &sub, sizeof(sub));
859 return sub;
860 }
861
862 /* grpc.gcp.StartServerHandshakeReq */
863
grpc_gcp_StartServerHandshakeReq_new(upb_Arena * arena)864 UPB_INLINE grpc_gcp_StartServerHandshakeReq* grpc_gcp_StartServerHandshakeReq_new(upb_Arena* arena) {
865 return (grpc_gcp_StartServerHandshakeReq*)_upb_Message_New(&grpc__gcp__StartServerHandshakeReq_msg_init, arena);
866 }
grpc_gcp_StartServerHandshakeReq_parse(const char * buf,size_t size,upb_Arena * arena)867 UPB_INLINE grpc_gcp_StartServerHandshakeReq* grpc_gcp_StartServerHandshakeReq_parse(const char* buf, size_t size, upb_Arena* arena) {
868 grpc_gcp_StartServerHandshakeReq* ret = grpc_gcp_StartServerHandshakeReq_new(arena);
869 if (!ret) return NULL;
870 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__StartServerHandshakeReq_msg_init, NULL, 0, arena) !=
871 kUpb_DecodeStatus_Ok) {
872 return NULL;
873 }
874 return ret;
875 }
grpc_gcp_StartServerHandshakeReq_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)876 UPB_INLINE grpc_gcp_StartServerHandshakeReq* grpc_gcp_StartServerHandshakeReq_parse_ex(const char* buf, size_t size,
877 const upb_ExtensionRegistry* extreg,
878 int options, upb_Arena* arena) {
879 grpc_gcp_StartServerHandshakeReq* ret = grpc_gcp_StartServerHandshakeReq_new(arena);
880 if (!ret) return NULL;
881 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__StartServerHandshakeReq_msg_init, extreg, options,
882 arena) != kUpb_DecodeStatus_Ok) {
883 return NULL;
884 }
885 return ret;
886 }
grpc_gcp_StartServerHandshakeReq_serialize(const grpc_gcp_StartServerHandshakeReq * msg,upb_Arena * arena,size_t * len)887 UPB_INLINE char* grpc_gcp_StartServerHandshakeReq_serialize(const grpc_gcp_StartServerHandshakeReq* msg, upb_Arena* arena, size_t* len) {
888 char* ptr;
889 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__StartServerHandshakeReq_msg_init, 0, arena, &ptr, len);
890 return ptr;
891 }
grpc_gcp_StartServerHandshakeReq_serialize_ex(const grpc_gcp_StartServerHandshakeReq * msg,int options,upb_Arena * arena,size_t * len)892 UPB_INLINE char* grpc_gcp_StartServerHandshakeReq_serialize_ex(const grpc_gcp_StartServerHandshakeReq* msg, int options,
893 upb_Arena* arena, size_t* len) {
894 char* ptr;
895 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__StartServerHandshakeReq_msg_init, options, arena, &ptr, len);
896 return ptr;
897 }
grpc_gcp_StartServerHandshakeReq_clear_application_protocols(grpc_gcp_StartServerHandshakeReq * msg)898 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_application_protocols(grpc_gcp_StartServerHandshakeReq* msg) {
899 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
900 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
901 }
grpc_gcp_StartServerHandshakeReq_application_protocols(const grpc_gcp_StartServerHandshakeReq * msg,size_t * size)902 UPB_INLINE upb_StringView const* grpc_gcp_StartServerHandshakeReq_application_protocols(const grpc_gcp_StartServerHandshakeReq* msg, size_t* size) {
903 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
904 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
905 if (arr) {
906 if (size) *size = arr->UPB_PRIVATE(size);
907 return (upb_StringView const*)upb_Array_DataPtr(arr);
908 } else {
909 if (size) *size = 0;
910 return NULL;
911 }
912 }
_grpc_gcp_StartServerHandshakeReq_application_protocols_upb_array(const grpc_gcp_StartServerHandshakeReq * msg,size_t * size)913 UPB_INLINE const upb_Array* _grpc_gcp_StartServerHandshakeReq_application_protocols_upb_array(const grpc_gcp_StartServerHandshakeReq* msg, size_t* size) {
914 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
915 const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
916 if (size) {
917 *size = arr ? arr->UPB_PRIVATE(size) : 0;
918 }
919 return arr;
920 }
_grpc_gcp_StartServerHandshakeReq_application_protocols_mutable_upb_array(grpc_gcp_StartServerHandshakeReq * msg,size_t * size,upb_Arena * arena)921 UPB_INLINE upb_Array* _grpc_gcp_StartServerHandshakeReq_application_protocols_mutable_upb_array(grpc_gcp_StartServerHandshakeReq* msg, size_t* size, upb_Arena* arena) {
922 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
923 upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
924 &field, arena);
925 if (size) {
926 *size = arr ? arr->UPB_PRIVATE(size) : 0;
927 }
928 return arr;
929 }
grpc_gcp_StartServerHandshakeReq_clear_handshake_parameters(grpc_gcp_StartServerHandshakeReq * msg)930 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_handshake_parameters(grpc_gcp_StartServerHandshakeReq* msg) {
931 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
932 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
933 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_size(const grpc_gcp_StartServerHandshakeReq * msg)934 UPB_INLINE size_t grpc_gcp_StartServerHandshakeReq_handshake_parameters_size(const grpc_gcp_StartServerHandshakeReq* msg) {
935 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
936 const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
937 return map ? _upb_Map_Size(map) : 0;
938 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_get(const grpc_gcp_StartServerHandshakeReq * msg,int32_t key,grpc_gcp_ServerHandshakeParameters ** val)939 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_handshake_parameters_get(const grpc_gcp_StartServerHandshakeReq* msg, int32_t key, grpc_gcp_ServerHandshakeParameters** val) {
940 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
941 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq__HandshakeParametersEntry_msg_init);
942 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__ServerHandshakeParameters_msg_init);
943 const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
944 if (!map) return false;
945 return _upb_Map_Get(map, &key, sizeof(key), val, sizeof(*val));
946 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_next(const grpc_gcp_StartServerHandshakeReq * msg,size_t * iter)947 UPB_INLINE const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry* grpc_gcp_StartServerHandshakeReq_handshake_parameters_next(const grpc_gcp_StartServerHandshakeReq* msg, size_t* iter) {
948 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
949 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq__HandshakeParametersEntry_msg_init);
950 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__ServerHandshakeParameters_msg_init);
951 const upb_Map* map = upb_Message_GetMap(UPB_UPCAST(msg), &field);
952 if (!map) return NULL;
953 return (const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry*)_upb_map_next(map, iter);
954 }
_grpc_gcp_StartServerHandshakeReq_handshake_parameters_upb_map(grpc_gcp_StartServerHandshakeReq * msg)955 UPB_INLINE const upb_Map* _grpc_gcp_StartServerHandshakeReq_handshake_parameters_upb_map(grpc_gcp_StartServerHandshakeReq* msg) {
956 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
957 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq__HandshakeParametersEntry_msg_init);
958 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__ServerHandshakeParameters_msg_init);
959 return upb_Message_GetMap(UPB_UPCAST(msg), &field);
960 }
_grpc_gcp_StartServerHandshakeReq_handshake_parameters_mutable_upb_map(grpc_gcp_StartServerHandshakeReq * msg,upb_Arena * a)961 UPB_INLINE upb_Map* _grpc_gcp_StartServerHandshakeReq_handshake_parameters_mutable_upb_map(grpc_gcp_StartServerHandshakeReq* msg, upb_Arena* a) {
962 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
963 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq__HandshakeParametersEntry_msg_init);
964 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__ServerHandshakeParameters_msg_init);
965 return _upb_Message_GetOrCreateMutableMap(UPB_UPCAST(msg), &field, sizeof(int32_t), sizeof(grpc_gcp_ServerHandshakeParameters*), a);
966 }
grpc_gcp_StartServerHandshakeReq_clear_in_bytes(grpc_gcp_StartServerHandshakeReq * msg)967 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_in_bytes(grpc_gcp_StartServerHandshakeReq* msg) {
968 const upb_MiniTableField field = {3, UPB_SIZE(36, 32), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
969 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
970 }
grpc_gcp_StartServerHandshakeReq_in_bytes(const grpc_gcp_StartServerHandshakeReq * msg)971 UPB_INLINE upb_StringView grpc_gcp_StartServerHandshakeReq_in_bytes(const grpc_gcp_StartServerHandshakeReq* msg) {
972 upb_StringView default_val = upb_StringView_FromString("");
973 upb_StringView ret;
974 const upb_MiniTableField field = {3, UPB_SIZE(36, 32), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
975 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
976 &default_val, &ret);
977 return ret;
978 }
grpc_gcp_StartServerHandshakeReq_clear_local_endpoint(grpc_gcp_StartServerHandshakeReq * msg)979 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_local_endpoint(grpc_gcp_StartServerHandshakeReq* msg) {
980 const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
981 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
982 }
grpc_gcp_StartServerHandshakeReq_local_endpoint(const grpc_gcp_StartServerHandshakeReq * msg)983 UPB_INLINE const grpc_gcp_Endpoint* grpc_gcp_StartServerHandshakeReq_local_endpoint(const grpc_gcp_StartServerHandshakeReq* msg) {
984 const grpc_gcp_Endpoint* default_val = NULL;
985 const grpc_gcp_Endpoint* ret;
986 const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
987 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
988 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
989 &default_val, &ret);
990 return ret;
991 }
grpc_gcp_StartServerHandshakeReq_has_local_endpoint(const grpc_gcp_StartServerHandshakeReq * msg)992 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_has_local_endpoint(const grpc_gcp_StartServerHandshakeReq* msg) {
993 const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
994 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
995 }
grpc_gcp_StartServerHandshakeReq_clear_remote_endpoint(grpc_gcp_StartServerHandshakeReq * msg)996 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_remote_endpoint(grpc_gcp_StartServerHandshakeReq* msg) {
997 const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
998 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
999 }
grpc_gcp_StartServerHandshakeReq_remote_endpoint(const grpc_gcp_StartServerHandshakeReq * msg)1000 UPB_INLINE const grpc_gcp_Endpoint* grpc_gcp_StartServerHandshakeReq_remote_endpoint(const grpc_gcp_StartServerHandshakeReq* msg) {
1001 const grpc_gcp_Endpoint* default_val = NULL;
1002 const grpc_gcp_Endpoint* ret;
1003 const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1004 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
1005 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1006 &default_val, &ret);
1007 return ret;
1008 }
grpc_gcp_StartServerHandshakeReq_has_remote_endpoint(const grpc_gcp_StartServerHandshakeReq * msg)1009 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_has_remote_endpoint(const grpc_gcp_StartServerHandshakeReq* msg) {
1010 const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1011 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1012 }
grpc_gcp_StartServerHandshakeReq_clear_rpc_versions(grpc_gcp_StartServerHandshakeReq * msg)1013 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_rpc_versions(grpc_gcp_StartServerHandshakeReq* msg) {
1014 const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1015 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1016 }
grpc_gcp_StartServerHandshakeReq_rpc_versions(const grpc_gcp_StartServerHandshakeReq * msg)1017 UPB_INLINE const struct grpc_gcp_RpcProtocolVersions* grpc_gcp_StartServerHandshakeReq_rpc_versions(const grpc_gcp_StartServerHandshakeReq* msg) {
1018 const struct grpc_gcp_RpcProtocolVersions* default_val = NULL;
1019 const struct grpc_gcp_RpcProtocolVersions* ret;
1020 const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1021 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__RpcProtocolVersions_msg_init);
1022 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1023 &default_val, &ret);
1024 return ret;
1025 }
grpc_gcp_StartServerHandshakeReq_has_rpc_versions(const grpc_gcp_StartServerHandshakeReq * msg)1026 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_has_rpc_versions(const grpc_gcp_StartServerHandshakeReq* msg) {
1027 const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1028 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1029 }
grpc_gcp_StartServerHandshakeReq_clear_max_frame_size(grpc_gcp_StartServerHandshakeReq * msg)1030 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_clear_max_frame_size(grpc_gcp_StartServerHandshakeReq* msg) {
1031 const upb_MiniTableField field = {7, UPB_SIZE(32, 12), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1032 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1033 }
grpc_gcp_StartServerHandshakeReq_max_frame_size(const grpc_gcp_StartServerHandshakeReq * msg)1034 UPB_INLINE uint32_t grpc_gcp_StartServerHandshakeReq_max_frame_size(const grpc_gcp_StartServerHandshakeReq* msg) {
1035 uint32_t default_val = (uint32_t)0u;
1036 uint32_t ret;
1037 const upb_MiniTableField field = {7, UPB_SIZE(32, 12), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1038 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1039 &default_val, &ret);
1040 return ret;
1041 }
1042
grpc_gcp_StartServerHandshakeReq_mutable_application_protocols(grpc_gcp_StartServerHandshakeReq * msg,size_t * size)1043 UPB_INLINE upb_StringView* grpc_gcp_StartServerHandshakeReq_mutable_application_protocols(grpc_gcp_StartServerHandshakeReq* msg, size_t* size) {
1044 upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1045 upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
1046 if (arr) {
1047 if (size) *size = arr->UPB_PRIVATE(size);
1048 return (upb_StringView*)upb_Array_MutableDataPtr(arr);
1049 } else {
1050 if (size) *size = 0;
1051 return NULL;
1052 }
1053 }
grpc_gcp_StartServerHandshakeReq_resize_application_protocols(grpc_gcp_StartServerHandshakeReq * msg,size_t size,upb_Arena * arena)1054 UPB_INLINE upb_StringView* grpc_gcp_StartServerHandshakeReq_resize_application_protocols(grpc_gcp_StartServerHandshakeReq* msg, size_t size, upb_Arena* arena) {
1055 upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1056 return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
1057 &field, size, arena);
1058 }
grpc_gcp_StartServerHandshakeReq_add_application_protocols(grpc_gcp_StartServerHandshakeReq * msg,upb_StringView val,upb_Arena * arena)1059 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_add_application_protocols(grpc_gcp_StartServerHandshakeReq* msg, upb_StringView val, upb_Arena* arena) {
1060 upb_MiniTableField field = {1, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1061 upb_Array* arr = upb_Message_GetOrCreateMutableArray(
1062 UPB_UPCAST(msg), &field, arena);
1063 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
1064 arr, arr->UPB_PRIVATE(size) + 1, arena)) {
1065 return false;
1066 }
1067 UPB_PRIVATE(_upb_Array_Set)
1068 (arr, arr->UPB_PRIVATE(size) - 1, &val, sizeof(val));
1069 return true;
1070 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_clear(grpc_gcp_StartServerHandshakeReq * msg)1071 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_handshake_parameters_clear(grpc_gcp_StartServerHandshakeReq* msg) {
1072 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1073 upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
1074 if (!map) return;
1075 _upb_Map_Clear(map);
1076 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_set(grpc_gcp_StartServerHandshakeReq * msg,int32_t key,grpc_gcp_ServerHandshakeParameters * val,upb_Arena * a)1077 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_handshake_parameters_set(grpc_gcp_StartServerHandshakeReq* msg, int32_t key, grpc_gcp_ServerHandshakeParameters* val, upb_Arena* a) {
1078 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1079 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq__HandshakeParametersEntry_msg_init);
1080 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__ServerHandshakeParameters_msg_init);
1081 upb_Map* map = _upb_Message_GetOrCreateMutableMap(UPB_UPCAST(msg),
1082 &field, sizeof(key), sizeof(val), a);
1083 return _upb_Map_Insert(map, &key, sizeof(key), &val, sizeof(val), a) !=
1084 kUpb_MapInsertStatus_OutOfMemory;
1085 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_delete(grpc_gcp_StartServerHandshakeReq * msg,int32_t key)1086 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_handshake_parameters_delete(grpc_gcp_StartServerHandshakeReq* msg, int32_t key) {
1087 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1088 upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
1089 if (!map) return false;
1090 return _upb_Map_Delete(map, &key, sizeof(key), NULL);
1091 }
grpc_gcp_StartServerHandshakeReq_handshake_parameters_nextmutable(grpc_gcp_StartServerHandshakeReq * msg,size_t * iter)1092 UPB_INLINE grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry* grpc_gcp_StartServerHandshakeReq_handshake_parameters_nextmutable(grpc_gcp_StartServerHandshakeReq* msg, size_t* iter) {
1093 const upb_MiniTableField field = {2, UPB_SIZE(16, 24), 0, 0, 11, (int)kUpb_FieldMode_Map | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1094 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq__HandshakeParametersEntry_msg_init);
1095 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__ServerHandshakeParameters_msg_init);
1096 upb_Map* map = (upb_Map*)upb_Message_GetMap(UPB_UPCAST(msg), &field);
1097 if (!map) return NULL;
1098 return (grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry*)_upb_map_next(map, iter);
1099 }
grpc_gcp_StartServerHandshakeReq_set_in_bytes(grpc_gcp_StartServerHandshakeReq * msg,upb_StringView value)1100 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_set_in_bytes(grpc_gcp_StartServerHandshakeReq *msg, upb_StringView value) {
1101 const upb_MiniTableField field = {3, UPB_SIZE(36, 32), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1102 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1103 }
grpc_gcp_StartServerHandshakeReq_set_local_endpoint(grpc_gcp_StartServerHandshakeReq * msg,grpc_gcp_Endpoint * value)1104 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_set_local_endpoint(grpc_gcp_StartServerHandshakeReq *msg, grpc_gcp_Endpoint* value) {
1105 const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1106 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
1107 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1108 }
grpc_gcp_StartServerHandshakeReq_mutable_local_endpoint(grpc_gcp_StartServerHandshakeReq * msg,upb_Arena * arena)1109 UPB_INLINE struct grpc_gcp_Endpoint* grpc_gcp_StartServerHandshakeReq_mutable_local_endpoint(grpc_gcp_StartServerHandshakeReq* msg, upb_Arena* arena) {
1110 struct grpc_gcp_Endpoint* sub = (struct grpc_gcp_Endpoint*)grpc_gcp_StartServerHandshakeReq_local_endpoint(msg);
1111 if (sub == NULL) {
1112 sub = (struct grpc_gcp_Endpoint*)_upb_Message_New(&grpc__gcp__Endpoint_msg_init, arena);
1113 if (sub) grpc_gcp_StartServerHandshakeReq_set_local_endpoint(msg, sub);
1114 }
1115 return sub;
1116 }
grpc_gcp_StartServerHandshakeReq_set_remote_endpoint(grpc_gcp_StartServerHandshakeReq * msg,grpc_gcp_Endpoint * value)1117 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_set_remote_endpoint(grpc_gcp_StartServerHandshakeReq *msg, grpc_gcp_Endpoint* value) {
1118 const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 65, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1119 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Endpoint_msg_init);
1120 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1121 }
grpc_gcp_StartServerHandshakeReq_mutable_remote_endpoint(grpc_gcp_StartServerHandshakeReq * msg,upb_Arena * arena)1122 UPB_INLINE struct grpc_gcp_Endpoint* grpc_gcp_StartServerHandshakeReq_mutable_remote_endpoint(grpc_gcp_StartServerHandshakeReq* msg, upb_Arena* arena) {
1123 struct grpc_gcp_Endpoint* sub = (struct grpc_gcp_Endpoint*)grpc_gcp_StartServerHandshakeReq_remote_endpoint(msg);
1124 if (sub == NULL) {
1125 sub = (struct grpc_gcp_Endpoint*)_upb_Message_New(&grpc__gcp__Endpoint_msg_init, arena);
1126 if (sub) grpc_gcp_StartServerHandshakeReq_set_remote_endpoint(msg, sub);
1127 }
1128 return sub;
1129 }
grpc_gcp_StartServerHandshakeReq_set_rpc_versions(grpc_gcp_StartServerHandshakeReq * msg,struct grpc_gcp_RpcProtocolVersions * value)1130 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_set_rpc_versions(grpc_gcp_StartServerHandshakeReq *msg, struct grpc_gcp_RpcProtocolVersions* value) {
1131 const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 66, 3, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1132 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__RpcProtocolVersions_msg_init);
1133 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1134 }
grpc_gcp_StartServerHandshakeReq_mutable_rpc_versions(grpc_gcp_StartServerHandshakeReq * msg,upb_Arena * arena)1135 UPB_INLINE struct grpc_gcp_RpcProtocolVersions* grpc_gcp_StartServerHandshakeReq_mutable_rpc_versions(grpc_gcp_StartServerHandshakeReq* msg, upb_Arena* arena) {
1136 struct grpc_gcp_RpcProtocolVersions* sub = (struct grpc_gcp_RpcProtocolVersions*)grpc_gcp_StartServerHandshakeReq_rpc_versions(msg);
1137 if (sub == NULL) {
1138 sub = (struct grpc_gcp_RpcProtocolVersions*)_upb_Message_New(&grpc__gcp__RpcProtocolVersions_msg_init, arena);
1139 if (sub) grpc_gcp_StartServerHandshakeReq_set_rpc_versions(msg, sub);
1140 }
1141 return sub;
1142 }
grpc_gcp_StartServerHandshakeReq_set_max_frame_size(grpc_gcp_StartServerHandshakeReq * msg,uint32_t value)1143 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_set_max_frame_size(grpc_gcp_StartServerHandshakeReq *msg, uint32_t value) {
1144 const upb_MiniTableField field = {7, UPB_SIZE(32, 12), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1145 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1146 }
1147
1148 /* grpc.gcp.StartServerHandshakeReq.HandshakeParametersEntry */
1149
grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_key(const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry * msg)1150 UPB_INLINE int32_t grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_key(const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry* msg) {
1151 int32_t ret;
1152 _upb_msg_map_key(msg, &ret, sizeof(ret));
1153 return ret;
1154 }
grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_value(const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry * msg)1155 UPB_INLINE const grpc_gcp_ServerHandshakeParameters* grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_value(const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry* msg) {
1156 grpc_gcp_ServerHandshakeParameters* ret;
1157 _upb_msg_map_value(msg, &ret, sizeof(ret));
1158 return ret;
1159 }
grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_has_value(const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry * msg)1160 UPB_INLINE bool grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_has_value(const grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry* msg) {
1161 const upb_MiniTableField field = {2, 32, 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1162 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1163 }
1164
grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_set_value(grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry * msg,grpc_gcp_ServerHandshakeParameters * value)1165 UPB_INLINE void grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry_set_value(grpc_gcp_StartServerHandshakeReq_HandshakeParametersEntry *msg, grpc_gcp_ServerHandshakeParameters* value) {
1166 _upb_msg_map_set_value(msg, &value, sizeof(grpc_gcp_ServerHandshakeParameters*));
1167 }
1168
1169 /* grpc.gcp.NextHandshakeMessageReq */
1170
grpc_gcp_NextHandshakeMessageReq_new(upb_Arena * arena)1171 UPB_INLINE grpc_gcp_NextHandshakeMessageReq* grpc_gcp_NextHandshakeMessageReq_new(upb_Arena* arena) {
1172 return (grpc_gcp_NextHandshakeMessageReq*)_upb_Message_New(&grpc__gcp__NextHandshakeMessageReq_msg_init, arena);
1173 }
grpc_gcp_NextHandshakeMessageReq_parse(const char * buf,size_t size,upb_Arena * arena)1174 UPB_INLINE grpc_gcp_NextHandshakeMessageReq* grpc_gcp_NextHandshakeMessageReq_parse(const char* buf, size_t size, upb_Arena* arena) {
1175 grpc_gcp_NextHandshakeMessageReq* ret = grpc_gcp_NextHandshakeMessageReq_new(arena);
1176 if (!ret) return NULL;
1177 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__NextHandshakeMessageReq_msg_init, NULL, 0, arena) !=
1178 kUpb_DecodeStatus_Ok) {
1179 return NULL;
1180 }
1181 return ret;
1182 }
grpc_gcp_NextHandshakeMessageReq_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)1183 UPB_INLINE grpc_gcp_NextHandshakeMessageReq* grpc_gcp_NextHandshakeMessageReq_parse_ex(const char* buf, size_t size,
1184 const upb_ExtensionRegistry* extreg,
1185 int options, upb_Arena* arena) {
1186 grpc_gcp_NextHandshakeMessageReq* ret = grpc_gcp_NextHandshakeMessageReq_new(arena);
1187 if (!ret) return NULL;
1188 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__NextHandshakeMessageReq_msg_init, extreg, options,
1189 arena) != kUpb_DecodeStatus_Ok) {
1190 return NULL;
1191 }
1192 return ret;
1193 }
grpc_gcp_NextHandshakeMessageReq_serialize(const grpc_gcp_NextHandshakeMessageReq * msg,upb_Arena * arena,size_t * len)1194 UPB_INLINE char* grpc_gcp_NextHandshakeMessageReq_serialize(const grpc_gcp_NextHandshakeMessageReq* msg, upb_Arena* arena, size_t* len) {
1195 char* ptr;
1196 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__NextHandshakeMessageReq_msg_init, 0, arena, &ptr, len);
1197 return ptr;
1198 }
grpc_gcp_NextHandshakeMessageReq_serialize_ex(const grpc_gcp_NextHandshakeMessageReq * msg,int options,upb_Arena * arena,size_t * len)1199 UPB_INLINE char* grpc_gcp_NextHandshakeMessageReq_serialize_ex(const grpc_gcp_NextHandshakeMessageReq* msg, int options,
1200 upb_Arena* arena, size_t* len) {
1201 char* ptr;
1202 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__NextHandshakeMessageReq_msg_init, options, arena, &ptr, len);
1203 return ptr;
1204 }
grpc_gcp_NextHandshakeMessageReq_clear_in_bytes(grpc_gcp_NextHandshakeMessageReq * msg)1205 UPB_INLINE void grpc_gcp_NextHandshakeMessageReq_clear_in_bytes(grpc_gcp_NextHandshakeMessageReq* msg) {
1206 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1207 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1208 }
grpc_gcp_NextHandshakeMessageReq_in_bytes(const grpc_gcp_NextHandshakeMessageReq * msg)1209 UPB_INLINE upb_StringView grpc_gcp_NextHandshakeMessageReq_in_bytes(const grpc_gcp_NextHandshakeMessageReq* msg) {
1210 upb_StringView default_val = upb_StringView_FromString("");
1211 upb_StringView ret;
1212 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1213 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1214 &default_val, &ret);
1215 return ret;
1216 }
1217
grpc_gcp_NextHandshakeMessageReq_set_in_bytes(grpc_gcp_NextHandshakeMessageReq * msg,upb_StringView value)1218 UPB_INLINE void grpc_gcp_NextHandshakeMessageReq_set_in_bytes(grpc_gcp_NextHandshakeMessageReq *msg, upb_StringView value) {
1219 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1220 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1221 }
1222
1223 /* grpc.gcp.HandshakerReq */
1224
grpc_gcp_HandshakerReq_new(upb_Arena * arena)1225 UPB_INLINE grpc_gcp_HandshakerReq* grpc_gcp_HandshakerReq_new(upb_Arena* arena) {
1226 return (grpc_gcp_HandshakerReq*)_upb_Message_New(&grpc__gcp__HandshakerReq_msg_init, arena);
1227 }
grpc_gcp_HandshakerReq_parse(const char * buf,size_t size,upb_Arena * arena)1228 UPB_INLINE grpc_gcp_HandshakerReq* grpc_gcp_HandshakerReq_parse(const char* buf, size_t size, upb_Arena* arena) {
1229 grpc_gcp_HandshakerReq* ret = grpc_gcp_HandshakerReq_new(arena);
1230 if (!ret) return NULL;
1231 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerReq_msg_init, NULL, 0, arena) !=
1232 kUpb_DecodeStatus_Ok) {
1233 return NULL;
1234 }
1235 return ret;
1236 }
grpc_gcp_HandshakerReq_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)1237 UPB_INLINE grpc_gcp_HandshakerReq* grpc_gcp_HandshakerReq_parse_ex(const char* buf, size_t size,
1238 const upb_ExtensionRegistry* extreg,
1239 int options, upb_Arena* arena) {
1240 grpc_gcp_HandshakerReq* ret = grpc_gcp_HandshakerReq_new(arena);
1241 if (!ret) return NULL;
1242 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerReq_msg_init, extreg, options,
1243 arena) != kUpb_DecodeStatus_Ok) {
1244 return NULL;
1245 }
1246 return ret;
1247 }
grpc_gcp_HandshakerReq_serialize(const grpc_gcp_HandshakerReq * msg,upb_Arena * arena,size_t * len)1248 UPB_INLINE char* grpc_gcp_HandshakerReq_serialize(const grpc_gcp_HandshakerReq* msg, upb_Arena* arena, size_t* len) {
1249 char* ptr;
1250 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerReq_msg_init, 0, arena, &ptr, len);
1251 return ptr;
1252 }
grpc_gcp_HandshakerReq_serialize_ex(const grpc_gcp_HandshakerReq * msg,int options,upb_Arena * arena,size_t * len)1253 UPB_INLINE char* grpc_gcp_HandshakerReq_serialize_ex(const grpc_gcp_HandshakerReq* msg, int options,
1254 upb_Arena* arena, size_t* len) {
1255 char* ptr;
1256 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerReq_msg_init, options, arena, &ptr, len);
1257 return ptr;
1258 }
1259 typedef enum {
1260 grpc_gcp_HandshakerReq_req_oneof_client_start = 1,
1261 grpc_gcp_HandshakerReq_req_oneof_server_start = 2,
1262 grpc_gcp_HandshakerReq_req_oneof_next = 3,
1263 grpc_gcp_HandshakerReq_req_oneof_NOT_SET = 0
1264 } grpc_gcp_HandshakerReq_req_oneof_oneofcases;
grpc_gcp_HandshakerReq_req_oneof_case(const grpc_gcp_HandshakerReq * msg)1265 UPB_INLINE grpc_gcp_HandshakerReq_req_oneof_oneofcases grpc_gcp_HandshakerReq_req_oneof_case(const grpc_gcp_HandshakerReq* msg) {
1266 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1267 return (grpc_gcp_HandshakerReq_req_oneof_oneofcases)upb_Message_WhichOneofFieldNumber(
1268 UPB_UPCAST(msg), &field);
1269 }
grpc_gcp_HandshakerReq_clear_client_start(grpc_gcp_HandshakerReq * msg)1270 UPB_INLINE void grpc_gcp_HandshakerReq_clear_client_start(grpc_gcp_HandshakerReq* msg) {
1271 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1272 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1273 }
grpc_gcp_HandshakerReq_client_start(const grpc_gcp_HandshakerReq * msg)1274 UPB_INLINE const grpc_gcp_StartClientHandshakeReq* grpc_gcp_HandshakerReq_client_start(const grpc_gcp_HandshakerReq* msg) {
1275 const grpc_gcp_StartClientHandshakeReq* default_val = NULL;
1276 const grpc_gcp_StartClientHandshakeReq* ret;
1277 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1278 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartClientHandshakeReq_msg_init);
1279 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1280 &default_val, &ret);
1281 return ret;
1282 }
grpc_gcp_HandshakerReq_has_client_start(const grpc_gcp_HandshakerReq * msg)1283 UPB_INLINE bool grpc_gcp_HandshakerReq_has_client_start(const grpc_gcp_HandshakerReq* msg) {
1284 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1285 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1286 }
grpc_gcp_HandshakerReq_clear_server_start(grpc_gcp_HandshakerReq * msg)1287 UPB_INLINE void grpc_gcp_HandshakerReq_clear_server_start(grpc_gcp_HandshakerReq* msg) {
1288 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), -9, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1289 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1290 }
grpc_gcp_HandshakerReq_server_start(const grpc_gcp_HandshakerReq * msg)1291 UPB_INLINE const grpc_gcp_StartServerHandshakeReq* grpc_gcp_HandshakerReq_server_start(const grpc_gcp_HandshakerReq* msg) {
1292 const grpc_gcp_StartServerHandshakeReq* default_val = NULL;
1293 const grpc_gcp_StartServerHandshakeReq* ret;
1294 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), -9, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1295 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq_msg_init);
1296 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1297 &default_val, &ret);
1298 return ret;
1299 }
grpc_gcp_HandshakerReq_has_server_start(const grpc_gcp_HandshakerReq * msg)1300 UPB_INLINE bool grpc_gcp_HandshakerReq_has_server_start(const grpc_gcp_HandshakerReq* msg) {
1301 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), -9, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1302 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1303 }
grpc_gcp_HandshakerReq_clear_next(grpc_gcp_HandshakerReq * msg)1304 UPB_INLINE void grpc_gcp_HandshakerReq_clear_next(grpc_gcp_HandshakerReq* msg) {
1305 const upb_MiniTableField field = {3, UPB_SIZE(12, 16), -9, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1306 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1307 }
grpc_gcp_HandshakerReq_next(const grpc_gcp_HandshakerReq * msg)1308 UPB_INLINE const grpc_gcp_NextHandshakeMessageReq* grpc_gcp_HandshakerReq_next(const grpc_gcp_HandshakerReq* msg) {
1309 const grpc_gcp_NextHandshakeMessageReq* default_val = NULL;
1310 const grpc_gcp_NextHandshakeMessageReq* ret;
1311 const upb_MiniTableField field = {3, UPB_SIZE(12, 16), -9, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1312 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__NextHandshakeMessageReq_msg_init);
1313 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1314 &default_val, &ret);
1315 return ret;
1316 }
grpc_gcp_HandshakerReq_has_next(const grpc_gcp_HandshakerReq * msg)1317 UPB_INLINE bool grpc_gcp_HandshakerReq_has_next(const grpc_gcp_HandshakerReq* msg) {
1318 const upb_MiniTableField field = {3, UPB_SIZE(12, 16), -9, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1319 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1320 }
1321
grpc_gcp_HandshakerReq_set_client_start(grpc_gcp_HandshakerReq * msg,grpc_gcp_StartClientHandshakeReq * value)1322 UPB_INLINE void grpc_gcp_HandshakerReq_set_client_start(grpc_gcp_HandshakerReq *msg, grpc_gcp_StartClientHandshakeReq* value) {
1323 const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1324 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartClientHandshakeReq_msg_init);
1325 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1326 }
grpc_gcp_HandshakerReq_mutable_client_start(grpc_gcp_HandshakerReq * msg,upb_Arena * arena)1327 UPB_INLINE struct grpc_gcp_StartClientHandshakeReq* grpc_gcp_HandshakerReq_mutable_client_start(grpc_gcp_HandshakerReq* msg, upb_Arena* arena) {
1328 struct grpc_gcp_StartClientHandshakeReq* sub = (struct grpc_gcp_StartClientHandshakeReq*)grpc_gcp_HandshakerReq_client_start(msg);
1329 if (sub == NULL) {
1330 sub = (struct grpc_gcp_StartClientHandshakeReq*)_upb_Message_New(&grpc__gcp__StartClientHandshakeReq_msg_init, arena);
1331 if (sub) grpc_gcp_HandshakerReq_set_client_start(msg, sub);
1332 }
1333 return sub;
1334 }
grpc_gcp_HandshakerReq_set_server_start(grpc_gcp_HandshakerReq * msg,grpc_gcp_StartServerHandshakeReq * value)1335 UPB_INLINE void grpc_gcp_HandshakerReq_set_server_start(grpc_gcp_HandshakerReq *msg, grpc_gcp_StartServerHandshakeReq* value) {
1336 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), -9, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1337 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__StartServerHandshakeReq_msg_init);
1338 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1339 }
grpc_gcp_HandshakerReq_mutable_server_start(grpc_gcp_HandshakerReq * msg,upb_Arena * arena)1340 UPB_INLINE struct grpc_gcp_StartServerHandshakeReq* grpc_gcp_HandshakerReq_mutable_server_start(grpc_gcp_HandshakerReq* msg, upb_Arena* arena) {
1341 struct grpc_gcp_StartServerHandshakeReq* sub = (struct grpc_gcp_StartServerHandshakeReq*)grpc_gcp_HandshakerReq_server_start(msg);
1342 if (sub == NULL) {
1343 sub = (struct grpc_gcp_StartServerHandshakeReq*)_upb_Message_New(&grpc__gcp__StartServerHandshakeReq_msg_init, arena);
1344 if (sub) grpc_gcp_HandshakerReq_set_server_start(msg, sub);
1345 }
1346 return sub;
1347 }
grpc_gcp_HandshakerReq_set_next(grpc_gcp_HandshakerReq * msg,grpc_gcp_NextHandshakeMessageReq * value)1348 UPB_INLINE void grpc_gcp_HandshakerReq_set_next(grpc_gcp_HandshakerReq *msg, grpc_gcp_NextHandshakeMessageReq* value) {
1349 const upb_MiniTableField field = {3, UPB_SIZE(12, 16), -9, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1350 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__NextHandshakeMessageReq_msg_init);
1351 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1352 }
grpc_gcp_HandshakerReq_mutable_next(grpc_gcp_HandshakerReq * msg,upb_Arena * arena)1353 UPB_INLINE struct grpc_gcp_NextHandshakeMessageReq* grpc_gcp_HandshakerReq_mutable_next(grpc_gcp_HandshakerReq* msg, upb_Arena* arena) {
1354 struct grpc_gcp_NextHandshakeMessageReq* sub = (struct grpc_gcp_NextHandshakeMessageReq*)grpc_gcp_HandshakerReq_next(msg);
1355 if (sub == NULL) {
1356 sub = (struct grpc_gcp_NextHandshakeMessageReq*)_upb_Message_New(&grpc__gcp__NextHandshakeMessageReq_msg_init, arena);
1357 if (sub) grpc_gcp_HandshakerReq_set_next(msg, sub);
1358 }
1359 return sub;
1360 }
1361
1362 /* grpc.gcp.HandshakerResult */
1363
grpc_gcp_HandshakerResult_new(upb_Arena * arena)1364 UPB_INLINE grpc_gcp_HandshakerResult* grpc_gcp_HandshakerResult_new(upb_Arena* arena) {
1365 return (grpc_gcp_HandshakerResult*)_upb_Message_New(&grpc__gcp__HandshakerResult_msg_init, arena);
1366 }
grpc_gcp_HandshakerResult_parse(const char * buf,size_t size,upb_Arena * arena)1367 UPB_INLINE grpc_gcp_HandshakerResult* grpc_gcp_HandshakerResult_parse(const char* buf, size_t size, upb_Arena* arena) {
1368 grpc_gcp_HandshakerResult* ret = grpc_gcp_HandshakerResult_new(arena);
1369 if (!ret) return NULL;
1370 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerResult_msg_init, NULL, 0, arena) !=
1371 kUpb_DecodeStatus_Ok) {
1372 return NULL;
1373 }
1374 return ret;
1375 }
grpc_gcp_HandshakerResult_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)1376 UPB_INLINE grpc_gcp_HandshakerResult* grpc_gcp_HandshakerResult_parse_ex(const char* buf, size_t size,
1377 const upb_ExtensionRegistry* extreg,
1378 int options, upb_Arena* arena) {
1379 grpc_gcp_HandshakerResult* ret = grpc_gcp_HandshakerResult_new(arena);
1380 if (!ret) return NULL;
1381 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerResult_msg_init, extreg, options,
1382 arena) != kUpb_DecodeStatus_Ok) {
1383 return NULL;
1384 }
1385 return ret;
1386 }
grpc_gcp_HandshakerResult_serialize(const grpc_gcp_HandshakerResult * msg,upb_Arena * arena,size_t * len)1387 UPB_INLINE char* grpc_gcp_HandshakerResult_serialize(const grpc_gcp_HandshakerResult* msg, upb_Arena* arena, size_t* len) {
1388 char* ptr;
1389 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerResult_msg_init, 0, arena, &ptr, len);
1390 return ptr;
1391 }
grpc_gcp_HandshakerResult_serialize_ex(const grpc_gcp_HandshakerResult * msg,int options,upb_Arena * arena,size_t * len)1392 UPB_INLINE char* grpc_gcp_HandshakerResult_serialize_ex(const grpc_gcp_HandshakerResult* msg, int options,
1393 upb_Arena* arena, size_t* len) {
1394 char* ptr;
1395 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerResult_msg_init, options, arena, &ptr, len);
1396 return ptr;
1397 }
grpc_gcp_HandshakerResult_clear_application_protocol(grpc_gcp_HandshakerResult * msg)1398 UPB_INLINE void grpc_gcp_HandshakerResult_clear_application_protocol(grpc_gcp_HandshakerResult* msg) {
1399 const upb_MiniTableField field = {1, UPB_SIZE(32, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1400 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1401 }
grpc_gcp_HandshakerResult_application_protocol(const grpc_gcp_HandshakerResult * msg)1402 UPB_INLINE upb_StringView grpc_gcp_HandshakerResult_application_protocol(const grpc_gcp_HandshakerResult* msg) {
1403 upb_StringView default_val = upb_StringView_FromString("");
1404 upb_StringView ret;
1405 const upb_MiniTableField field = {1, UPB_SIZE(32, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1406 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1407 &default_val, &ret);
1408 return ret;
1409 }
grpc_gcp_HandshakerResult_clear_record_protocol(grpc_gcp_HandshakerResult * msg)1410 UPB_INLINE void grpc_gcp_HandshakerResult_clear_record_protocol(grpc_gcp_HandshakerResult* msg) {
1411 const upb_MiniTableField field = {2, UPB_SIZE(40, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1412 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1413 }
grpc_gcp_HandshakerResult_record_protocol(const grpc_gcp_HandshakerResult * msg)1414 UPB_INLINE upb_StringView grpc_gcp_HandshakerResult_record_protocol(const grpc_gcp_HandshakerResult* msg) {
1415 upb_StringView default_val = upb_StringView_FromString("");
1416 upb_StringView ret;
1417 const upb_MiniTableField field = {2, UPB_SIZE(40, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1418 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1419 &default_val, &ret);
1420 return ret;
1421 }
grpc_gcp_HandshakerResult_clear_key_data(grpc_gcp_HandshakerResult * msg)1422 UPB_INLINE void grpc_gcp_HandshakerResult_clear_key_data(grpc_gcp_HandshakerResult* msg) {
1423 const upb_MiniTableField field = {3, 48, 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1424 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1425 }
grpc_gcp_HandshakerResult_key_data(const grpc_gcp_HandshakerResult * msg)1426 UPB_INLINE upb_StringView grpc_gcp_HandshakerResult_key_data(const grpc_gcp_HandshakerResult* msg) {
1427 upb_StringView default_val = upb_StringView_FromString("");
1428 upb_StringView ret;
1429 const upb_MiniTableField field = {3, 48, 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1430 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1431 &default_val, &ret);
1432 return ret;
1433 }
grpc_gcp_HandshakerResult_clear_peer_identity(grpc_gcp_HandshakerResult * msg)1434 UPB_INLINE void grpc_gcp_HandshakerResult_clear_peer_identity(grpc_gcp_HandshakerResult* msg) {
1435 const upb_MiniTableField field = {4, UPB_SIZE(12, 64), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1436 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1437 }
grpc_gcp_HandshakerResult_peer_identity(const grpc_gcp_HandshakerResult * msg)1438 UPB_INLINE const grpc_gcp_Identity* grpc_gcp_HandshakerResult_peer_identity(const grpc_gcp_HandshakerResult* msg) {
1439 const grpc_gcp_Identity* default_val = NULL;
1440 const grpc_gcp_Identity* ret;
1441 const upb_MiniTableField field = {4, UPB_SIZE(12, 64), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1442 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
1443 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1444 &default_val, &ret);
1445 return ret;
1446 }
grpc_gcp_HandshakerResult_has_peer_identity(const grpc_gcp_HandshakerResult * msg)1447 UPB_INLINE bool grpc_gcp_HandshakerResult_has_peer_identity(const grpc_gcp_HandshakerResult* msg) {
1448 const upb_MiniTableField field = {4, UPB_SIZE(12, 64), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1449 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1450 }
grpc_gcp_HandshakerResult_clear_local_identity(grpc_gcp_HandshakerResult * msg)1451 UPB_INLINE void grpc_gcp_HandshakerResult_clear_local_identity(grpc_gcp_HandshakerResult* msg) {
1452 const upb_MiniTableField field = {5, UPB_SIZE(16, 72), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1453 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1454 }
grpc_gcp_HandshakerResult_local_identity(const grpc_gcp_HandshakerResult * msg)1455 UPB_INLINE const grpc_gcp_Identity* grpc_gcp_HandshakerResult_local_identity(const grpc_gcp_HandshakerResult* msg) {
1456 const grpc_gcp_Identity* default_val = NULL;
1457 const grpc_gcp_Identity* ret;
1458 const upb_MiniTableField field = {5, UPB_SIZE(16, 72), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1459 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
1460 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1461 &default_val, &ret);
1462 return ret;
1463 }
grpc_gcp_HandshakerResult_has_local_identity(const grpc_gcp_HandshakerResult * msg)1464 UPB_INLINE bool grpc_gcp_HandshakerResult_has_local_identity(const grpc_gcp_HandshakerResult* msg) {
1465 const upb_MiniTableField field = {5, UPB_SIZE(16, 72), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1466 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1467 }
grpc_gcp_HandshakerResult_clear_keep_channel_open(grpc_gcp_HandshakerResult * msg)1468 UPB_INLINE void grpc_gcp_HandshakerResult_clear_keep_channel_open(grpc_gcp_HandshakerResult* msg) {
1469 const upb_MiniTableField field = {6, UPB_SIZE(20, 9), 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
1470 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1471 }
grpc_gcp_HandshakerResult_keep_channel_open(const grpc_gcp_HandshakerResult * msg)1472 UPB_INLINE bool grpc_gcp_HandshakerResult_keep_channel_open(const grpc_gcp_HandshakerResult* msg) {
1473 bool default_val = false;
1474 bool ret;
1475 const upb_MiniTableField field = {6, UPB_SIZE(20, 9), 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
1476 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1477 &default_val, &ret);
1478 return ret;
1479 }
grpc_gcp_HandshakerResult_clear_peer_rpc_versions(grpc_gcp_HandshakerResult * msg)1480 UPB_INLINE void grpc_gcp_HandshakerResult_clear_peer_rpc_versions(grpc_gcp_HandshakerResult* msg) {
1481 const upb_MiniTableField field = {7, UPB_SIZE(24, 80), 66, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1482 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1483 }
grpc_gcp_HandshakerResult_peer_rpc_versions(const grpc_gcp_HandshakerResult * msg)1484 UPB_INLINE const struct grpc_gcp_RpcProtocolVersions* grpc_gcp_HandshakerResult_peer_rpc_versions(const grpc_gcp_HandshakerResult* msg) {
1485 const struct grpc_gcp_RpcProtocolVersions* default_val = NULL;
1486 const struct grpc_gcp_RpcProtocolVersions* ret;
1487 const upb_MiniTableField field = {7, UPB_SIZE(24, 80), 66, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1488 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__RpcProtocolVersions_msg_init);
1489 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1490 &default_val, &ret);
1491 return ret;
1492 }
grpc_gcp_HandshakerResult_has_peer_rpc_versions(const grpc_gcp_HandshakerResult * msg)1493 UPB_INLINE bool grpc_gcp_HandshakerResult_has_peer_rpc_versions(const grpc_gcp_HandshakerResult* msg) {
1494 const upb_MiniTableField field = {7, UPB_SIZE(24, 80), 66, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1495 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1496 }
grpc_gcp_HandshakerResult_clear_max_frame_size(grpc_gcp_HandshakerResult * msg)1497 UPB_INLINE void grpc_gcp_HandshakerResult_clear_max_frame_size(grpc_gcp_HandshakerResult* msg) {
1498 const upb_MiniTableField field = {8, UPB_SIZE(28, 12), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1499 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1500 }
grpc_gcp_HandshakerResult_max_frame_size(const grpc_gcp_HandshakerResult * msg)1501 UPB_INLINE uint32_t grpc_gcp_HandshakerResult_max_frame_size(const grpc_gcp_HandshakerResult* msg) {
1502 uint32_t default_val = (uint32_t)0u;
1503 uint32_t ret;
1504 const upb_MiniTableField field = {8, UPB_SIZE(28, 12), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1505 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1506 &default_val, &ret);
1507 return ret;
1508 }
1509
grpc_gcp_HandshakerResult_set_application_protocol(grpc_gcp_HandshakerResult * msg,upb_StringView value)1510 UPB_INLINE void grpc_gcp_HandshakerResult_set_application_protocol(grpc_gcp_HandshakerResult *msg, upb_StringView value) {
1511 const upb_MiniTableField field = {1, UPB_SIZE(32, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1512 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1513 }
grpc_gcp_HandshakerResult_set_record_protocol(grpc_gcp_HandshakerResult * msg,upb_StringView value)1514 UPB_INLINE void grpc_gcp_HandshakerResult_set_record_protocol(grpc_gcp_HandshakerResult *msg, upb_StringView value) {
1515 const upb_MiniTableField field = {2, UPB_SIZE(40, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1516 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1517 }
grpc_gcp_HandshakerResult_set_key_data(grpc_gcp_HandshakerResult * msg,upb_StringView value)1518 UPB_INLINE void grpc_gcp_HandshakerResult_set_key_data(grpc_gcp_HandshakerResult *msg, upb_StringView value) {
1519 const upb_MiniTableField field = {3, 48, 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1520 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1521 }
grpc_gcp_HandshakerResult_set_peer_identity(grpc_gcp_HandshakerResult * msg,grpc_gcp_Identity * value)1522 UPB_INLINE void grpc_gcp_HandshakerResult_set_peer_identity(grpc_gcp_HandshakerResult *msg, grpc_gcp_Identity* value) {
1523 const upb_MiniTableField field = {4, UPB_SIZE(12, 64), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1524 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
1525 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1526 }
grpc_gcp_HandshakerResult_mutable_peer_identity(grpc_gcp_HandshakerResult * msg,upb_Arena * arena)1527 UPB_INLINE struct grpc_gcp_Identity* grpc_gcp_HandshakerResult_mutable_peer_identity(grpc_gcp_HandshakerResult* msg, upb_Arena* arena) {
1528 struct grpc_gcp_Identity* sub = (struct grpc_gcp_Identity*)grpc_gcp_HandshakerResult_peer_identity(msg);
1529 if (sub == NULL) {
1530 sub = (struct grpc_gcp_Identity*)_upb_Message_New(&grpc__gcp__Identity_msg_init, arena);
1531 if (sub) grpc_gcp_HandshakerResult_set_peer_identity(msg, sub);
1532 }
1533 return sub;
1534 }
grpc_gcp_HandshakerResult_set_local_identity(grpc_gcp_HandshakerResult * msg,grpc_gcp_Identity * value)1535 UPB_INLINE void grpc_gcp_HandshakerResult_set_local_identity(grpc_gcp_HandshakerResult *msg, grpc_gcp_Identity* value) {
1536 const upb_MiniTableField field = {5, UPB_SIZE(16, 72), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1537 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__Identity_msg_init);
1538 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1539 }
grpc_gcp_HandshakerResult_mutable_local_identity(grpc_gcp_HandshakerResult * msg,upb_Arena * arena)1540 UPB_INLINE struct grpc_gcp_Identity* grpc_gcp_HandshakerResult_mutable_local_identity(grpc_gcp_HandshakerResult* msg, upb_Arena* arena) {
1541 struct grpc_gcp_Identity* sub = (struct grpc_gcp_Identity*)grpc_gcp_HandshakerResult_local_identity(msg);
1542 if (sub == NULL) {
1543 sub = (struct grpc_gcp_Identity*)_upb_Message_New(&grpc__gcp__Identity_msg_init, arena);
1544 if (sub) grpc_gcp_HandshakerResult_set_local_identity(msg, sub);
1545 }
1546 return sub;
1547 }
grpc_gcp_HandshakerResult_set_keep_channel_open(grpc_gcp_HandshakerResult * msg,bool value)1548 UPB_INLINE void grpc_gcp_HandshakerResult_set_keep_channel_open(grpc_gcp_HandshakerResult *msg, bool value) {
1549 const upb_MiniTableField field = {6, UPB_SIZE(20, 9), 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
1550 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1551 }
grpc_gcp_HandshakerResult_set_peer_rpc_versions(grpc_gcp_HandshakerResult * msg,struct grpc_gcp_RpcProtocolVersions * value)1552 UPB_INLINE void grpc_gcp_HandshakerResult_set_peer_rpc_versions(grpc_gcp_HandshakerResult *msg, struct grpc_gcp_RpcProtocolVersions* value) {
1553 const upb_MiniTableField field = {7, UPB_SIZE(24, 80), 66, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1554 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__RpcProtocolVersions_msg_init);
1555 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1556 }
grpc_gcp_HandshakerResult_mutable_peer_rpc_versions(grpc_gcp_HandshakerResult * msg,upb_Arena * arena)1557 UPB_INLINE struct grpc_gcp_RpcProtocolVersions* grpc_gcp_HandshakerResult_mutable_peer_rpc_versions(grpc_gcp_HandshakerResult* msg, upb_Arena* arena) {
1558 struct grpc_gcp_RpcProtocolVersions* sub = (struct grpc_gcp_RpcProtocolVersions*)grpc_gcp_HandshakerResult_peer_rpc_versions(msg);
1559 if (sub == NULL) {
1560 sub = (struct grpc_gcp_RpcProtocolVersions*)_upb_Message_New(&grpc__gcp__RpcProtocolVersions_msg_init, arena);
1561 if (sub) grpc_gcp_HandshakerResult_set_peer_rpc_versions(msg, sub);
1562 }
1563 return sub;
1564 }
grpc_gcp_HandshakerResult_set_max_frame_size(grpc_gcp_HandshakerResult * msg,uint32_t value)1565 UPB_INLINE void grpc_gcp_HandshakerResult_set_max_frame_size(grpc_gcp_HandshakerResult *msg, uint32_t value) {
1566 const upb_MiniTableField field = {8, UPB_SIZE(28, 12), 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1567 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1568 }
1569
1570 /* grpc.gcp.HandshakerStatus */
1571
grpc_gcp_HandshakerStatus_new(upb_Arena * arena)1572 UPB_INLINE grpc_gcp_HandshakerStatus* grpc_gcp_HandshakerStatus_new(upb_Arena* arena) {
1573 return (grpc_gcp_HandshakerStatus*)_upb_Message_New(&grpc__gcp__HandshakerStatus_msg_init, arena);
1574 }
grpc_gcp_HandshakerStatus_parse(const char * buf,size_t size,upb_Arena * arena)1575 UPB_INLINE grpc_gcp_HandshakerStatus* grpc_gcp_HandshakerStatus_parse(const char* buf, size_t size, upb_Arena* arena) {
1576 grpc_gcp_HandshakerStatus* ret = grpc_gcp_HandshakerStatus_new(arena);
1577 if (!ret) return NULL;
1578 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerStatus_msg_init, NULL, 0, arena) !=
1579 kUpb_DecodeStatus_Ok) {
1580 return NULL;
1581 }
1582 return ret;
1583 }
grpc_gcp_HandshakerStatus_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)1584 UPB_INLINE grpc_gcp_HandshakerStatus* grpc_gcp_HandshakerStatus_parse_ex(const char* buf, size_t size,
1585 const upb_ExtensionRegistry* extreg,
1586 int options, upb_Arena* arena) {
1587 grpc_gcp_HandshakerStatus* ret = grpc_gcp_HandshakerStatus_new(arena);
1588 if (!ret) return NULL;
1589 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerStatus_msg_init, extreg, options,
1590 arena) != kUpb_DecodeStatus_Ok) {
1591 return NULL;
1592 }
1593 return ret;
1594 }
grpc_gcp_HandshakerStatus_serialize(const grpc_gcp_HandshakerStatus * msg,upb_Arena * arena,size_t * len)1595 UPB_INLINE char* grpc_gcp_HandshakerStatus_serialize(const grpc_gcp_HandshakerStatus* msg, upb_Arena* arena, size_t* len) {
1596 char* ptr;
1597 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerStatus_msg_init, 0, arena, &ptr, len);
1598 return ptr;
1599 }
grpc_gcp_HandshakerStatus_serialize_ex(const grpc_gcp_HandshakerStatus * msg,int options,upb_Arena * arena,size_t * len)1600 UPB_INLINE char* grpc_gcp_HandshakerStatus_serialize_ex(const grpc_gcp_HandshakerStatus* msg, int options,
1601 upb_Arena* arena, size_t* len) {
1602 char* ptr;
1603 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerStatus_msg_init, options, arena, &ptr, len);
1604 return ptr;
1605 }
grpc_gcp_HandshakerStatus_clear_code(grpc_gcp_HandshakerStatus * msg)1606 UPB_INLINE void grpc_gcp_HandshakerStatus_clear_code(grpc_gcp_HandshakerStatus* msg) {
1607 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1608 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1609 }
grpc_gcp_HandshakerStatus_code(const grpc_gcp_HandshakerStatus * msg)1610 UPB_INLINE uint32_t grpc_gcp_HandshakerStatus_code(const grpc_gcp_HandshakerStatus* msg) {
1611 uint32_t default_val = (uint32_t)0u;
1612 uint32_t ret;
1613 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1614 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1615 &default_val, &ret);
1616 return ret;
1617 }
grpc_gcp_HandshakerStatus_clear_details(grpc_gcp_HandshakerStatus * msg)1618 UPB_INLINE void grpc_gcp_HandshakerStatus_clear_details(grpc_gcp_HandshakerStatus* msg) {
1619 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1620 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1621 }
grpc_gcp_HandshakerStatus_details(const grpc_gcp_HandshakerStatus * msg)1622 UPB_INLINE upb_StringView grpc_gcp_HandshakerStatus_details(const grpc_gcp_HandshakerStatus* msg) {
1623 upb_StringView default_val = upb_StringView_FromString("");
1624 upb_StringView ret;
1625 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1626 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1627 &default_val, &ret);
1628 return ret;
1629 }
1630
grpc_gcp_HandshakerStatus_set_code(grpc_gcp_HandshakerStatus * msg,uint32_t value)1631 UPB_INLINE void grpc_gcp_HandshakerStatus_set_code(grpc_gcp_HandshakerStatus *msg, uint32_t value) {
1632 const upb_MiniTableField field = {1, 8, 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1633 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1634 }
grpc_gcp_HandshakerStatus_set_details(grpc_gcp_HandshakerStatus * msg,upb_StringView value)1635 UPB_INLINE void grpc_gcp_HandshakerStatus_set_details(grpc_gcp_HandshakerStatus *msg, upb_StringView value) {
1636 const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1637 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1638 }
1639
1640 /* grpc.gcp.HandshakerResp */
1641
grpc_gcp_HandshakerResp_new(upb_Arena * arena)1642 UPB_INLINE grpc_gcp_HandshakerResp* grpc_gcp_HandshakerResp_new(upb_Arena* arena) {
1643 return (grpc_gcp_HandshakerResp*)_upb_Message_New(&grpc__gcp__HandshakerResp_msg_init, arena);
1644 }
grpc_gcp_HandshakerResp_parse(const char * buf,size_t size,upb_Arena * arena)1645 UPB_INLINE grpc_gcp_HandshakerResp* grpc_gcp_HandshakerResp_parse(const char* buf, size_t size, upb_Arena* arena) {
1646 grpc_gcp_HandshakerResp* ret = grpc_gcp_HandshakerResp_new(arena);
1647 if (!ret) return NULL;
1648 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerResp_msg_init, NULL, 0, arena) !=
1649 kUpb_DecodeStatus_Ok) {
1650 return NULL;
1651 }
1652 return ret;
1653 }
grpc_gcp_HandshakerResp_parse_ex(const char * buf,size_t size,const upb_ExtensionRegistry * extreg,int options,upb_Arena * arena)1654 UPB_INLINE grpc_gcp_HandshakerResp* grpc_gcp_HandshakerResp_parse_ex(const char* buf, size_t size,
1655 const upb_ExtensionRegistry* extreg,
1656 int options, upb_Arena* arena) {
1657 grpc_gcp_HandshakerResp* ret = grpc_gcp_HandshakerResp_new(arena);
1658 if (!ret) return NULL;
1659 if (upb_Decode(buf, size, UPB_UPCAST(ret), &grpc__gcp__HandshakerResp_msg_init, extreg, options,
1660 arena) != kUpb_DecodeStatus_Ok) {
1661 return NULL;
1662 }
1663 return ret;
1664 }
grpc_gcp_HandshakerResp_serialize(const grpc_gcp_HandshakerResp * msg,upb_Arena * arena,size_t * len)1665 UPB_INLINE char* grpc_gcp_HandshakerResp_serialize(const grpc_gcp_HandshakerResp* msg, upb_Arena* arena, size_t* len) {
1666 char* ptr;
1667 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerResp_msg_init, 0, arena, &ptr, len);
1668 return ptr;
1669 }
grpc_gcp_HandshakerResp_serialize_ex(const grpc_gcp_HandshakerResp * msg,int options,upb_Arena * arena,size_t * len)1670 UPB_INLINE char* grpc_gcp_HandshakerResp_serialize_ex(const grpc_gcp_HandshakerResp* msg, int options,
1671 upb_Arena* arena, size_t* len) {
1672 char* ptr;
1673 (void)upb_Encode(UPB_UPCAST(msg), &grpc__gcp__HandshakerResp_msg_init, options, arena, &ptr, len);
1674 return ptr;
1675 }
grpc_gcp_HandshakerResp_clear_out_frames(grpc_gcp_HandshakerResp * msg)1676 UPB_INLINE void grpc_gcp_HandshakerResp_clear_out_frames(grpc_gcp_HandshakerResp* msg) {
1677 const upb_MiniTableField field = {1, UPB_SIZE(24, 16), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1678 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1679 }
grpc_gcp_HandshakerResp_out_frames(const grpc_gcp_HandshakerResp * msg)1680 UPB_INLINE upb_StringView grpc_gcp_HandshakerResp_out_frames(const grpc_gcp_HandshakerResp* msg) {
1681 upb_StringView default_val = upb_StringView_FromString("");
1682 upb_StringView ret;
1683 const upb_MiniTableField field = {1, UPB_SIZE(24, 16), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1684 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1685 &default_val, &ret);
1686 return ret;
1687 }
grpc_gcp_HandshakerResp_clear_bytes_consumed(grpc_gcp_HandshakerResp * msg)1688 UPB_INLINE void grpc_gcp_HandshakerResp_clear_bytes_consumed(grpc_gcp_HandshakerResp* msg) {
1689 const upb_MiniTableField field = {2, 12, 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1690 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1691 }
grpc_gcp_HandshakerResp_bytes_consumed(const grpc_gcp_HandshakerResp * msg)1692 UPB_INLINE uint32_t grpc_gcp_HandshakerResp_bytes_consumed(const grpc_gcp_HandshakerResp* msg) {
1693 uint32_t default_val = (uint32_t)0u;
1694 uint32_t ret;
1695 const upb_MiniTableField field = {2, 12, 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1696 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1697 &default_val, &ret);
1698 return ret;
1699 }
grpc_gcp_HandshakerResp_clear_result(grpc_gcp_HandshakerResp * msg)1700 UPB_INLINE void grpc_gcp_HandshakerResp_clear_result(grpc_gcp_HandshakerResp* msg) {
1701 const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1702 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1703 }
grpc_gcp_HandshakerResp_result(const grpc_gcp_HandshakerResp * msg)1704 UPB_INLINE const grpc_gcp_HandshakerResult* grpc_gcp_HandshakerResp_result(const grpc_gcp_HandshakerResp* msg) {
1705 const grpc_gcp_HandshakerResult* default_val = NULL;
1706 const grpc_gcp_HandshakerResult* ret;
1707 const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1708 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__HandshakerResult_msg_init);
1709 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1710 &default_val, &ret);
1711 return ret;
1712 }
grpc_gcp_HandshakerResp_has_result(const grpc_gcp_HandshakerResp * msg)1713 UPB_INLINE bool grpc_gcp_HandshakerResp_has_result(const grpc_gcp_HandshakerResp* msg) {
1714 const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1715 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1716 }
grpc_gcp_HandshakerResp_clear_status(grpc_gcp_HandshakerResp * msg)1717 UPB_INLINE void grpc_gcp_HandshakerResp_clear_status(grpc_gcp_HandshakerResp* msg) {
1718 const upb_MiniTableField field = {4, UPB_SIZE(20, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1719 upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
1720 }
grpc_gcp_HandshakerResp_status(const grpc_gcp_HandshakerResp * msg)1721 UPB_INLINE const grpc_gcp_HandshakerStatus* grpc_gcp_HandshakerResp_status(const grpc_gcp_HandshakerResp* msg) {
1722 const grpc_gcp_HandshakerStatus* default_val = NULL;
1723 const grpc_gcp_HandshakerStatus* ret;
1724 const upb_MiniTableField field = {4, UPB_SIZE(20, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1725 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__HandshakerStatus_msg_init);
1726 _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
1727 &default_val, &ret);
1728 return ret;
1729 }
grpc_gcp_HandshakerResp_has_status(const grpc_gcp_HandshakerResp * msg)1730 UPB_INLINE bool grpc_gcp_HandshakerResp_has_status(const grpc_gcp_HandshakerResp* msg) {
1731 const upb_MiniTableField field = {4, UPB_SIZE(20, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1732 return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
1733 }
1734
grpc_gcp_HandshakerResp_set_out_frames(grpc_gcp_HandshakerResp * msg,upb_StringView value)1735 UPB_INLINE void grpc_gcp_HandshakerResp_set_out_frames(grpc_gcp_HandshakerResp *msg, upb_StringView value) {
1736 const upb_MiniTableField field = {1, UPB_SIZE(24, 16), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
1737 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1738 }
grpc_gcp_HandshakerResp_set_bytes_consumed(grpc_gcp_HandshakerResp * msg,uint32_t value)1739 UPB_INLINE void grpc_gcp_HandshakerResp_set_bytes_consumed(grpc_gcp_HandshakerResp *msg, uint32_t value) {
1740 const upb_MiniTableField field = {2, 12, 0, kUpb_NoSub, 13, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
1741 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1742 }
grpc_gcp_HandshakerResp_set_result(grpc_gcp_HandshakerResp * msg,grpc_gcp_HandshakerResult * value)1743 UPB_INLINE void grpc_gcp_HandshakerResp_set_result(grpc_gcp_HandshakerResp *msg, grpc_gcp_HandshakerResult* value) {
1744 const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1745 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__HandshakerResult_msg_init);
1746 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1747 }
grpc_gcp_HandshakerResp_mutable_result(grpc_gcp_HandshakerResp * msg,upb_Arena * arena)1748 UPB_INLINE struct grpc_gcp_HandshakerResult* grpc_gcp_HandshakerResp_mutable_result(grpc_gcp_HandshakerResp* msg, upb_Arena* arena) {
1749 struct grpc_gcp_HandshakerResult* sub = (struct grpc_gcp_HandshakerResult*)grpc_gcp_HandshakerResp_result(msg);
1750 if (sub == NULL) {
1751 sub = (struct grpc_gcp_HandshakerResult*)_upb_Message_New(&grpc__gcp__HandshakerResult_msg_init, arena);
1752 if (sub) grpc_gcp_HandshakerResp_set_result(msg, sub);
1753 }
1754 return sub;
1755 }
grpc_gcp_HandshakerResp_set_status(grpc_gcp_HandshakerResp * msg,grpc_gcp_HandshakerStatus * value)1756 UPB_INLINE void grpc_gcp_HandshakerResp_set_status(grpc_gcp_HandshakerResp *msg, grpc_gcp_HandshakerStatus* value) {
1757 const upb_MiniTableField field = {4, UPB_SIZE(20, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
1758 UPB_PRIVATE(_upb_MiniTable_StrongReference)(&grpc__gcp__HandshakerStatus_msg_init);
1759 upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
1760 }
grpc_gcp_HandshakerResp_mutable_status(grpc_gcp_HandshakerResp * msg,upb_Arena * arena)1761 UPB_INLINE struct grpc_gcp_HandshakerStatus* grpc_gcp_HandshakerResp_mutable_status(grpc_gcp_HandshakerResp* msg, upb_Arena* arena) {
1762 struct grpc_gcp_HandshakerStatus* sub = (struct grpc_gcp_HandshakerStatus*)grpc_gcp_HandshakerResp_status(msg);
1763 if (sub == NULL) {
1764 sub = (struct grpc_gcp_HandshakerStatus*)_upb_Message_New(&grpc__gcp__HandshakerStatus_msg_init, arena);
1765 if (sub) grpc_gcp_HandshakerResp_set_status(msg, sub);
1766 }
1767 return sub;
1768 }
1769
1770 #ifdef __cplusplus
1771 } /* extern "C" */
1772 #endif
1773
1774 #include "upb/port/undef.inc"
1775
1776 #endif /* SRC_PROTO_GRPC_GCP_HANDSHAKER_PROTO_UPB_H__UPB_H_ */
1777