1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2023 Google LLC. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 #ifndef UPB_MESSAGE_ACCESSORS_H_
9 #define UPB_MESSAGE_ACCESSORS_H_
10
11 #include <stddef.h>
12 #include <stdint.h>
13 #include <string.h>
14
15 #include "upb/base/descriptor_constants.h"
16 #include "upb/base/string_view.h"
17 #include "upb/mem/arena.h"
18 #include "upb/message/array.h"
19 #include "upb/message/internal/accessors.h"
20 #include "upb/message/internal/array.h"
21 #include "upb/message/internal/map.h"
22 #include "upb/message/internal/message.h"
23 #include "upb/message/internal/tagged_ptr.h"
24 #include "upb/message/map.h"
25 #include "upb/message/tagged_ptr.h"
26 #include "upb/message/value.h"
27 #include "upb/mini_table/enum.h"
28 #include "upb/mini_table/sub.h"
29
30 // Must be last.
31 #include "upb/port/def.inc"
32
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36
37 // Functions ending in BaseField() take a (upb_MiniTableField*) argument
38 // and work only on non-extension fields.
39 //
40 // Functions ending in Extension() take a (upb_MiniTableExtension*) argument
41 // and work only on extensions.
42
upb_Message_Clear(upb_Message * msg,const upb_MiniTable * m)43 UPB_API_INLINE void upb_Message_Clear(upb_Message* msg,
44 const upb_MiniTable* m) {
45 UPB_PRIVATE(_upb_Message_Clear)(msg, m);
46 }
47
upb_Message_ClearBaseField(upb_Message * msg,const upb_MiniTableField * f)48 UPB_API_INLINE void upb_Message_ClearBaseField(upb_Message* msg,
49 const upb_MiniTableField* f) {
50 UPB_PRIVATE(_upb_Message_ClearBaseField)(msg, f);
51 }
52
upb_Message_ClearExtension(upb_Message * msg,const upb_MiniTableExtension * e)53 UPB_API_INLINE void upb_Message_ClearExtension(
54 upb_Message* msg, const upb_MiniTableExtension* e) {
55 UPB_PRIVATE(_upb_Message_ClearExtension)(msg, e);
56 }
57
upb_Message_HasBaseField(const upb_Message * msg,const upb_MiniTableField * f)58 UPB_API_INLINE bool upb_Message_HasBaseField(const upb_Message* msg,
59 const upb_MiniTableField* f) {
60 return UPB_PRIVATE(_upb_Message_HasBaseField)(msg, f);
61 }
62
upb_Message_HasExtension(const upb_Message * msg,const upb_MiniTableExtension * e)63 UPB_API_INLINE bool upb_Message_HasExtension(const upb_Message* msg,
64 const upb_MiniTableExtension* e) {
65 return UPB_PRIVATE(_upb_Message_HasExtension)(msg, e);
66 }
67
upb_Message_WhichOneofFieldNumber(const upb_Message * message,const upb_MiniTableField * oneof_field)68 UPB_API_INLINE uint32_t upb_Message_WhichOneofFieldNumber(
69 const upb_Message* message, const upb_MiniTableField* oneof_field) {
70 UPB_ASSUME(upb_MiniTableField_IsInOneof(oneof_field));
71 return UPB_PRIVATE(_upb_Message_GetOneofCase)(message, oneof_field);
72 }
73
74 // NOTE: The default_val is only used for fields that support presence.
75 // For repeated/map fields, the resulting upb_Array*/upb_Map* can be NULL if a
76 // upb_Array/upb_Map has not been allocated yet. Array/map fields do not have
77 // presence, so this is semantically identical to a pointer to an empty
78 // array/map, and must be treated the same for all semantic purposes.
79 UPB_INLINE upb_MessageValue
upb_Message_GetField(const upb_Message * msg,const upb_MiniTableField * field,upb_MessageValue default_val)80 upb_Message_GetField(const upb_Message* msg, const upb_MiniTableField* field,
81 upb_MessageValue default_val) {
82 upb_MessageValue ret;
83 if (upb_MiniTableField_IsExtension(field)) {
84 _upb_Message_GetExtensionField(msg, (upb_MiniTableExtension*)field,
85 &default_val, &ret);
86 } else {
87 _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
88 }
89 return ret;
90 }
91
upb_Message_SetField(upb_Message * msg,const upb_MiniTableField * field,upb_MessageValue val,upb_Arena * a)92 UPB_INLINE bool upb_Message_SetField(upb_Message* msg,
93 const upb_MiniTableField* field,
94 upb_MessageValue val, upb_Arena* a) {
95 if (upb_MiniTableField_IsExtension(field)) {
96 const upb_MiniTableExtension* ext = (const upb_MiniTableExtension*)field;
97 return _upb_Message_SetExtensionField(msg, ext, &val, a);
98 } else {
99 _upb_Message_SetNonExtensionField(msg, field, &val);
100 return true;
101 }
102 }
103
upb_Message_GetBool(const upb_Message * msg,const upb_MiniTableField * field,bool default_val)104 UPB_API_INLINE bool upb_Message_GetBool(const upb_Message* msg,
105 const upb_MiniTableField* field,
106 bool default_val) {
107 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
108 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
109 kUpb_FieldRep_1Byte);
110 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
111 upb_MessageValue def;
112 def.bool_val = default_val;
113 return upb_Message_GetField(msg, field, def).bool_val;
114 }
115
upb_Message_SetBool(upb_Message * msg,const upb_MiniTableField * field,bool value,upb_Arena * a)116 UPB_API_INLINE bool upb_Message_SetBool(upb_Message* msg,
117 const upb_MiniTableField* field,
118 bool value, upb_Arena* a) {
119 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
120 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
121 kUpb_FieldRep_1Byte);
122 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
123 upb_MessageValue val;
124 val.bool_val = value;
125 return upb_Message_SetField(msg, field, val, a);
126 }
127
upb_Message_GetInt32(const upb_Message * msg,const upb_MiniTableField * field,int32_t default_val)128 UPB_API_INLINE int32_t upb_Message_GetInt32(const upb_Message* msg,
129 const upb_MiniTableField* field,
130 int32_t default_val) {
131 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
132 upb_MiniTableField_CType(field) == kUpb_CType_Enum);
133 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
134 kUpb_FieldRep_4Byte);
135 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
136
137 upb_MessageValue def;
138 def.int32_val = default_val;
139 return upb_Message_GetField(msg, field, def).int32_val;
140 }
141
upb_Message_SetInt32(upb_Message * msg,const upb_MiniTableField * field,int32_t value,upb_Arena * a)142 UPB_API_INLINE bool upb_Message_SetInt32(upb_Message* msg,
143 const upb_MiniTableField* field,
144 int32_t value, upb_Arena* a) {
145 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
146 upb_MiniTableField_CType(field) == kUpb_CType_Enum);
147 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
148 kUpb_FieldRep_4Byte);
149 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
150 upb_MessageValue val;
151 val.int32_val = value;
152 return upb_Message_SetField(msg, field, val, a);
153 }
154
upb_Message_GetUInt32(const upb_Message * msg,const upb_MiniTableField * field,uint32_t default_val)155 UPB_API_INLINE uint32_t upb_Message_GetUInt32(const upb_Message* msg,
156 const upb_MiniTableField* field,
157 uint32_t default_val) {
158 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
159 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
160 kUpb_FieldRep_4Byte);
161 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
162
163 upb_MessageValue def;
164 def.uint32_val = default_val;
165 return upb_Message_GetField(msg, field, def).uint32_val;
166 }
167
upb_Message_SetUInt32(upb_Message * msg,const upb_MiniTableField * field,uint32_t value,upb_Arena * a)168 UPB_API_INLINE bool upb_Message_SetUInt32(upb_Message* msg,
169 const upb_MiniTableField* field,
170 uint32_t value, upb_Arena* a) {
171 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
172 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
173 kUpb_FieldRep_4Byte);
174 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
175 upb_MessageValue val;
176 val.uint32_val = value;
177 return upb_Message_SetField(msg, field, val, a);
178 }
179
upb_Message_SetClosedEnum(upb_Message * msg,const upb_MiniTable * msg_mini_table,const upb_MiniTableField * field,int32_t value)180 UPB_API_INLINE void upb_Message_SetClosedEnum(
181 upb_Message* msg, const upb_MiniTable* msg_mini_table,
182 const upb_MiniTableField* field, int32_t value) {
183 UPB_ASSERT(upb_MiniTableField_IsClosedEnum(field));
184 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
185 kUpb_FieldRep_4Byte);
186 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
187 UPB_ASSERT(upb_MiniTableEnum_CheckValue(
188 upb_MiniTable_GetSubEnumTable(msg_mini_table, field), value));
189 _upb_Message_SetNonExtensionField(msg, field, &value);
190 }
191
upb_Message_GetInt64(const upb_Message * msg,const upb_MiniTableField * field,int64_t default_val)192 UPB_API_INLINE int64_t upb_Message_GetInt64(const upb_Message* msg,
193 const upb_MiniTableField* field,
194 int64_t default_val) {
195 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
196 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
197 kUpb_FieldRep_8Byte);
198 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
199
200 upb_MessageValue def;
201 def.int64_val = default_val;
202 return upb_Message_GetField(msg, field, def).int64_val;
203 }
204
upb_Message_SetInt64(upb_Message * msg,const upb_MiniTableField * field,int64_t value,upb_Arena * a)205 UPB_API_INLINE bool upb_Message_SetInt64(upb_Message* msg,
206 const upb_MiniTableField* field,
207 int64_t value, upb_Arena* a) {
208 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
209 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
210 kUpb_FieldRep_8Byte);
211 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
212 upb_MessageValue val;
213 val.int64_val = value;
214 return upb_Message_SetField(msg, field, val, a);
215 }
216
upb_Message_GetUInt64(const upb_Message * msg,const upb_MiniTableField * field,uint64_t default_val)217 UPB_API_INLINE uint64_t upb_Message_GetUInt64(const upb_Message* msg,
218 const upb_MiniTableField* field,
219 uint64_t default_val) {
220 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
221 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
222 kUpb_FieldRep_8Byte);
223 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
224
225 upb_MessageValue def;
226 def.uint64_val = default_val;
227 return upb_Message_GetField(msg, field, def).uint64_val;
228 }
229
upb_Message_SetUInt64(upb_Message * msg,const upb_MiniTableField * field,uint64_t value,upb_Arena * a)230 UPB_API_INLINE bool upb_Message_SetUInt64(upb_Message* msg,
231 const upb_MiniTableField* field,
232 uint64_t value, upb_Arena* a) {
233 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
234 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
235 kUpb_FieldRep_8Byte);
236 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
237 upb_MessageValue val;
238 val.uint64_val = value;
239 return upb_Message_SetField(msg, field, val, a);
240 }
241
upb_Message_GetFloat(const upb_Message * msg,const upb_MiniTableField * field,float default_val)242 UPB_API_INLINE float upb_Message_GetFloat(const upb_Message* msg,
243 const upb_MiniTableField* field,
244 float default_val) {
245 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
246 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
247 kUpb_FieldRep_4Byte);
248 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
249
250 upb_MessageValue def;
251 def.float_val = default_val;
252 return upb_Message_GetField(msg, field, def).float_val;
253 }
254
upb_Message_SetFloat(upb_Message * msg,const upb_MiniTableField * field,float value,upb_Arena * a)255 UPB_API_INLINE bool upb_Message_SetFloat(upb_Message* msg,
256 const upb_MiniTableField* field,
257 float value, upb_Arena* a) {
258 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
259 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
260 kUpb_FieldRep_4Byte);
261 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
262 upb_MessageValue val;
263 val.float_val = value;
264 return upb_Message_SetField(msg, field, val, a);
265 }
266
upb_Message_GetDouble(const upb_Message * msg,const upb_MiniTableField * field,double default_val)267 UPB_API_INLINE double upb_Message_GetDouble(const upb_Message* msg,
268 const upb_MiniTableField* field,
269 double default_val) {
270 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
271 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
272 kUpb_FieldRep_8Byte);
273 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
274
275 upb_MessageValue def;
276 def.double_val = default_val;
277 return upb_Message_GetField(msg, field, def).double_val;
278 }
279
upb_Message_SetDouble(upb_Message * msg,const upb_MiniTableField * field,double value,upb_Arena * a)280 UPB_API_INLINE bool upb_Message_SetDouble(upb_Message* msg,
281 const upb_MiniTableField* field,
282 double value, upb_Arena* a) {
283 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
284 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
285 kUpb_FieldRep_8Byte);
286 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
287 upb_MessageValue val;
288 val.double_val = value;
289 return upb_Message_SetField(msg, field, val, a);
290 }
291
292 UPB_API_INLINE upb_StringView
upb_Message_GetString(const upb_Message * msg,const upb_MiniTableField * field,upb_StringView default_val)293 upb_Message_GetString(const upb_Message* msg, const upb_MiniTableField* field,
294 upb_StringView default_val) {
295 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
296 upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
297 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
298 kUpb_FieldRep_StringView);
299 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
300
301 upb_MessageValue def;
302 def.str_val = default_val;
303 return upb_Message_GetField(msg, field, def).str_val;
304 }
305
upb_Message_SetString(upb_Message * msg,const upb_MiniTableField * field,upb_StringView value,upb_Arena * a)306 UPB_API_INLINE bool upb_Message_SetString(upb_Message* msg,
307 const upb_MiniTableField* field,
308 upb_StringView value, upb_Arena* a) {
309 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
310 upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
311 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
312 kUpb_FieldRep_StringView);
313 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
314 upb_MessageValue val;
315 val.str_val = value;
316 return upb_Message_SetField(msg, field, val, a);
317 }
318
upb_Message_GetTaggedMessagePtr(const upb_Message * msg,const upb_MiniTableField * field,upb_Message * default_val)319 UPB_API_INLINE upb_TaggedMessagePtr upb_Message_GetTaggedMessagePtr(
320 const upb_Message* msg, const upb_MiniTableField* field,
321 upb_Message* default_val) {
322 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
323 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
324 UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
325 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
326 upb_TaggedMessagePtr tagged;
327 _upb_Message_GetNonExtensionField(msg, field, &default_val, &tagged);
328 return tagged;
329 }
330
upb_Message_GetMessage(const upb_Message * msg,const upb_MiniTableField * field,upb_Message * default_val)331 UPB_API_INLINE const upb_Message* upb_Message_GetMessage(
332 const upb_Message* msg, const upb_MiniTableField* field,
333 upb_Message* default_val) {
334 upb_TaggedMessagePtr tagged =
335 upb_Message_GetTaggedMessagePtr(msg, field, default_val);
336 return upb_TaggedMessagePtr_GetNonEmptyMessage(tagged);
337 }
338
339 // For internal use only; users cannot set tagged messages because only the
340 // parser and the message copier are allowed to directly create an empty
341 // message.
_upb_Message_SetTaggedMessagePtr(upb_Message * msg,const upb_MiniTable * mini_table,const upb_MiniTableField * field,upb_TaggedMessagePtr sub_message)342 UPB_API_INLINE void _upb_Message_SetTaggedMessagePtr(
343 upb_Message* msg, const upb_MiniTable* mini_table,
344 const upb_MiniTableField* field, upb_TaggedMessagePtr sub_message) {
345 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
346 UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
347 UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
348 UPB_ASSUME(upb_MiniTableField_IsScalar(field));
349 UPB_ASSERT(upb_MiniTableSub_Message(
350 mini_table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)]));
351 _upb_Message_SetNonExtensionField(msg, field, &sub_message);
352 }
353
upb_Message_SetMessage(upb_Message * msg,const upb_MiniTable * mini_table,const upb_MiniTableField * field,upb_Message * sub_message)354 UPB_API_INLINE void upb_Message_SetMessage(upb_Message* msg,
355 const upb_MiniTable* mini_table,
356 const upb_MiniTableField* field,
357 upb_Message* sub_message) {
358 _upb_Message_SetTaggedMessagePtr(
359 msg, mini_table, field,
360 UPB_PRIVATE(_upb_TaggedMessagePtr_Pack)(sub_message, false));
361 }
362
upb_Message_GetOrCreateMutableMessage(upb_Message * msg,const upb_MiniTable * mini_table,const upb_MiniTableField * field,upb_Arena * arena)363 UPB_API_INLINE upb_Message* upb_Message_GetOrCreateMutableMessage(
364 upb_Message* msg, const upb_MiniTable* mini_table,
365 const upb_MiniTableField* field, upb_Arena* arena) {
366 UPB_ASSERT(arena);
367 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
368 upb_Message* sub_message =
369 *UPB_PTR_AT(msg, field->UPB_ONLYBITS(offset), upb_Message*);
370 if (!sub_message) {
371 const upb_MiniTable* sub_mini_table = upb_MiniTableSub_Message(
372 mini_table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)]);
373 UPB_ASSERT(sub_mini_table);
374 sub_message = _upb_Message_New(sub_mini_table, arena);
375 *UPB_PTR_AT(msg, field->UPB_ONLYBITS(offset), upb_Message*) = sub_message;
376 UPB_PRIVATE(_upb_Message_SetPresence)(msg, field);
377 }
378 return sub_message;
379 }
380
upb_Message_GetArray(const upb_Message * msg,const upb_MiniTableField * field)381 UPB_API_INLINE const upb_Array* upb_Message_GetArray(
382 const upb_Message* msg, const upb_MiniTableField* field) {
383 UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
384 upb_Array* ret;
385 const upb_Array* default_val = NULL;
386 _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
387 return ret;
388 }
389
upb_Message_GetMutableArray(upb_Message * msg,const upb_MiniTableField * field)390 UPB_API_INLINE upb_Array* upb_Message_GetMutableArray(
391 upb_Message* msg, const upb_MiniTableField* field) {
392 UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
393 return (upb_Array*)upb_Message_GetArray(msg, field);
394 }
395
upb_Message_GetOrCreateMutableArray(upb_Message * msg,const upb_MiniTableField * field,upb_Arena * arena)396 UPB_API_INLINE upb_Array* upb_Message_GetOrCreateMutableArray(
397 upb_Message* msg, const upb_MiniTableField* field, upb_Arena* arena) {
398 UPB_ASSERT(arena);
399 UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
400 upb_Array* array = upb_Message_GetMutableArray(msg, field);
401 if (!array) {
402 array = UPB_PRIVATE(_upb_Array_New)(
403 arena, 4, UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)(field));
404 // Check again due to: https://godbolt.org/z/7WfaoKG1r
405 UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
406 upb_MessageValue val;
407 val.array_val = array;
408 upb_Message_SetField(msg, field, val, arena);
409 }
410 return array;
411 }
412
upb_Message_ResizeArrayUninitialized(upb_Message * msg,const upb_MiniTableField * field,size_t size,upb_Arena * arena)413 UPB_API_INLINE void* upb_Message_ResizeArrayUninitialized(
414 upb_Message* msg, const upb_MiniTableField* field, size_t size,
415 upb_Arena* arena) {
416 UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
417 upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, field, arena);
418 if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(arr, size, arena)) {
419 return NULL;
420 }
421 return upb_Array_MutableDataPtr(arr);
422 }
423
upb_Message_GetMap(const upb_Message * msg,const upb_MiniTableField * field)424 UPB_API_INLINE const upb_Map* upb_Message_GetMap(
425 const upb_Message* msg, const upb_MiniTableField* field) {
426 UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
427 _upb_Message_AssertMapIsUntagged(msg, field);
428 upb_Map* ret;
429 const upb_Map* default_val = NULL;
430 _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
431 return ret;
432 }
433
upb_Message_GetMutableMap(upb_Message * msg,const upb_MiniTableField * field)434 UPB_API_INLINE upb_Map* upb_Message_GetMutableMap(
435 upb_Message* msg, const upb_MiniTableField* field) {
436 return (upb_Map*)upb_Message_GetMap(msg, field);
437 }
438
upb_Message_GetOrCreateMutableMap(upb_Message * msg,const upb_MiniTable * map_entry_mini_table,const upb_MiniTableField * field,upb_Arena * arena)439 UPB_API_INLINE upb_Map* upb_Message_GetOrCreateMutableMap(
440 upb_Message* msg, const upb_MiniTable* map_entry_mini_table,
441 const upb_MiniTableField* field, upb_Arena* arena) {
442 UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
443 const upb_MiniTableField* map_entry_key_field =
444 &map_entry_mini_table->UPB_PRIVATE(fields)[0];
445 const upb_MiniTableField* map_entry_value_field =
446 &map_entry_mini_table->UPB_PRIVATE(fields)[1];
447 return _upb_Message_GetOrCreateMutableMap(
448 msg, field,
449 _upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_key_field)),
450 _upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_value_field)),
451 arena);
452 }
453
454 // Updates a map entry given an entry message.
455 bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* mini_table,
456 const upb_MiniTableField* field,
457 upb_Message* map_entry_message, upb_Arena* arena);
458
459 #ifdef __cplusplus
460 } /* extern "C" */
461 #endif
462
463 #include "upb/port/undef.inc"
464
465 #endif // UPB_MESSAGE_ACCESSORS_H_
466