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