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