google-protobuf 4.27.1 → 4.28.0

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of google-protobuf might be problematic. Click here for more details.

@@ -342,10 +342,81 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
342
342
  #define UPB_DESC_MINITABLE(sym) &google__protobuf__##sym##_msg_init
343
343
  #endif
344
344
 
345
- #ifdef UPB_TRACING_ENABLED
346
- #ifdef NDEBUG
347
- error UPB_TRACING_ENABLED Tracing should be disabled in production builds
348
- #endif
345
+
346
+ // Linker arrays combine elements from multiple translation units into a single
347
+ // array that can be iterated over at runtime.
348
+ //
349
+ // It is an alternative to pre-main "registration" functions.
350
+ //
351
+ // Usage:
352
+ //
353
+ // // In N translation units.
354
+ // UPB_LINKARR_APPEND(foo_array) static int elems[3] = {1, 2, 3};
355
+ //
356
+ // // At runtime:
357
+ // UPB_LINKARR_DECLARE(foo_array, int);
358
+ //
359
+ // void f() {
360
+ // const int* start = UPB_LINKARR_START(foo_array);
361
+ // const int* stop = UPB_LINKARR_STOP(foo_array);
362
+ // for (const int* p = start; p < stop; p++) {
363
+ // // Windows can introduce zero padding, so we have to skip zeroes.
364
+ // if (*p != 0) {
365
+ // vec.push_back(*p);
366
+ // }
367
+ // }
368
+ // }
369
+
370
+ #if defined(__ELF__) || defined(__wasm__)
371
+
372
+ #define UPB_LINKARR_APPEND(name) \
373
+ __attribute__((retain, used, section("linkarr_" #name)))
374
+ #define UPB_LINKARR_DECLARE(name, type) \
375
+ extern type const __start_linkarr_##name; \
376
+ extern type const __stop_linkarr_##name; \
377
+ UPB_LINKARR_APPEND(name) type UPB_linkarr_internal_empty_##name[1]
378
+ #define UPB_LINKARR_START(name) (&__start_linkarr_##name)
379
+ #define UPB_LINKARR_STOP(name) (&__stop_linkarr_##name)
380
+
381
+ #elif defined(__MACH__)
382
+
383
+ /* As described in: https://stackoverflow.com/a/22366882 */
384
+ #define UPB_LINKARR_APPEND(name) \
385
+ __attribute__((retain, used, section("__DATA,__la_" #name)))
386
+ #define UPB_LINKARR_DECLARE(name, type) \
387
+ extern type const __start_linkarr_##name __asm( \
388
+ "section$start$__DATA$__la_" #name); \
389
+ extern type const __stop_linkarr_##name __asm( \
390
+ "section$end$__DATA$" \
391
+ "__la_" #name); \
392
+ UPB_LINKARR_APPEND(name) type UPB_linkarr_internal_empty_##name[1]
393
+ #define UPB_LINKARR_START(name) (&__start_linkarr_##name)
394
+ #define UPB_LINKARR_STOP(name) (&__stop_linkarr_##name)
395
+
396
+ #elif defined(_MSC_VER) && defined(__clang__)
397
+
398
+ /* See:
399
+ * https://devblogs.microsoft.com/oldnewthing/20181107-00/?p=100155
400
+ * https://devblogs.microsoft.com/oldnewthing/20181108-00/?p=100165
401
+ * https://devblogs.microsoft.com/oldnewthing/20181109-00/?p=100175 */
402
+
403
+ // Usage of __attribute__ here probably means this is Clang-specific, and would
404
+ // not work on MSVC.
405
+ #define UPB_LINKARR_APPEND(name) \
406
+ __declspec(allocate("la_" #name "$j")) __attribute__((retain, used))
407
+ #define UPB_LINKARR_DECLARE(name, type) \
408
+ __declspec(allocate("la_" #name "$a")) type __start_linkarr_##name; \
409
+ __declspec(allocate("la_" #name "$z")) type __stop_linkarr_##name; \
410
+ UPB_LINKARR_APPEND(name) type UPB_linkarr_internal_empty_##name[1] = {0}
411
+ #define UPB_LINKARR_START(name) (&__start_linkarr_##name)
412
+ #define UPB_LINKARR_STOP(name) (&__stop_linkarr_##name)
413
+
414
+ #else
415
+
416
+ // Linker arrays are not supported on this platform. Make appends a no-op but
417
+ // don't define the other macros.
418
+ #define UPB_LINKARR_APPEND(name)
419
+
349
420
  #endif
350
421
 
351
422
  #ifndef UPB_BASE_STATUS_H_
@@ -415,113 +486,6 @@ void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
415
486
  #ifndef UPB_MESSAGE_ACCESSORS_H_
416
487
  #define UPB_MESSAGE_ACCESSORS_H_
417
488
 
418
- #include <stddef.h>
419
- #include <stdint.h>
420
- #include <string.h>
421
-
422
-
423
- #ifndef UPB_BASE_DESCRIPTOR_CONSTANTS_H_
424
- #define UPB_BASE_DESCRIPTOR_CONSTANTS_H_
425
-
426
- // Must be last.
427
-
428
- // The types a field can have. Note that this list is not identical to the
429
- // types defined in descriptor.proto, which gives INT32 and SINT32 separate
430
- // types (we distinguish the two with the "integer encoding" enum below).
431
- // This enum is an internal convenience only and has no meaning outside of upb.
432
- typedef enum {
433
- kUpb_CType_Bool = 1,
434
- kUpb_CType_Float = 2,
435
- kUpb_CType_Int32 = 3,
436
- kUpb_CType_UInt32 = 4,
437
- kUpb_CType_Enum = 5, // Enum values are int32. TODO: rename
438
- kUpb_CType_Message = 6,
439
- kUpb_CType_Double = 7,
440
- kUpb_CType_Int64 = 8,
441
- kUpb_CType_UInt64 = 9,
442
- kUpb_CType_String = 10,
443
- kUpb_CType_Bytes = 11
444
- } upb_CType;
445
-
446
- // The repeated-ness of each field; this matches descriptor.proto.
447
- typedef enum {
448
- kUpb_Label_Optional = 1,
449
- kUpb_Label_Required = 2,
450
- kUpb_Label_Repeated = 3
451
- } upb_Label;
452
-
453
- // Descriptor types, as defined in descriptor.proto.
454
- typedef enum {
455
- kUpb_FieldType_Double = 1,
456
- kUpb_FieldType_Float = 2,
457
- kUpb_FieldType_Int64 = 3,
458
- kUpb_FieldType_UInt64 = 4,
459
- kUpb_FieldType_Int32 = 5,
460
- kUpb_FieldType_Fixed64 = 6,
461
- kUpb_FieldType_Fixed32 = 7,
462
- kUpb_FieldType_Bool = 8,
463
- kUpb_FieldType_String = 9,
464
- kUpb_FieldType_Group = 10,
465
- kUpb_FieldType_Message = 11,
466
- kUpb_FieldType_Bytes = 12,
467
- kUpb_FieldType_UInt32 = 13,
468
- kUpb_FieldType_Enum = 14,
469
- kUpb_FieldType_SFixed32 = 15,
470
- kUpb_FieldType_SFixed64 = 16,
471
- kUpb_FieldType_SInt32 = 17,
472
- kUpb_FieldType_SInt64 = 18,
473
- } upb_FieldType;
474
-
475
- #define kUpb_FieldType_SizeOf 19
476
-
477
- #ifdef __cplusplus
478
- extern "C" {
479
- #endif
480
-
481
- // Convert from upb_FieldType to upb_CType
482
- UPB_INLINE upb_CType upb_FieldType_CType(upb_FieldType field_type) {
483
- static const upb_CType c_type[] = {
484
- kUpb_CType_Double, // kUpb_FieldType_Double
485
- kUpb_CType_Float, // kUpb_FieldType_Float
486
- kUpb_CType_Int64, // kUpb_FieldType_Int64
487
- kUpb_CType_UInt64, // kUpb_FieldType_UInt64
488
- kUpb_CType_Int32, // kUpb_FieldType_Int32
489
- kUpb_CType_UInt64, // kUpb_FieldType_Fixed64
490
- kUpb_CType_UInt32, // kUpb_FieldType_Fixed32
491
- kUpb_CType_Bool, // kUpb_FieldType_Bool
492
- kUpb_CType_String, // kUpb_FieldType_String
493
- kUpb_CType_Message, // kUpb_FieldType_Group
494
- kUpb_CType_Message, // kUpb_FieldType_Message
495
- kUpb_CType_Bytes, // kUpb_FieldType_Bytes
496
- kUpb_CType_UInt32, // kUpb_FieldType_UInt32
497
- kUpb_CType_Enum, // kUpb_FieldType_Enum
498
- kUpb_CType_Int32, // kUpb_FieldType_SFixed32
499
- kUpb_CType_Int64, // kUpb_FieldType_SFixed64
500
- kUpb_CType_Int32, // kUpb_FieldType_SInt32
501
- kUpb_CType_Int64, // kUpb_FieldType_SInt64
502
- };
503
-
504
- // -1 here because the enum is one-based but the table is zero-based.
505
- return c_type[field_type - 1];
506
- }
507
-
508
- UPB_INLINE bool upb_FieldType_IsPackable(upb_FieldType field_type) {
509
- // clang-format off
510
- const unsigned kUnpackableTypes =
511
- (1 << kUpb_FieldType_String) |
512
- (1 << kUpb_FieldType_Bytes) |
513
- (1 << kUpb_FieldType_Message) |
514
- (1 << kUpb_FieldType_Group);
515
- // clang-format on
516
- return (1 << field_type) & ~kUnpackableTypes;
517
- }
518
-
519
- #ifdef __cplusplus
520
- } /* extern "C" */
521
- #endif
522
-
523
-
524
- #endif /* UPB_BASE_DESCRIPTOR_CONSTANTS_H_ */
525
489
  #ifndef UPB_BASE_STRING_VIEW_H_
526
490
  #define UPB_BASE_STRING_VIEW_H_
527
491
 
@@ -801,6 +765,15 @@ UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size);
801
765
  UPB_API_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize,
802
766
  size_t size);
803
767
 
768
+ // Sets the maximum block size for all arenas. This is a global configuration
769
+ // setting that will affect all existing and future arenas. If
770
+ // upb_Arena_Malloc() is called with a size larger than this, we will exceed
771
+ // this size and allocate a larger block.
772
+ //
773
+ // This API is meant for experimentation only. It will likely be removed in
774
+ // the future.
775
+ void upb_Arena_SetMaxBlockSize(size_t max);
776
+
804
777
  // Shrinks the last alloc from arena.
805
778
  // REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
806
779
  // We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
@@ -829,6 +802,109 @@ void upb_Arena_SetTraceHandler(void (*initArenaTraceHandler)(const upb_Arena*,
829
802
  #include <stddef.h>
830
803
 
831
804
 
805
+ #ifndef UPB_BASE_DESCRIPTOR_CONSTANTS_H_
806
+ #define UPB_BASE_DESCRIPTOR_CONSTANTS_H_
807
+
808
+ // Must be last.
809
+
810
+ // The types a field can have. Note that this list is not identical to the
811
+ // types defined in descriptor.proto, which gives INT32 and SINT32 separate
812
+ // types (we distinguish the two with the "integer encoding" enum below).
813
+ // This enum is an internal convenience only and has no meaning outside of upb.
814
+ typedef enum {
815
+ kUpb_CType_Bool = 1,
816
+ kUpb_CType_Float = 2,
817
+ kUpb_CType_Int32 = 3,
818
+ kUpb_CType_UInt32 = 4,
819
+ kUpb_CType_Enum = 5, // Enum values are int32. TODO: rename
820
+ kUpb_CType_Message = 6,
821
+ kUpb_CType_Double = 7,
822
+ kUpb_CType_Int64 = 8,
823
+ kUpb_CType_UInt64 = 9,
824
+ kUpb_CType_String = 10,
825
+ kUpb_CType_Bytes = 11
826
+ } upb_CType;
827
+
828
+ // The repeated-ness of each field; this matches descriptor.proto.
829
+ typedef enum {
830
+ kUpb_Label_Optional = 1,
831
+ kUpb_Label_Required = 2,
832
+ kUpb_Label_Repeated = 3
833
+ } upb_Label;
834
+
835
+ // Descriptor types, as defined in descriptor.proto.
836
+ typedef enum {
837
+ kUpb_FieldType_Double = 1,
838
+ kUpb_FieldType_Float = 2,
839
+ kUpb_FieldType_Int64 = 3,
840
+ kUpb_FieldType_UInt64 = 4,
841
+ kUpb_FieldType_Int32 = 5,
842
+ kUpb_FieldType_Fixed64 = 6,
843
+ kUpb_FieldType_Fixed32 = 7,
844
+ kUpb_FieldType_Bool = 8,
845
+ kUpb_FieldType_String = 9,
846
+ kUpb_FieldType_Group = 10,
847
+ kUpb_FieldType_Message = 11,
848
+ kUpb_FieldType_Bytes = 12,
849
+ kUpb_FieldType_UInt32 = 13,
850
+ kUpb_FieldType_Enum = 14,
851
+ kUpb_FieldType_SFixed32 = 15,
852
+ kUpb_FieldType_SFixed64 = 16,
853
+ kUpb_FieldType_SInt32 = 17,
854
+ kUpb_FieldType_SInt64 = 18,
855
+ } upb_FieldType;
856
+
857
+ #define kUpb_FieldType_SizeOf 19
858
+
859
+ #ifdef __cplusplus
860
+ extern "C" {
861
+ #endif
862
+
863
+ // Convert from upb_FieldType to upb_CType
864
+ UPB_INLINE upb_CType upb_FieldType_CType(upb_FieldType field_type) {
865
+ static const upb_CType c_type[] = {
866
+ kUpb_CType_Double, // kUpb_FieldType_Double
867
+ kUpb_CType_Float, // kUpb_FieldType_Float
868
+ kUpb_CType_Int64, // kUpb_FieldType_Int64
869
+ kUpb_CType_UInt64, // kUpb_FieldType_UInt64
870
+ kUpb_CType_Int32, // kUpb_FieldType_Int32
871
+ kUpb_CType_UInt64, // kUpb_FieldType_Fixed64
872
+ kUpb_CType_UInt32, // kUpb_FieldType_Fixed32
873
+ kUpb_CType_Bool, // kUpb_FieldType_Bool
874
+ kUpb_CType_String, // kUpb_FieldType_String
875
+ kUpb_CType_Message, // kUpb_FieldType_Group
876
+ kUpb_CType_Message, // kUpb_FieldType_Message
877
+ kUpb_CType_Bytes, // kUpb_FieldType_Bytes
878
+ kUpb_CType_UInt32, // kUpb_FieldType_UInt32
879
+ kUpb_CType_Enum, // kUpb_FieldType_Enum
880
+ kUpb_CType_Int32, // kUpb_FieldType_SFixed32
881
+ kUpb_CType_Int64, // kUpb_FieldType_SFixed64
882
+ kUpb_CType_Int32, // kUpb_FieldType_SInt32
883
+ kUpb_CType_Int64, // kUpb_FieldType_SInt64
884
+ };
885
+
886
+ // -1 here because the enum is one-based but the table is zero-based.
887
+ return c_type[field_type - 1];
888
+ }
889
+
890
+ UPB_INLINE bool upb_FieldType_IsPackable(upb_FieldType field_type) {
891
+ // clang-format off
892
+ const unsigned kUnpackableTypes =
893
+ (1 << kUpb_FieldType_String) |
894
+ (1 << kUpb_FieldType_Bytes) |
895
+ (1 << kUpb_FieldType_Message) |
896
+ (1 << kUpb_FieldType_Group);
897
+ // clang-format on
898
+ return (1 << field_type) & ~kUnpackableTypes;
899
+ }
900
+
901
+ #ifdef __cplusplus
902
+ } /* extern "C" */
903
+ #endif
904
+
905
+
906
+ #endif /* UPB_BASE_DESCRIPTOR_CONSTANTS_H_ */
907
+
832
908
  #ifndef UPB_MESSAGE_INTERNAL_ARRAY_H_
833
909
  #define UPB_MESSAGE_INTERNAL_ARRAY_H_
834
910
 
@@ -1411,6 +1487,7 @@ UPB_API_INLINE bool upb_MiniTableEnum_CheckValue(const upb_MiniTableEnum* e,
1411
1487
  #ifndef UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
1412
1488
  #define UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
1413
1489
 
1490
+ #include <stddef.h>
1414
1491
  #include <stdint.h>
1415
1492
 
1416
1493
 
@@ -1419,6 +1496,11 @@ UPB_API_INLINE bool upb_MiniTableEnum_CheckValue(const upb_MiniTableEnum* e,
1419
1496
 
1420
1497
  // Must be last.
1421
1498
 
1499
+ typedef union {
1500
+ const struct upb_MiniTable* const* UPB_PRIVATE(submsg);
1501
+ const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
1502
+ } upb_MiniTableSubInternal;
1503
+
1422
1504
  union upb_MiniTableSub {
1423
1505
  const struct upb_MiniTable* UPB_PRIVATE(submsg);
1424
1506
  const struct upb_MiniTableEnum* UPB_PRIVATE(subenum);
@@ -1489,7 +1571,7 @@ typedef enum {
1489
1571
 
1490
1572
  // LINT.IfChange(minitable_struct_definition)
1491
1573
  struct upb_MiniTable {
1492
- const union upb_MiniTableSub* UPB_PRIVATE(subs);
1574
+ const upb_MiniTableSubInternal* UPB_PRIVATE(subs);
1493
1575
  const struct upb_MiniTableField* UPB_ONLYBITS(fields);
1494
1576
 
1495
1577
  // Must be aligned to sizeof(void*). Doesn't include internal members like
@@ -1520,6 +1602,17 @@ struct upb_MiniTable {
1520
1602
  extern "C" {
1521
1603
  #endif
1522
1604
 
1605
+ UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(
1606
+ _upb_MiniTable_StrongReference)(const struct upb_MiniTable* mt) {
1607
+ #if defined(__GNUC__)
1608
+ __asm__("" : : "r"(mt));
1609
+ #else
1610
+ const struct upb_MiniTable* volatile unused = mt;
1611
+ (void)&unused; // Use address to avoid an extra load of "unused".
1612
+ #endif
1613
+ return mt;
1614
+ }
1615
+
1523
1616
  UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(_upb_MiniTable_Empty)(void) {
1524
1617
  extern const struct upb_MiniTable UPB_PRIVATE(_kUpb_MiniTable_Empty);
1525
1618
 
@@ -1542,34 +1635,46 @@ UPB_API_INLINE const struct upb_MiniTableField* upb_MiniTable_GetFieldByIndex(
1542
1635
  return &m->UPB_ONLYBITS(fields)[i];
1543
1636
  }
1544
1637
 
1545
- UPB_INLINE const union upb_MiniTableSub* UPB_PRIVATE(
1546
- _upb_MiniTable_GetSubByIndex)(const struct upb_MiniTable* m, uint32_t i) {
1547
- return &m->UPB_PRIVATE(subs)[i];
1638
+ UPB_INLINE const struct upb_MiniTable* UPB_PRIVATE(
1639
+ _upb_MiniTable_GetSubTableByIndex)(const struct upb_MiniTable* m,
1640
+ uint32_t i) {
1641
+ return *m->UPB_PRIVATE(subs)[i].UPB_PRIVATE(submsg);
1642
+ }
1643
+
1644
+ UPB_API_INLINE const struct upb_MiniTable* upb_MiniTable_SubMessage(
1645
+ const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
1646
+ if (upb_MiniTableField_CType(f) != kUpb_CType_Message) {
1647
+ return NULL;
1648
+ }
1649
+ return UPB_PRIVATE(_upb_MiniTable_GetSubTableByIndex)(
1650
+ m, f->UPB_PRIVATE(submsg_index));
1548
1651
  }
1549
1652
 
1550
1653
  UPB_API_INLINE const struct upb_MiniTable* upb_MiniTable_GetSubMessageTable(
1551
1654
  const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
1552
- UPB_ASSERT(upb_MiniTableField_CType(f) == kUpb_CType_Message);
1553
- const struct upb_MiniTable* ret = upb_MiniTableSub_Message(
1554
- m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
1655
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Message);
1656
+ const struct upb_MiniTable* ret = upb_MiniTable_SubMessage(m, f);
1555
1657
  UPB_ASSUME(ret);
1556
1658
  return UPB_PRIVATE(_upb_MiniTable_IsEmpty)(ret) ? NULL : ret;
1557
1659
  }
1558
1660
 
1559
- UPB_API_INLINE const struct upb_MiniTable* upb_MiniTable_SubMessage(
1661
+ UPB_API_INLINE bool upb_MiniTable_FieldIsLinked(
1560
1662
  const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
1561
- if (upb_MiniTableField_CType(f) != kUpb_CType_Message) {
1562
- return NULL;
1563
- }
1564
- return upb_MiniTableSub_Message(
1565
- m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
1663
+ return upb_MiniTable_GetSubMessageTable(m, f) != NULL;
1664
+ }
1665
+
1666
+ UPB_API_INLINE const struct upb_MiniTable* upb_MiniTable_MapEntrySubMessage(
1667
+ const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
1668
+ UPB_ASSERT(upb_MiniTable_FieldIsLinked(m, f)); // Map entries must be linked.
1669
+ UPB_ASSERT(upb_MiniTableField_IsMap(f)); // Function precondition.
1670
+ return upb_MiniTable_SubMessage(m, f);
1566
1671
  }
1567
1672
 
1568
1673
  UPB_API_INLINE const struct upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable(
1569
1674
  const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
1570
1675
  UPB_ASSERT(upb_MiniTableField_CType(f) == kUpb_CType_Enum);
1571
- return upb_MiniTableSub_Enum(
1572
- m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)]);
1676
+ return m->UPB_PRIVATE(subs)[f->UPB_PRIVATE(submsg_index)].UPB_PRIVATE(
1677
+ subenum);
1573
1678
  }
1574
1679
 
1575
1680
  UPB_API_INLINE const struct upb_MiniTableField* upb_MiniTable_MapKey(
@@ -1588,11 +1693,6 @@ UPB_API_INLINE const struct upb_MiniTableField* upb_MiniTable_MapValue(
1588
1693
  return f;
1589
1694
  }
1590
1695
 
1591
- UPB_API_INLINE bool upb_MiniTable_FieldIsLinked(
1592
- const struct upb_MiniTable* m, const struct upb_MiniTableField* f) {
1593
- return upb_MiniTable_GetSubMessageTable(m, f) != NULL;
1594
- }
1595
-
1596
1696
  // Computes a bitmask in which the |m->required_count| lowest bits are set.
1597
1697
  //
1598
1698
  // Sample output:
@@ -1647,10 +1747,20 @@ UPB_API_INLINE int upb_MiniTable_FieldCount(const upb_MiniTable* m);
1647
1747
  UPB_API_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
1648
1748
  const upb_MiniTable* m, const upb_MiniTableField* f);
1649
1749
 
1650
- // Returns the MiniTable for a message field if it is a submessage.
1750
+ // Returns the MiniTable for a message field if it is a submessage, otherwise
1751
+ // returns NULL.
1752
+ //
1753
+ // WARNING: if dynamic tree shaking is in use, the return value may be the
1754
+ // "empty", zero-field placeholder message instead of the real message type.
1755
+ // If the message is later linked, this function will begin returning the real
1756
+ // message type.
1651
1757
  UPB_API_INLINE const upb_MiniTable* upb_MiniTable_SubMessage(
1652
1758
  const upb_MiniTable* m, const upb_MiniTableField* f);
1653
1759
 
1760
+ // Returns the MiniTable for a map field. The given field must refer to a map.
1761
+ UPB_API_INLINE const upb_MiniTable* upb_MiniTable_MapEntrySubMessage(
1762
+ const upb_MiniTable* m, const upb_MiniTableField* f);
1763
+
1654
1764
  // Returns the MiniTableEnum for a message field, NULL if the field is unlinked.
1655
1765
  UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTable_GetSubEnumTable(
1656
1766
  const upb_MiniTable* m, const upb_MiniTableField* f);
@@ -1831,6 +1941,7 @@ UPB_INLINE uint64_t upb_BigEndian64(uint64_t val) {
1831
1941
  #ifndef UPB_MINI_TABLE_INTERNAL_EXTENSION_H_
1832
1942
  #define UPB_MINI_TABLE_INTERNAL_EXTENSION_H_
1833
1943
 
1944
+ #include <stddef.h>
1834
1945
  #include <stdint.h>
1835
1946
 
1836
1947
 
@@ -1860,6 +1971,9 @@ upb_MiniTableExtension_Number(const struct upb_MiniTableExtension* e) {
1860
1971
 
1861
1972
  UPB_API_INLINE const struct upb_MiniTable* upb_MiniTableExtension_GetSubMessage(
1862
1973
  const struct upb_MiniTableExtension* e) {
1974
+ if (upb_MiniTableExtension_CType(e) != kUpb_CType_Message) {
1975
+ return NULL;
1976
+ }
1863
1977
  return upb_MiniTableSub_Message(e->UPB_PRIVATE(sub));
1864
1978
  }
1865
1979
 
@@ -1868,6 +1982,11 @@ UPB_API_INLINE void upb_MiniTableExtension_SetSubMessage(
1868
1982
  e->UPB_PRIVATE(sub).UPB_PRIVATE(submsg) = m;
1869
1983
  }
1870
1984
 
1985
+ UPB_INLINE upb_FieldRep UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(
1986
+ const struct upb_MiniTableExtension* e) {
1987
+ return UPB_PRIVATE(_upb_MiniTableField_GetRep)(&e->UPB_PRIVATE(field));
1988
+ }
1989
+
1871
1990
  #ifdef __cplusplus
1872
1991
  } /* extern "C" */
1873
1992
  #endif
@@ -2456,18 +2575,19 @@ typedef struct upb_Message_Internal {
2456
2575
  } upb_Message_Internal;
2457
2576
 
2458
2577
  #ifdef UPB_TRACING_ENABLED
2459
- void UPB_PRIVATE(upb_Message_SetNewMessageTraceHandler)(
2460
- void (*newMessageTraceHandler)(const upb_MiniTable*, const upb_Arena*));
2461
- void UPB_PRIVATE(upb_Message_LogNewMessage)(const upb_MiniTable* mini_table,
2462
- const upb_Arena* arena);
2463
- #endif
2578
+ UPB_API void upb_Message_LogNewMessage(const upb_MiniTable* m,
2579
+ const upb_Arena* arena);
2580
+ UPB_API void upb_Message_SetNewMessageTraceHandler(
2581
+ void (*handler)(const upb_MiniTable*, const upb_Arena*));
2582
+ #endif // UPB_TRACING_ENABLED
2464
2583
 
2465
2584
  // Inline version upb_Message_New(), for internal use.
2466
2585
  UPB_INLINE struct upb_Message* _upb_Message_New(const upb_MiniTable* m,
2467
2586
  upb_Arena* a) {
2468
2587
  #ifdef UPB_TRACING_ENABLED
2469
- UPB_PRIVATE(upb_Message_LogNewMessage)(m, a);
2470
- #endif
2588
+ upb_Message_LogNewMessage(m, a);
2589
+ #endif // UPB_TRACING_ENABLED
2590
+
2471
2591
  const int size = m->UPB_PRIVATE(size);
2472
2592
  struct upb_Message* msg = (struct upb_Message*)upb_Arena_Malloc(a, size);
2473
2593
  if (UPB_UNLIKELY(!msg)) return NULL;
@@ -2677,6 +2797,23 @@ UPB_INLINE bool UPB_PRIVATE(_upb_Message_ClearOneofCase)(
2677
2797
  return true;
2678
2798
  }
2679
2799
 
2800
+ UPB_API_INLINE uint32_t upb_Message_WhichOneofFieldNumber(
2801
+ const struct upb_Message* message, const upb_MiniTableField* oneof_field) {
2802
+ UPB_ASSUME(upb_MiniTableField_IsInOneof(oneof_field));
2803
+ return UPB_PRIVATE(_upb_Message_GetOneofCase)(message, oneof_field);
2804
+ }
2805
+
2806
+ UPB_API_INLINE const upb_MiniTableField* upb_Message_WhichOneof(
2807
+ const struct upb_Message* msg, const upb_MiniTable* m,
2808
+ const upb_MiniTableField* f) {
2809
+ uint32_t field_number = upb_Message_WhichOneofFieldNumber(msg, f);
2810
+ if (field_number == 0) {
2811
+ // No field in the oneof is set.
2812
+ return NULL;
2813
+ }
2814
+ return upb_MiniTable_FindFieldByNumber(m, field_number);
2815
+ }
2816
+
2680
2817
  // LINT.ThenChange(GoogleInternalName2)
2681
2818
 
2682
2819
  // Returns false if the message is missing any of its required fields.
@@ -2748,7 +2885,7 @@ UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataEquals)(
2748
2885
  UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_DataClear)(
2749
2886
  const upb_MiniTableField* f, void* val) {
2750
2887
  const char zero[16] = {0};
2751
- return UPB_PRIVATE(_upb_MiniTableField_DataCopy)(f, val, zero);
2888
+ UPB_PRIVATE(_upb_MiniTableField_DataCopy)(f, val, zero);
2752
2889
  }
2753
2890
 
2754
2891
  UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(
@@ -2775,7 +2912,6 @@ UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableField_DataIsZero)(
2775
2912
  // const upb_MiniTableField* field,
2776
2913
  // bool value, upb_Arena* a) {
2777
2914
  // UPB_ASSUME(field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bool);
2778
- // UPB_ASSUME(upb_MiniTableField_IsScalar(field));
2779
2915
  // UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
2780
2916
  // kUpb_FieldRep_1Byte);
2781
2917
  // upb_Message_SetField(msg, field, &value, a);
@@ -2836,6 +2972,24 @@ UPB_INLINE void _upb_Message_GetExtensionField(
2836
2972
  }
2837
2973
  }
2838
2974
 
2975
+ // NOTE: The default_val is only used for fields that support presence.
2976
+ // For repeated/map fields, the resulting upb_Array*/upb_Map* can be NULL if a
2977
+ // upb_Array/upb_Map has not been allocated yet. Array/map fields do not have
2978
+ // presence, so this is semantically identical to a pointer to an empty
2979
+ // array/map, and must be treated the same for all semantic purposes.
2980
+ UPB_API_INLINE upb_MessageValue upb_Message_GetField(
2981
+ const struct upb_Message* msg, const upb_MiniTableField* field,
2982
+ upb_MessageValue default_val) {
2983
+ upb_MessageValue ret;
2984
+ if (upb_MiniTableField_IsExtension(field)) {
2985
+ _upb_Message_GetExtensionField(msg, (upb_MiniTableExtension*)field,
2986
+ &default_val, &ret);
2987
+ } else {
2988
+ _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
2989
+ }
2990
+ return ret;
2991
+ }
2992
+
2839
2993
  UPB_API_INLINE void upb_Message_SetBaseField(struct upb_Message* msg,
2840
2994
  const upb_MiniTableField* f,
2841
2995
  const void* val) {
@@ -2859,6 +3013,516 @@ UPB_API_INLINE bool upb_Message_SetExtension(struct upb_Message* msg,
2859
3013
  return true;
2860
3014
  }
2861
3015
 
3016
+ // Sets the value of the given field in the given msg. The return value is true
3017
+ // if the operation completed successfully, or false if memory allocation
3018
+ // failed.
3019
+ UPB_INLINE bool UPB_PRIVATE(_upb_Message_SetField)(struct upb_Message* msg,
3020
+ const upb_MiniTableField* f,
3021
+ upb_MessageValue val,
3022
+ upb_Arena* a) {
3023
+ if (upb_MiniTableField_IsExtension(f)) {
3024
+ const upb_MiniTableExtension* ext = (const upb_MiniTableExtension*)f;
3025
+ return upb_Message_SetExtension(msg, ext, &val, a);
3026
+ } else {
3027
+ upb_Message_SetBaseField(msg, f, &val);
3028
+ return true;
3029
+ }
3030
+ }
3031
+
3032
+ UPB_API_INLINE const upb_Array* upb_Message_GetArray(
3033
+ const struct upb_Message* msg, const upb_MiniTableField* f) {
3034
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(f);
3035
+ upb_Array* ret;
3036
+ const upb_Array* default_val = NULL;
3037
+ _upb_Message_GetNonExtensionField(msg, f, &default_val, &ret);
3038
+ return ret;
3039
+ }
3040
+
3041
+ UPB_API_INLINE bool upb_Message_GetBool(const struct upb_Message* msg,
3042
+ const upb_MiniTableField* f,
3043
+ bool default_val) {
3044
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Bool);
3045
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3046
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_1Byte);
3047
+ upb_MessageValue def;
3048
+ def.bool_val = default_val;
3049
+ return upb_Message_GetField(msg, f, def).bool_val;
3050
+ }
3051
+
3052
+ UPB_API_INLINE double upb_Message_GetDouble(const struct upb_Message* msg,
3053
+ const upb_MiniTableField* f,
3054
+ double default_val) {
3055
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Double);
3056
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3057
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_8Byte);
3058
+
3059
+ upb_MessageValue def;
3060
+ def.double_val = default_val;
3061
+ return upb_Message_GetField(msg, f, def).double_val;
3062
+ }
3063
+
3064
+ UPB_API_INLINE float upb_Message_GetFloat(const struct upb_Message* msg,
3065
+ const upb_MiniTableField* f,
3066
+ float default_val) {
3067
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Float);
3068
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3069
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3070
+
3071
+ upb_MessageValue def;
3072
+ def.float_val = default_val;
3073
+ return upb_Message_GetField(msg, f, def).float_val;
3074
+ }
3075
+
3076
+ UPB_API_INLINE int32_t upb_Message_GetInt32(const struct upb_Message* msg,
3077
+ const upb_MiniTableField* f,
3078
+ int32_t default_val) {
3079
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Int32 ||
3080
+ upb_MiniTableField_CType(f) == kUpb_CType_Enum);
3081
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3082
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3083
+
3084
+ upb_MessageValue def;
3085
+ def.int32_val = default_val;
3086
+ return upb_Message_GetField(msg, f, def).int32_val;
3087
+ }
3088
+
3089
+ UPB_API_INLINE int64_t upb_Message_GetInt64(const struct upb_Message* msg,
3090
+ const upb_MiniTableField* f,
3091
+ int64_t default_val) {
3092
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Int64);
3093
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3094
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_8Byte);
3095
+
3096
+ upb_MessageValue def;
3097
+ def.int64_val = default_val;
3098
+ return upb_Message_GetField(msg, f, def).int64_val;
3099
+ }
3100
+
3101
+ UPB_INLINE void UPB_PRIVATE(_upb_Message_AssertMapIsUntagged)(
3102
+ const struct upb_Message* msg, const upb_MiniTableField* field) {
3103
+ UPB_UNUSED(msg);
3104
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
3105
+ #ifndef NDEBUG
3106
+ uintptr_t default_val = 0;
3107
+ uintptr_t tagged;
3108
+ _upb_Message_GetNonExtensionField(msg, field, &default_val, &tagged);
3109
+ UPB_ASSERT(!upb_TaggedMessagePtr_IsEmpty(tagged));
3110
+ #endif
3111
+ }
3112
+
3113
+ UPB_API_INLINE const struct upb_Map* upb_Message_GetMap(
3114
+ const struct upb_Message* msg, const upb_MiniTableField* f) {
3115
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(f);
3116
+ UPB_PRIVATE(_upb_Message_AssertMapIsUntagged)(msg, f);
3117
+ struct upb_Map* ret;
3118
+ const struct upb_Map* default_val = NULL;
3119
+ _upb_Message_GetNonExtensionField(msg, f, &default_val, &ret);
3120
+ return ret;
3121
+ }
3122
+
3123
+ UPB_API_INLINE uintptr_t upb_Message_GetTaggedMessagePtr(
3124
+ const struct upb_Message* msg, const upb_MiniTableField* f,
3125
+ struct upb_Message* default_val) {
3126
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Message);
3127
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
3128
+ UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
3129
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3130
+ uintptr_t tagged;
3131
+ _upb_Message_GetNonExtensionField(msg, f, &default_val, &tagged);
3132
+ return tagged;
3133
+ }
3134
+
3135
+ // For internal use only; users cannot set tagged messages because only the
3136
+ // parser and the message copier are allowed to directly create an empty
3137
+ // message.
3138
+ UPB_INLINE void UPB_PRIVATE(_upb_Message_SetTaggedMessagePtr)(
3139
+ struct upb_Message* msg, const upb_MiniTableField* f,
3140
+ uintptr_t sub_message) {
3141
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Message);
3142
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
3143
+ UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
3144
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3145
+ upb_Message_SetBaseField(msg, f, &sub_message);
3146
+ }
3147
+
3148
+ UPB_API_INLINE const struct upb_Message* upb_Message_GetMessage(
3149
+ const struct upb_Message* msg, const upb_MiniTableField* f) {
3150
+ uintptr_t tagged = upb_Message_GetTaggedMessagePtr(msg, f, NULL);
3151
+ return upb_TaggedMessagePtr_GetNonEmptyMessage(tagged);
3152
+ }
3153
+
3154
+ UPB_API_INLINE upb_Array* upb_Message_GetMutableArray(
3155
+ struct upb_Message* msg, const upb_MiniTableField* f) {
3156
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(f);
3157
+ return (upb_Array*)upb_Message_GetArray(msg, f);
3158
+ }
3159
+
3160
+ UPB_API_INLINE struct upb_Map* upb_Message_GetMutableMap(
3161
+ struct upb_Message* msg, const upb_MiniTableField* f) {
3162
+ return (struct upb_Map*)upb_Message_GetMap(msg, f);
3163
+ }
3164
+
3165
+ UPB_API_INLINE struct upb_Message* upb_Message_GetMutableMessage(
3166
+ struct upb_Message* msg, const upb_MiniTableField* f) {
3167
+ return (struct upb_Message*)upb_Message_GetMessage(msg, f);
3168
+ }
3169
+
3170
+ UPB_API_INLINE upb_Array* upb_Message_GetOrCreateMutableArray(
3171
+ struct upb_Message* msg, const upb_MiniTableField* f, upb_Arena* arena) {
3172
+ UPB_ASSERT(arena);
3173
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(f);
3174
+ upb_Array* array = upb_Message_GetMutableArray(msg, f);
3175
+ if (!array) {
3176
+ array = UPB_PRIVATE(_upb_Array_New)(
3177
+ arena, 4, UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)(f));
3178
+ // Check again due to: https://godbolt.org/z/7WfaoKG1r
3179
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(f);
3180
+ upb_MessageValue val;
3181
+ val.array_val = array;
3182
+ UPB_PRIVATE(_upb_Message_SetField)(msg, f, val, arena);
3183
+ }
3184
+ return array;
3185
+ }
3186
+
3187
+ UPB_INLINE struct upb_Map* _upb_Message_GetOrCreateMutableMap(
3188
+ struct upb_Message* msg, const upb_MiniTableField* field, size_t key_size,
3189
+ size_t val_size, upb_Arena* arena) {
3190
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
3191
+ UPB_PRIVATE(_upb_Message_AssertMapIsUntagged)(msg, field);
3192
+ struct upb_Map* map = NULL;
3193
+ struct upb_Map* default_map_value = NULL;
3194
+ _upb_Message_GetNonExtensionField(msg, field, &default_map_value, &map);
3195
+ if (!map) {
3196
+ map = _upb_Map_New(arena, key_size, val_size);
3197
+ // Check again due to: https://godbolt.org/z/7WfaoKG1r
3198
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
3199
+ upb_Message_SetBaseField(msg, field, &map);
3200
+ }
3201
+ return map;
3202
+ }
3203
+
3204
+ UPB_API_INLINE struct upb_Map* upb_Message_GetOrCreateMutableMap(
3205
+ struct upb_Message* msg, const upb_MiniTable* map_entry_mini_table,
3206
+ const upb_MiniTableField* f, upb_Arena* arena) {
3207
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Message);
3208
+ const upb_MiniTableField* map_entry_key_field =
3209
+ &map_entry_mini_table->UPB_ONLYBITS(fields)[0];
3210
+ const upb_MiniTableField* map_entry_value_field =
3211
+ &map_entry_mini_table->UPB_ONLYBITS(fields)[1];
3212
+ return _upb_Message_GetOrCreateMutableMap(
3213
+ msg, f, _upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_key_field)),
3214
+ _upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_value_field)),
3215
+ arena);
3216
+ }
3217
+
3218
+ UPB_API_INLINE struct upb_Message* upb_Message_GetOrCreateMutableMessage(
3219
+ struct upb_Message* msg, const upb_MiniTable* mini_table,
3220
+ const upb_MiniTableField* f, upb_Arena* arena) {
3221
+ UPB_ASSERT(arena);
3222
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Message);
3223
+ UPB_ASSUME(!upb_MiniTableField_IsExtension(f));
3224
+ struct upb_Message* sub_message =
3225
+ *UPB_PTR_AT(msg, f->UPB_ONLYBITS(offset), struct upb_Message*);
3226
+ if (!sub_message) {
3227
+ const upb_MiniTable* sub_mini_table =
3228
+ upb_MiniTable_SubMessage(mini_table, f);
3229
+ UPB_ASSERT(sub_mini_table);
3230
+ sub_message = _upb_Message_New(sub_mini_table, arena);
3231
+ *UPB_PTR_AT(msg, f->UPB_ONLYBITS(offset), struct upb_Message*) =
3232
+ sub_message;
3233
+ UPB_PRIVATE(_upb_Message_SetPresence)(msg, f);
3234
+ }
3235
+ return sub_message;
3236
+ }
3237
+
3238
+ UPB_API_INLINE upb_StringView
3239
+ upb_Message_GetString(const struct upb_Message* msg,
3240
+ const upb_MiniTableField* f, upb_StringView default_val) {
3241
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_String ||
3242
+ upb_MiniTableField_CType(f) == kUpb_CType_Bytes);
3243
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
3244
+ kUpb_FieldRep_StringView);
3245
+
3246
+ upb_MessageValue def;
3247
+ def.str_val = default_val;
3248
+ return upb_Message_GetField(msg, f, def).str_val;
3249
+ }
3250
+
3251
+ UPB_API_INLINE uint32_t upb_Message_GetUInt32(const struct upb_Message* msg,
3252
+ const upb_MiniTableField* f,
3253
+ uint32_t default_val) {
3254
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_UInt32);
3255
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3256
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3257
+
3258
+ upb_MessageValue def;
3259
+ def.uint32_val = default_val;
3260
+ return upb_Message_GetField(msg, f, def).uint32_val;
3261
+ }
3262
+
3263
+ UPB_API_INLINE uint64_t upb_Message_GetUInt64(const struct upb_Message* msg,
3264
+ const upb_MiniTableField* f,
3265
+ uint64_t default_val) {
3266
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_UInt64);
3267
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3268
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_8Byte);
3269
+
3270
+ upb_MessageValue def;
3271
+ def.uint64_val = default_val;
3272
+ return upb_Message_GetField(msg, f, def).uint64_val;
3273
+ }
3274
+
3275
+ // BaseField Setters ///////////////////////////////////////////////////////////
3276
+
3277
+ UPB_API_INLINE void upb_Message_SetBaseFieldBool(struct upb_Message* msg,
3278
+ const upb_MiniTableField* f,
3279
+ bool value) {
3280
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Bool);
3281
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3282
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_1Byte);
3283
+ upb_Message_SetBaseField(msg, f, &value);
3284
+ }
3285
+
3286
+ UPB_API_INLINE void upb_Message_SetBaseFieldDouble(struct upb_Message* msg,
3287
+ const upb_MiniTableField* f,
3288
+ double value) {
3289
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Double);
3290
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3291
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_8Byte);
3292
+ upb_Message_SetBaseField(msg, f, &value);
3293
+ }
3294
+
3295
+ UPB_API_INLINE void upb_Message_SetBaseFieldFloat(struct upb_Message* msg,
3296
+ const upb_MiniTableField* f,
3297
+ float value) {
3298
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Float);
3299
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3300
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3301
+ upb_Message_SetBaseField(msg, f, &value);
3302
+ }
3303
+
3304
+ UPB_API_INLINE void upb_Message_SetBaseFieldInt32(struct upb_Message* msg,
3305
+ const upb_MiniTableField* f,
3306
+ int32_t value) {
3307
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Int32 ||
3308
+ upb_MiniTableField_CType(f) == kUpb_CType_Enum);
3309
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3310
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3311
+ upb_Message_SetBaseField(msg, f, &value);
3312
+ }
3313
+
3314
+ UPB_API_INLINE void upb_Message_SetBaseFieldInt64(struct upb_Message* msg,
3315
+ const upb_MiniTableField* f,
3316
+ int64_t value) {
3317
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_Int64);
3318
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3319
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_8Byte);
3320
+ upb_Message_SetBaseField(msg, f, &value);
3321
+ }
3322
+
3323
+ UPB_API_INLINE void upb_Message_SetBaseFieldString(struct upb_Message* msg,
3324
+ const upb_MiniTableField* f,
3325
+ upb_StringView value) {
3326
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_String ||
3327
+ upb_MiniTableField_CType(f) == kUpb_CType_Bytes);
3328
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3329
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
3330
+ kUpb_FieldRep_StringView);
3331
+ upb_Message_SetBaseField(msg, f, &value);
3332
+ }
3333
+
3334
+ UPB_API_INLINE void upb_Message_SetBaseFieldUInt32(struct upb_Message* msg,
3335
+ const upb_MiniTableField* f,
3336
+ uint32_t value) {
3337
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_UInt32);
3338
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3339
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3340
+ upb_Message_SetBaseField(msg, f, &value);
3341
+ }
3342
+
3343
+ UPB_API_INLINE void upb_Message_SetBaseFieldUInt64(struct upb_Message* msg,
3344
+ const upb_MiniTableField* f,
3345
+ uint64_t value) {
3346
+ UPB_ASSUME(upb_MiniTableField_CType(f) == kUpb_CType_UInt64);
3347
+ UPB_ASSUME(upb_MiniTableField_IsScalar(f));
3348
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_8Byte);
3349
+ upb_Message_SetBaseField(msg, f, &value);
3350
+ }
3351
+
3352
+ UPB_API_INLINE void upb_Message_SetClosedEnum(struct upb_Message* msg,
3353
+ const upb_MiniTable* m,
3354
+ const upb_MiniTableField* f,
3355
+ int32_t value) {
3356
+ UPB_ASSERT(upb_MiniTableField_IsClosedEnum(f));
3357
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) == kUpb_FieldRep_4Byte);
3358
+ UPB_ASSERT(
3359
+ upb_MiniTableEnum_CheckValue(upb_MiniTable_GetSubEnumTable(m, f), value));
3360
+ upb_Message_SetBaseField(msg, f, &value);
3361
+ }
3362
+
3363
+ // Extension Setters ///////////////////////////////////////////////////////////
3364
+
3365
+ UPB_API_INLINE bool upb_Message_SetExtensionBool(
3366
+ struct upb_Message* msg, const upb_MiniTableExtension* e, bool value,
3367
+ upb_Arena* a) {
3368
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_Bool);
3369
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3370
+ kUpb_FieldRep_1Byte);
3371
+ return upb_Message_SetExtension(msg, e, &value, a);
3372
+ }
3373
+
3374
+ UPB_API_INLINE bool upb_Message_SetExtensionDouble(
3375
+ struct upb_Message* msg, const upb_MiniTableExtension* e, double value,
3376
+ upb_Arena* a) {
3377
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_Double);
3378
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3379
+ kUpb_FieldRep_8Byte);
3380
+ return upb_Message_SetExtension(msg, e, &value, a);
3381
+ }
3382
+
3383
+ UPB_API_INLINE bool upb_Message_SetExtensionFloat(
3384
+ struct upb_Message* msg, const upb_MiniTableExtension* e, float value,
3385
+ upb_Arena* a) {
3386
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_Float);
3387
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3388
+ kUpb_FieldRep_4Byte);
3389
+ return upb_Message_SetExtension(msg, e, &value, a);
3390
+ }
3391
+
3392
+ UPB_API_INLINE bool upb_Message_SetExtensionInt32(
3393
+ struct upb_Message* msg, const upb_MiniTableExtension* e, int32_t value,
3394
+ upb_Arena* a) {
3395
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_Int32 ||
3396
+ upb_MiniTableExtension_CType(e) == kUpb_CType_Enum);
3397
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3398
+ kUpb_FieldRep_4Byte);
3399
+ return upb_Message_SetExtension(msg, e, &value, a);
3400
+ }
3401
+
3402
+ UPB_API_INLINE bool upb_Message_SetExtensionInt64(
3403
+ struct upb_Message* msg, const upb_MiniTableExtension* e, int64_t value,
3404
+ upb_Arena* a) {
3405
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_Int64);
3406
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3407
+ kUpb_FieldRep_8Byte);
3408
+ return upb_Message_SetExtension(msg, e, &value, a);
3409
+ }
3410
+
3411
+ UPB_API_INLINE bool upb_Message_SetExtensionString(
3412
+ struct upb_Message* msg, const upb_MiniTableExtension* e,
3413
+ upb_StringView value, upb_Arena* a) {
3414
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_String ||
3415
+ upb_MiniTableExtension_CType(e) == kUpb_CType_Bytes);
3416
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3417
+ kUpb_FieldRep_StringView);
3418
+ return upb_Message_SetExtension(msg, e, &value, a);
3419
+ }
3420
+
3421
+ UPB_API_INLINE bool upb_Message_SetExtensionUInt32(
3422
+ struct upb_Message* msg, const upb_MiniTableExtension* e, uint32_t value,
3423
+ upb_Arena* a) {
3424
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_UInt32);
3425
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3426
+ kUpb_FieldRep_4Byte);
3427
+ return upb_Message_SetExtension(msg, e, &value, a);
3428
+ }
3429
+
3430
+ UPB_API_INLINE bool upb_Message_SetExtensionUInt64(
3431
+ struct upb_Message* msg, const upb_MiniTableExtension* e, uint64_t value,
3432
+ upb_Arena* a) {
3433
+ UPB_ASSUME(upb_MiniTableExtension_CType(e) == kUpb_CType_UInt64);
3434
+ UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableExtension_GetRep)(e) ==
3435
+ kUpb_FieldRep_8Byte);
3436
+ return upb_Message_SetExtension(msg, e, &value, a);
3437
+ }
3438
+
3439
+ // Universal Setters ///////////////////////////////////////////////////////////
3440
+
3441
+ UPB_API_INLINE bool upb_Message_SetBool(struct upb_Message* msg,
3442
+ const upb_MiniTableField* f, bool value,
3443
+ upb_Arena* a) {
3444
+ return upb_MiniTableField_IsExtension(f)
3445
+ ? upb_Message_SetExtensionBool(
3446
+ msg, (const upb_MiniTableExtension*)f, value, a)
3447
+ : (upb_Message_SetBaseFieldBool(msg, f, value), true);
3448
+ }
3449
+
3450
+ UPB_API_INLINE bool upb_Message_SetDouble(struct upb_Message* msg,
3451
+ const upb_MiniTableField* f,
3452
+ double value, upb_Arena* a) {
3453
+ return upb_MiniTableField_IsExtension(f)
3454
+ ? upb_Message_SetExtensionDouble(
3455
+ msg, (const upb_MiniTableExtension*)f, value, a)
3456
+ : (upb_Message_SetBaseFieldDouble(msg, f, value), true);
3457
+ }
3458
+
3459
+ UPB_API_INLINE bool upb_Message_SetFloat(struct upb_Message* msg,
3460
+ const upb_MiniTableField* f,
3461
+ float value, upb_Arena* a) {
3462
+ return upb_MiniTableField_IsExtension(f)
3463
+ ? upb_Message_SetExtensionFloat(
3464
+ msg, (const upb_MiniTableExtension*)f, value, a)
3465
+ : (upb_Message_SetBaseFieldFloat(msg, f, value), true);
3466
+ }
3467
+
3468
+ UPB_API_INLINE bool upb_Message_SetInt32(struct upb_Message* msg,
3469
+ const upb_MiniTableField* f,
3470
+ int32_t value, upb_Arena* a) {
3471
+ return upb_MiniTableField_IsExtension(f)
3472
+ ? upb_Message_SetExtensionInt32(
3473
+ msg, (const upb_MiniTableExtension*)f, value, a)
3474
+ : (upb_Message_SetBaseFieldInt32(msg, f, value), true);
3475
+ }
3476
+
3477
+ UPB_API_INLINE bool upb_Message_SetInt64(struct upb_Message* msg,
3478
+ const upb_MiniTableField* f,
3479
+ int64_t value, upb_Arena* a) {
3480
+ return upb_MiniTableField_IsExtension(f)
3481
+ ? upb_Message_SetExtensionInt64(
3482
+ msg, (const upb_MiniTableExtension*)f, value, a)
3483
+ : (upb_Message_SetBaseFieldInt64(msg, f, value), true);
3484
+ }
3485
+
3486
+ // Sets the value of a message-typed field. The mini_tables of `msg` and
3487
+ // `value` must have been linked for this to work correctly.
3488
+ UPB_API_INLINE void upb_Message_SetMessage(struct upb_Message* msg,
3489
+ const upb_MiniTableField* f,
3490
+ struct upb_Message* value) {
3491
+ UPB_PRIVATE(_upb_Message_SetTaggedMessagePtr)
3492
+ (msg, f, UPB_PRIVATE(_upb_TaggedMessagePtr_Pack)(value, false));
3493
+ }
3494
+
3495
+ // Sets the value of a `string` or `bytes` field. The bytes of the value are not
3496
+ // copied, so it is the caller's responsibility to ensure that they remain valid
3497
+ // for the lifetime of `msg`. That might be done by copying them into the given
3498
+ // arena, or by fusing that arena with the arena the bytes live in, for example.
3499
+ UPB_API_INLINE bool upb_Message_SetString(struct upb_Message* msg,
3500
+ const upb_MiniTableField* f,
3501
+ upb_StringView value, upb_Arena* a) {
3502
+ return upb_MiniTableField_IsExtension(f)
3503
+ ? upb_Message_SetExtensionString(
3504
+ msg, (const upb_MiniTableExtension*)f, value, a)
3505
+ : (upb_Message_SetBaseFieldString(msg, f, value), true);
3506
+ }
3507
+
3508
+ UPB_API_INLINE bool upb_Message_SetUInt32(struct upb_Message* msg,
3509
+ const upb_MiniTableField* f,
3510
+ uint32_t value, upb_Arena* a) {
3511
+ return upb_MiniTableField_IsExtension(f)
3512
+ ? upb_Message_SetExtensionUInt32(
3513
+ msg, (const upb_MiniTableExtension*)f, value, a)
3514
+ : (upb_Message_SetBaseFieldUInt32(msg, f, value), true);
3515
+ }
3516
+
3517
+ UPB_API_INLINE bool upb_Message_SetUInt64(struct upb_Message* msg,
3518
+ const upb_MiniTableField* f,
3519
+ uint64_t value, upb_Arena* a) {
3520
+ return upb_MiniTableField_IsExtension(f)
3521
+ ? upb_Message_SetExtensionUInt64(
3522
+ msg, (const upb_MiniTableExtension*)f, value, a)
3523
+ : (upb_Message_SetBaseFieldUInt64(msg, f, value), true);
3524
+ }
3525
+
2862
3526
  UPB_API_INLINE void upb_Message_Clear(struct upb_Message* msg,
2863
3527
  const upb_MiniTable* m) {
2864
3528
  UPB_ASSERT(!upb_Message_IsFrozen(msg));
@@ -2900,33 +3564,30 @@ UPB_API_INLINE void upb_Message_ClearExtension(
2900
3564
  }
2901
3565
  }
2902
3566
 
2903
- UPB_INLINE void _upb_Message_AssertMapIsUntagged(
2904
- const struct upb_Message* msg, const upb_MiniTableField* field) {
2905
- UPB_UNUSED(msg);
2906
- UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
2907
- #ifndef NDEBUG
2908
- uintptr_t default_val = 0;
2909
- uintptr_t tagged;
2910
- _upb_Message_GetNonExtensionField(msg, field, &default_val, &tagged);
2911
- UPB_ASSERT(!upb_TaggedMessagePtr_IsEmpty(tagged));
2912
- #endif
3567
+ UPB_API_INLINE void upb_Message_ClearOneof(struct upb_Message* msg,
3568
+ const upb_MiniTable* m,
3569
+ const upb_MiniTableField* f) {
3570
+ UPB_ASSERT(!upb_Message_IsFrozen(msg));
3571
+ uint32_t field_number = upb_Message_WhichOneofFieldNumber(msg, f);
3572
+ if (field_number == 0) {
3573
+ // No field in the oneof is set.
3574
+ return;
3575
+ }
3576
+
3577
+ const upb_MiniTableField* field =
3578
+ upb_MiniTable_FindFieldByNumber(m, field_number);
3579
+ upb_Message_ClearBaseField(msg, field);
2913
3580
  }
2914
3581
 
2915
- UPB_INLINE struct upb_Map* _upb_Message_GetOrCreateMutableMap(
2916
- struct upb_Message* msg, const upb_MiniTableField* field, size_t key_size,
2917
- size_t val_size, upb_Arena* arena) {
2918
- UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
2919
- _upb_Message_AssertMapIsUntagged(msg, field);
2920
- struct upb_Map* map = NULL;
2921
- struct upb_Map* default_map_value = NULL;
2922
- _upb_Message_GetNonExtensionField(msg, field, &default_map_value, &map);
2923
- if (!map) {
2924
- map = _upb_Map_New(arena, key_size, val_size);
2925
- // Check again due to: https://godbolt.org/z/7WfaoKG1r
2926
- UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
2927
- upb_Message_SetBaseField(msg, field, &map);
3582
+ UPB_API_INLINE void* upb_Message_ResizeArrayUninitialized(
3583
+ struct upb_Message* msg, const upb_MiniTableField* f, size_t size,
3584
+ upb_Arena* arena) {
3585
+ UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(f);
3586
+ upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, f, arena);
3587
+ if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(arr, size, arena)) {
3588
+ return NULL;
2928
3589
  }
2929
- return map;
3590
+ return upb_Array_MutableDataPtr(arr);
2930
3591
  }
2931
3592
 
2932
3593
  #ifdef __cplusplus
@@ -3049,12 +3710,6 @@ UPB_API_INLINE bool upb_Map_IsFrozen(const upb_Map* map);
3049
3710
 
3050
3711
  #endif /* UPB_MESSAGE_MAP_H_ */
3051
3712
 
3052
- #ifndef UPB_MINI_TABLE_TAGGED_PTR_H_
3053
- #define UPB_MINI_TABLE_TAGGED_PTR_H_
3054
-
3055
- #include <stdint.h>
3056
-
3057
-
3058
3713
  // Public APIs for message operations that do not depend on the schema.
3059
3714
  //
3060
3715
  // MiniTable-based accessors live in accessors.h.
@@ -3092,16 +3747,12 @@ UPB_API void upb_Message_Freeze(upb_Message* msg, const upb_MiniTable* m);
3092
3747
  UPB_API_INLINE bool upb_Message_IsFrozen(const upb_Message* msg);
3093
3748
 
3094
3749
  #ifdef UPB_TRACING_ENABLED
3095
- UPB_INLINE void upb_Message_SetNewMessageTraceHandler(
3096
- void (*newMessageTraceHandler)(const upb_MiniTable* mini_table,
3097
- const upb_Arena* arena)) {
3098
- UPB_PRIVATE(upb_Message_SetNewMessageTraceHandler)(newMessageTraceHandler);
3099
- }
3100
- UPB_INLINE void upb_Message_LogNewMessage(const upb_MiniTable* mini_table,
3101
- const upb_Arena* arena) {
3102
- UPB_PRIVATE(upb_Message_LogNewMessage)(mini_table, arena);
3103
- }
3104
- #endif
3750
+ UPB_API void upb_Message_LogNewMessage(const upb_MiniTable* m,
3751
+ const upb_Arena* arena);
3752
+
3753
+ UPB_API void upb_Message_SetNewMessageTraceHandler(
3754
+ void (*handler)(const upb_MiniTable* m, const upb_Arena* arena));
3755
+ #endif // UPB_TRACING_ENABLED
3105
3756
 
3106
3757
  #ifdef __cplusplus
3107
3758
  } /* extern "C" */
@@ -3110,6 +3761,12 @@ UPB_INLINE void upb_Message_LogNewMessage(const upb_MiniTable* mini_table,
3110
3761
 
3111
3762
  #endif /* UPB_MESSAGE_MESSAGE_H_ */
3112
3763
 
3764
+ #ifndef UPB_MINI_TABLE_TAGGED_PTR_H_
3765
+ #define UPB_MINI_TABLE_TAGGED_PTR_H_
3766
+
3767
+ #include <stdint.h>
3768
+
3769
+
3113
3770
  // Must be last.
3114
3771
 
3115
3772
  // When a upb_Message* is stored in a message, array, or map, it is stored in a
@@ -3142,41 +3799,6 @@ UPB_API_INLINE upb_Message* upb_TaggedMessagePtr_GetNonEmptyMessage(
3142
3799
 
3143
3800
  #endif /* UPB_MINI_TABLE_TAGGED_PTR_H_ */
3144
3801
 
3145
- #ifndef UPB_MINI_TABLE_SUB_H_
3146
- #define UPB_MINI_TABLE_SUB_H_
3147
-
3148
-
3149
- // Must be last.
3150
-
3151
- typedef union upb_MiniTableSub upb_MiniTableSub;
3152
-
3153
- #ifdef __cplusplus
3154
- extern "C" {
3155
- #endif
3156
-
3157
- // Constructors
3158
-
3159
- UPB_API_INLINE upb_MiniTableSub
3160
- upb_MiniTableSub_FromEnum(const upb_MiniTableEnum* subenum);
3161
-
3162
- UPB_API_INLINE upb_MiniTableSub
3163
- upb_MiniTableSub_FromMessage(const upb_MiniTable* submsg);
3164
-
3165
- // Getters
3166
-
3167
- UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTableSub_Enum(
3168
- upb_MiniTableSub sub);
3169
-
3170
- UPB_API_INLINE const upb_MiniTable* upb_MiniTableSub_Message(
3171
- upb_MiniTableSub sub);
3172
-
3173
- #ifdef __cplusplus
3174
- } /* extern "C" */
3175
- #endif
3176
-
3177
-
3178
- #endif /* UPB_MINI_TABLE_SUB_H_ */
3179
-
3180
3802
  // Must be last.
3181
3803
 
3182
3804
  #ifdef __cplusplus
@@ -3197,419 +3819,217 @@ UPB_API_INLINE void upb_Message_ClearBaseField(upb_Message* msg,
3197
3819
  UPB_API_INLINE void upb_Message_ClearExtension(upb_Message* msg,
3198
3820
  const upb_MiniTableExtension* e);
3199
3821
 
3822
+ UPB_API_INLINE void upb_Message_ClearOneof(upb_Message* msg,
3823
+ const upb_MiniTable* m,
3824
+ const upb_MiniTableField* f);
3825
+
3200
3826
  UPB_API_INLINE bool upb_Message_HasBaseField(const upb_Message* msg,
3201
3827
  const upb_MiniTableField* f);
3202
3828
 
3203
3829
  UPB_API_INLINE bool upb_Message_HasExtension(const upb_Message* msg,
3204
3830
  const upb_MiniTableExtension* e);
3205
3831
 
3206
- UPB_API_INLINE void upb_Message_SetBaseField(upb_Message* msg,
3207
- const upb_MiniTableField* f,
3208
- const void* val);
3209
-
3210
- UPB_API_INLINE bool upb_Message_SetExtension(upb_Message* msg,
3211
- const upb_MiniTableExtension* e,
3212
- const void* val, upb_Arena* a);
3213
-
3214
- UPB_API_INLINE uint32_t upb_Message_WhichOneofFieldNumber(
3215
- const upb_Message* message, const upb_MiniTableField* oneof_field) {
3216
- UPB_ASSUME(upb_MiniTableField_IsInOneof(oneof_field));
3217
- return UPB_PRIVATE(_upb_Message_GetOneofCase)(message, oneof_field);
3218
- }
3832
+ UPB_API_INLINE upb_MessageValue
3833
+ upb_Message_GetField(const upb_Message* msg, const upb_MiniTableField* f,
3834
+ upb_MessageValue default_val);
3219
3835
 
3220
- // NOTE: The default_val is only used for fields that support presence.
3221
- // For repeated/map fields, the resulting upb_Array*/upb_Map* can be NULL if a
3222
- // upb_Array/upb_Map has not been allocated yet. Array/map fields do not have
3223
- // presence, so this is semantically identical to a pointer to an empty
3224
- // array/map, and must be treated the same for all semantic purposes.
3225
- UPB_INLINE upb_MessageValue
3226
- upb_Message_GetField(const upb_Message* msg, const upb_MiniTableField* field,
3227
- upb_MessageValue default_val) {
3228
- upb_MessageValue ret;
3229
- if (upb_MiniTableField_IsExtension(field)) {
3230
- _upb_Message_GetExtensionField(msg, (upb_MiniTableExtension*)field,
3231
- &default_val, &ret);
3232
- } else {
3233
- _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
3234
- }
3235
- return ret;
3236
- }
3836
+ UPB_API_INLINE upb_TaggedMessagePtr upb_Message_GetTaggedMessagePtr(
3837
+ const upb_Message* msg, const upb_MiniTableField* field,
3838
+ upb_Message* default_val);
3237
3839
 
3238
- // Sets the value of the given field in the given msg. The return value is true
3239
- // if the operation completed successfully, or false if memory allocation
3240
- // failed.
3241
- UPB_INLINE bool UPB_PRIVATE(_upb_Message_SetField)(
3242
- upb_Message* msg, const upb_MiniTableField* field, upb_MessageValue val,
3243
- upb_Arena* a) {
3244
- if (upb_MiniTableField_IsExtension(field)) {
3245
- const upb_MiniTableExtension* ext = (const upb_MiniTableExtension*)field;
3246
- return upb_Message_SetExtension(msg, ext, &val, a);
3247
- } else {
3248
- upb_Message_SetBaseField(msg, field, &val);
3249
- return true;
3250
- }
3251
- }
3840
+ UPB_API_INLINE const upb_Array* upb_Message_GetArray(
3841
+ const upb_Message* msg, const upb_MiniTableField* f);
3252
3842
 
3253
3843
  UPB_API_INLINE bool upb_Message_GetBool(const upb_Message* msg,
3254
- const upb_MiniTableField* field,
3255
- bool default_val) {
3256
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
3257
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3258
- kUpb_FieldRep_1Byte);
3259
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3260
- upb_MessageValue def;
3261
- def.bool_val = default_val;
3262
- return upb_Message_GetField(msg, field, def).bool_val;
3263
- }
3844
+ const upb_MiniTableField* f,
3845
+ bool default_val);
3846
+
3847
+ UPB_API_INLINE double upb_Message_GetDouble(const upb_Message* msg,
3848
+ const upb_MiniTableField* field,
3849
+ double default_val);
3264
3850
 
3265
- UPB_API_INLINE bool upb_Message_SetBool(upb_Message* msg,
3266
- const upb_MiniTableField* field,
3267
- bool value, upb_Arena* a) {
3268
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
3269
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3270
- kUpb_FieldRep_1Byte);
3271
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3272
- upb_MessageValue val;
3273
- val.bool_val = value;
3274
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3275
- }
3851
+ UPB_API_INLINE float upb_Message_GetFloat(const upb_Message* msg,
3852
+ const upb_MiniTableField* f,
3853
+ float default_val);
3276
3854
 
3277
3855
  UPB_API_INLINE int32_t upb_Message_GetInt32(const upb_Message* msg,
3278
- const upb_MiniTableField* field,
3279
- int32_t default_val) {
3280
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
3281
- upb_MiniTableField_CType(field) == kUpb_CType_Enum);
3282
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3283
- kUpb_FieldRep_4Byte);
3284
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3856
+ const upb_MiniTableField* f,
3857
+ int32_t default_val);
3285
3858
 
3286
- upb_MessageValue def;
3287
- def.int32_val = default_val;
3288
- return upb_Message_GetField(msg, field, def).int32_val;
3289
- }
3859
+ UPB_API_INLINE int64_t upb_Message_GetInt64(const upb_Message* msg,
3860
+ const upb_MiniTableField* f,
3861
+ int64_t default_val);
3290
3862
 
3291
- UPB_API_INLINE bool upb_Message_SetInt32(upb_Message* msg,
3292
- const upb_MiniTableField* field,
3293
- int32_t value, upb_Arena* a) {
3294
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
3295
- upb_MiniTableField_CType(field) == kUpb_CType_Enum);
3296
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3297
- kUpb_FieldRep_4Byte);
3298
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3299
- upb_MessageValue val;
3300
- val.int32_val = value;
3301
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3302
- }
3863
+ UPB_API_INLINE const upb_Map* upb_Message_GetMap(const upb_Message* msg,
3864
+ const upb_MiniTableField* f);
3303
3865
 
3304
- UPB_API_INLINE uint32_t upb_Message_GetUInt32(const upb_Message* msg,
3305
- const upb_MiniTableField* field,
3306
- uint32_t default_val) {
3307
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
3308
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3309
- kUpb_FieldRep_4Byte);
3310
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3866
+ UPB_API_INLINE const upb_Message* upb_Message_GetMessage(
3867
+ const upb_Message* msg, const upb_MiniTableField* f);
3311
3868
 
3312
- upb_MessageValue def;
3313
- def.uint32_val = default_val;
3314
- return upb_Message_GetField(msg, field, def).uint32_val;
3315
- }
3869
+ UPB_API_INLINE upb_Array* upb_Message_GetMutableArray(
3870
+ upb_Message* msg, const upb_MiniTableField* f);
3316
3871
 
3317
- UPB_API_INLINE bool upb_Message_SetUInt32(upb_Message* msg,
3318
- const upb_MiniTableField* field,
3319
- uint32_t value, upb_Arena* a) {
3320
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
3321
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3322
- kUpb_FieldRep_4Byte);
3323
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3324
- upb_MessageValue val;
3325
- val.uint32_val = value;
3326
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3327
- }
3872
+ UPB_API_INLINE upb_Map* upb_Message_GetMutableMap(upb_Message* msg,
3873
+ const upb_MiniTableField* f);
3874
+
3875
+ UPB_API_INLINE upb_Message* upb_Message_GetMutableMessage(
3876
+ upb_Message* msg, const upb_MiniTableField* f);
3877
+
3878
+ UPB_API_INLINE upb_Array* upb_Message_GetOrCreateMutableArray(
3879
+ upb_Message* msg, const upb_MiniTableField* f, upb_Arena* arena);
3880
+
3881
+ UPB_API_INLINE upb_Map* upb_Message_GetOrCreateMutableMap(
3882
+ upb_Message* msg, const upb_MiniTable* map_entry_mini_table,
3883
+ const upb_MiniTableField* f, upb_Arena* arena);
3884
+
3885
+ UPB_API_INLINE upb_Message* upb_Message_GetOrCreateMutableMessage(
3886
+ upb_Message* msg, const upb_MiniTable* mini_table,
3887
+ const upb_MiniTableField* f, upb_Arena* arena);
3888
+
3889
+ UPB_API_INLINE upb_StringView
3890
+ upb_Message_GetString(const upb_Message* msg, const upb_MiniTableField* field,
3891
+ upb_StringView default_val);
3892
+
3893
+ UPB_API_INLINE uint32_t upb_Message_GetUInt32(const upb_Message* msg,
3894
+ const upb_MiniTableField* f,
3895
+ uint32_t default_val);
3896
+
3897
+ UPB_API_INLINE uint64_t upb_Message_GetUInt64(const upb_Message* msg,
3898
+ const upb_MiniTableField* f,
3899
+ uint64_t default_val);
3328
3900
 
3329
3901
  UPB_API_INLINE void upb_Message_SetClosedEnum(
3330
3902
  upb_Message* msg, const upb_MiniTable* msg_mini_table,
3331
- const upb_MiniTableField* field, int32_t value) {
3332
- UPB_ASSERT(upb_MiniTableField_IsClosedEnum(field));
3333
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3334
- kUpb_FieldRep_4Byte);
3335
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3336
- UPB_ASSERT(upb_MiniTableEnum_CheckValue(
3337
- upb_MiniTable_GetSubEnumTable(msg_mini_table, field), value));
3338
- upb_Message_SetBaseField(msg, field, &value);
3339
- }
3903
+ const upb_MiniTableField* f, int32_t value);
3340
3904
 
3341
- UPB_API_INLINE int64_t upb_Message_GetInt64(const upb_Message* msg,
3342
- const upb_MiniTableField* field,
3343
- int64_t default_val) {
3344
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
3345
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3346
- kUpb_FieldRep_8Byte);
3347
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3905
+ // BaseField Setters ///////////////////////////////////////////////////////////
3348
3906
 
3349
- upb_MessageValue def;
3350
- def.int64_val = default_val;
3351
- return upb_Message_GetField(msg, field, def).int64_val;
3352
- }
3907
+ UPB_API_INLINE void upb_Message_SetBaseField(upb_Message* msg,
3908
+ const upb_MiniTableField* f,
3909
+ const void* val);
3353
3910
 
3354
- UPB_API_INLINE bool upb_Message_SetInt64(upb_Message* msg,
3355
- const upb_MiniTableField* field,
3356
- int64_t value, upb_Arena* a) {
3357
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
3358
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3359
- kUpb_FieldRep_8Byte);
3360
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3361
- upb_MessageValue val;
3362
- val.int64_val = value;
3363
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3364
- }
3911
+ UPB_API_INLINE void upb_Message_SetBaseFieldBool(struct upb_Message* msg,
3912
+ const upb_MiniTableField* f,
3913
+ bool value);
3365
3914
 
3366
- UPB_API_INLINE uint64_t upb_Message_GetUInt64(const upb_Message* msg,
3367
- const upb_MiniTableField* field,
3368
- uint64_t default_val) {
3369
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
3370
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3371
- kUpb_FieldRep_8Byte);
3372
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3915
+ UPB_API_INLINE void upb_Message_SetBaseFieldDouble(struct upb_Message* msg,
3916
+ const upb_MiniTableField* f,
3917
+ double value);
3373
3918
 
3374
- upb_MessageValue def;
3375
- def.uint64_val = default_val;
3376
- return upb_Message_GetField(msg, field, def).uint64_val;
3377
- }
3919
+ UPB_API_INLINE void upb_Message_SetBaseFieldFloat(struct upb_Message* msg,
3920
+ const upb_MiniTableField* f,
3921
+ float value);
3378
3922
 
3379
- UPB_API_INLINE bool upb_Message_SetUInt64(upb_Message* msg,
3380
- const upb_MiniTableField* field,
3381
- uint64_t value, upb_Arena* a) {
3382
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
3383
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3384
- kUpb_FieldRep_8Byte);
3385
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3386
- upb_MessageValue val;
3387
- val.uint64_val = value;
3388
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3389
- }
3923
+ UPB_API_INLINE void upb_Message_SetBaseFieldInt32(struct upb_Message* msg,
3924
+ const upb_MiniTableField* f,
3925
+ int32_t value);
3390
3926
 
3391
- UPB_API_INLINE float upb_Message_GetFloat(const upb_Message* msg,
3392
- const upb_MiniTableField* field,
3393
- float default_val) {
3394
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
3395
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3396
- kUpb_FieldRep_4Byte);
3397
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3927
+ UPB_API_INLINE void upb_Message_SetBaseFieldInt64(struct upb_Message* msg,
3928
+ const upb_MiniTableField* f,
3929
+ int64_t value);
3398
3930
 
3399
- upb_MessageValue def;
3400
- def.float_val = default_val;
3401
- return upb_Message_GetField(msg, field, def).float_val;
3402
- }
3931
+ UPB_API_INLINE void upb_Message_SetBaseFieldString(struct upb_Message* msg,
3932
+ const upb_MiniTableField* f,
3933
+ upb_StringView value);
3403
3934
 
3404
- UPB_API_INLINE bool upb_Message_SetFloat(upb_Message* msg,
3405
- const upb_MiniTableField* field,
3406
- float value, upb_Arena* a) {
3407
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
3408
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3409
- kUpb_FieldRep_4Byte);
3410
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3411
- upb_MessageValue val;
3412
- val.float_val = value;
3413
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3414
- }
3935
+ UPB_API_INLINE void upb_Message_SetBaseFieldUInt32(struct upb_Message* msg,
3936
+ const upb_MiniTableField* f,
3937
+ uint32_t value);
3415
3938
 
3416
- UPB_API_INLINE double upb_Message_GetDouble(const upb_Message* msg,
3417
- const upb_MiniTableField* field,
3418
- double default_val) {
3419
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
3420
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3421
- kUpb_FieldRep_8Byte);
3422
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3939
+ UPB_API_INLINE void upb_Message_SetBaseFieldUInt64(struct upb_Message* msg,
3940
+ const upb_MiniTableField* f,
3941
+ uint64_t value);
3423
3942
 
3424
- upb_MessageValue def;
3425
- def.double_val = default_val;
3426
- return upb_Message_GetField(msg, field, def).double_val;
3427
- }
3943
+ // Extension Setters ///////////////////////////////////////////////////////////
3428
3944
 
3429
- UPB_API_INLINE bool upb_Message_SetDouble(upb_Message* msg,
3430
- const upb_MiniTableField* field,
3431
- double value, upb_Arena* a) {
3432
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
3433
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3434
- kUpb_FieldRep_8Byte);
3435
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3436
- upb_MessageValue val;
3437
- val.double_val = value;
3438
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3439
- }
3945
+ UPB_API_INLINE bool upb_Message_SetExtension(upb_Message* msg,
3946
+ const upb_MiniTableExtension* e,
3947
+ const void* value, upb_Arena* a);
3440
3948
 
3441
- UPB_API_INLINE upb_StringView
3442
- upb_Message_GetString(const upb_Message* msg, const upb_MiniTableField* field,
3443
- upb_StringView default_val) {
3444
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
3445
- upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
3446
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3447
- kUpb_FieldRep_StringView);
3448
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3949
+ UPB_API_INLINE bool upb_Message_SetExtensionBool(
3950
+ struct upb_Message* msg, const upb_MiniTableExtension* e, bool value,
3951
+ upb_Arena* a);
3449
3952
 
3450
- upb_MessageValue def;
3451
- def.str_val = default_val;
3452
- return upb_Message_GetField(msg, field, def).str_val;
3453
- }
3953
+ UPB_API_INLINE bool upb_Message_SetExtensionDouble(
3954
+ struct upb_Message* msg, const upb_MiniTableExtension* e, double value,
3955
+ upb_Arena* a);
3454
3956
 
3455
- // Sets the value of a `string` or `bytes` field. The bytes of the value are not
3456
- // copied, so it is the caller's responsibility to ensure that they remain valid
3457
- // for the lifetime of `msg`. That might be done by copying them into the given
3458
- // arena, or by fusing that arena with the arena the bytes live in, for example.
3459
- UPB_API_INLINE bool upb_Message_SetString(upb_Message* msg,
3460
- const upb_MiniTableField* field,
3461
- upb_StringView value, upb_Arena* a) {
3462
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
3463
- upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
3464
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3465
- kUpb_FieldRep_StringView);
3466
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3467
- upb_MessageValue val;
3468
- val.str_val = value;
3469
- return UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, a);
3470
- }
3957
+ UPB_API_INLINE bool upb_Message_SetExtensionFloat(
3958
+ struct upb_Message* msg, const upb_MiniTableExtension* e, float value,
3959
+ upb_Arena* a);
3471
3960
 
3472
- UPB_API_INLINE upb_TaggedMessagePtr upb_Message_GetTaggedMessagePtr(
3473
- const upb_Message* msg, const upb_MiniTableField* field,
3474
- upb_Message* default_val) {
3475
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
3476
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3477
- UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
3478
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3479
- upb_TaggedMessagePtr tagged;
3480
- _upb_Message_GetNonExtensionField(msg, field, &default_val, &tagged);
3481
- return tagged;
3482
- }
3961
+ UPB_API_INLINE bool upb_Message_SetExtensionInt32(
3962
+ struct upb_Message* msg, const upb_MiniTableExtension* e, int32_t value,
3963
+ upb_Arena* a);
3483
3964
 
3484
- UPB_API_INLINE const upb_Message* upb_Message_GetMessage(
3485
- const upb_Message* msg, const upb_MiniTableField* field) {
3486
- upb_TaggedMessagePtr tagged =
3487
- upb_Message_GetTaggedMessagePtr(msg, field, NULL);
3488
- return upb_TaggedMessagePtr_GetNonEmptyMessage(tagged);
3489
- }
3965
+ UPB_API_INLINE bool upb_Message_SetExtensionInt64(
3966
+ struct upb_Message* msg, const upb_MiniTableExtension* e, int64_t value,
3967
+ upb_Arena* a);
3490
3968
 
3491
- UPB_API_INLINE upb_Message* upb_Message_GetMutableMessage(
3492
- upb_Message* msg, const upb_MiniTableField* field) {
3493
- return (upb_Message*)upb_Message_GetMessage(msg, field);
3494
- }
3969
+ UPB_API_INLINE bool upb_Message_SetExtensionString(
3970
+ struct upb_Message* msg, const upb_MiniTableExtension* e,
3971
+ upb_StringView value, upb_Arena* a);
3495
3972
 
3496
- // For internal use only; users cannot set tagged messages because only the
3497
- // parser and the message copier are allowed to directly create an empty
3498
- // message.
3499
- UPB_API_INLINE void _upb_Message_SetTaggedMessagePtr(
3500
- upb_Message* msg, const upb_MiniTable* mini_table,
3501
- const upb_MiniTableField* field, upb_TaggedMessagePtr sub_message) {
3502
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
3503
- UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(field) ==
3504
- UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
3505
- UPB_ASSUME(upb_MiniTableField_IsScalar(field));
3506
- UPB_ASSERT(upb_MiniTableSub_Message(
3507
- mini_table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)]));
3508
- upb_Message_SetBaseField(msg, field, &sub_message);
3509
- }
3973
+ UPB_API_INLINE bool upb_Message_SetExtensionUInt32(
3974
+ struct upb_Message* msg, const upb_MiniTableExtension* e, uint32_t value,
3975
+ upb_Arena* a);
3976
+
3977
+ UPB_API_INLINE bool upb_Message_SetExtensionUInt64(
3978
+ struct upb_Message* msg, const upb_MiniTableExtension* e, uint64_t value,
3979
+ upb_Arena* a);
3980
+
3981
+ // Universal Setters ///////////////////////////////////////////////////////////
3982
+
3983
+ UPB_API_INLINE bool upb_Message_SetBool(upb_Message* msg,
3984
+ const upb_MiniTableField* f, bool value,
3985
+ upb_Arena* a);
3986
+
3987
+ UPB_API_INLINE bool upb_Message_SetDouble(upb_Message* msg,
3988
+ const upb_MiniTableField* f,
3989
+ double value, upb_Arena* a);
3990
+
3991
+ UPB_API_INLINE bool upb_Message_SetFloat(upb_Message* msg,
3992
+ const upb_MiniTableField* f,
3993
+ float value, upb_Arena* a);
3994
+
3995
+ UPB_API_INLINE bool upb_Message_SetInt32(upb_Message* msg,
3996
+ const upb_MiniTableField* f,
3997
+ int32_t value, upb_Arena* a);
3998
+
3999
+ UPB_API_INLINE bool upb_Message_SetInt64(upb_Message* msg,
4000
+ const upb_MiniTableField* f,
4001
+ int64_t value, upb_Arena* a);
3510
4002
 
3511
- // Sets the value of a message-typed field. The `mini_table` and `field`
3512
- // parameters belong to `msg`, not `sub_message`. The mini_tables of `msg` and
3513
- // `sub_message` must have been linked for this to work correctly.
3514
4003
  UPB_API_INLINE void upb_Message_SetMessage(upb_Message* msg,
3515
- const upb_MiniTable* mini_table,
3516
- const upb_MiniTableField* field,
3517
- upb_Message* sub_message) {
3518
- _upb_Message_SetTaggedMessagePtr(
3519
- msg, mini_table, field,
3520
- UPB_PRIVATE(_upb_TaggedMessagePtr_Pack)(sub_message, false));
3521
- }
4004
+ const upb_MiniTableField* f,
4005
+ upb_Message* value);
3522
4006
 
3523
- UPB_API_INLINE upb_Message* upb_Message_GetOrCreateMutableMessage(
3524
- upb_Message* msg, const upb_MiniTable* mini_table,
3525
- const upb_MiniTableField* field, upb_Arena* arena) {
3526
- UPB_ASSERT(arena);
3527
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
3528
- upb_Message* sub_message =
3529
- *UPB_PTR_AT(msg, field->UPB_ONLYBITS(offset), upb_Message*);
3530
- if (!sub_message) {
3531
- const upb_MiniTable* sub_mini_table = upb_MiniTableSub_Message(
3532
- mini_table->UPB_PRIVATE(subs)[field->UPB_PRIVATE(submsg_index)]);
3533
- UPB_ASSERT(sub_mini_table);
3534
- sub_message = _upb_Message_New(sub_mini_table, arena);
3535
- *UPB_PTR_AT(msg, field->UPB_ONLYBITS(offset), upb_Message*) = sub_message;
3536
- UPB_PRIVATE(_upb_Message_SetPresence)(msg, field);
3537
- }
3538
- return sub_message;
3539
- }
4007
+ UPB_API_INLINE bool upb_Message_SetString(upb_Message* msg,
4008
+ const upb_MiniTableField* f,
4009
+ upb_StringView value, upb_Arena* a);
3540
4010
 
3541
- UPB_API_INLINE const upb_Array* upb_Message_GetArray(
3542
- const upb_Message* msg, const upb_MiniTableField* field) {
3543
- UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
3544
- upb_Array* ret;
3545
- const upb_Array* default_val = NULL;
3546
- _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
3547
- return ret;
3548
- }
4011
+ UPB_API_INLINE bool upb_Message_SetUInt32(upb_Message* msg,
4012
+ const upb_MiniTableField* f,
4013
+ uint32_t value, upb_Arena* a);
3549
4014
 
3550
- UPB_API_INLINE upb_Array* upb_Message_GetMutableArray(
3551
- upb_Message* msg, const upb_MiniTableField* field) {
3552
- UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
3553
- return (upb_Array*)upb_Message_GetArray(msg, field);
3554
- }
4015
+ UPB_API_INLINE bool upb_Message_SetUInt64(upb_Message* msg,
4016
+ const upb_MiniTableField* f,
4017
+ uint64_t value, upb_Arena* a);
3555
4018
 
3556
- UPB_API_INLINE upb_Array* upb_Message_GetOrCreateMutableArray(
3557
- upb_Message* msg, const upb_MiniTableField* field, upb_Arena* arena) {
3558
- UPB_ASSERT(arena);
3559
- UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
3560
- upb_Array* array = upb_Message_GetMutableArray(msg, field);
3561
- if (!array) {
3562
- array = UPB_PRIVATE(_upb_Array_New)(
3563
- arena, 4, UPB_PRIVATE(_upb_MiniTableField_ElemSizeLg2)(field));
3564
- // Check again due to: https://godbolt.org/z/7WfaoKG1r
3565
- UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
3566
- upb_MessageValue val;
3567
- val.array_val = array;
3568
- UPB_PRIVATE(_upb_Message_SetField)(msg, field, val, arena);
3569
- }
3570
- return array;
3571
- }
4019
+ ////////////////////////////////////////////////////////////////////////////////
3572
4020
 
3573
4021
  UPB_API_INLINE void* upb_Message_ResizeArrayUninitialized(
3574
- upb_Message* msg, const upb_MiniTableField* field, size_t size,
3575
- upb_Arena* arena) {
3576
- UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(field);
3577
- upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, field, arena);
3578
- if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(arr, size, arena)) {
3579
- return NULL;
3580
- }
3581
- return upb_Array_MutableDataPtr(arr);
3582
- }
3583
-
3584
- UPB_API_INLINE const upb_Map* upb_Message_GetMap(
3585
- const upb_Message* msg, const upb_MiniTableField* field) {
3586
- UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(field);
3587
- _upb_Message_AssertMapIsUntagged(msg, field);
3588
- upb_Map* ret;
3589
- const upb_Map* default_val = NULL;
3590
- _upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
3591
- return ret;
3592
- }
4022
+ upb_Message* msg, const upb_MiniTableField* f, size_t size,
4023
+ upb_Arena* arena);
3593
4024
 
3594
- UPB_API_INLINE upb_Map* upb_Message_GetMutableMap(
3595
- upb_Message* msg, const upb_MiniTableField* field) {
3596
- return (upb_Map*)upb_Message_GetMap(msg, field);
3597
- }
4025
+ UPB_API_INLINE uint32_t upb_Message_WhichOneofFieldNumber(
4026
+ const upb_Message* message, const upb_MiniTableField* oneof_field);
3598
4027
 
3599
- UPB_API_INLINE upb_Map* upb_Message_GetOrCreateMutableMap(
3600
- upb_Message* msg, const upb_MiniTable* map_entry_mini_table,
3601
- const upb_MiniTableField* field, upb_Arena* arena) {
3602
- UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
3603
- const upb_MiniTableField* map_entry_key_field =
3604
- &map_entry_mini_table->UPB_ONLYBITS(fields)[0];
3605
- const upb_MiniTableField* map_entry_value_field =
3606
- &map_entry_mini_table->UPB_ONLYBITS(fields)[1];
3607
- return _upb_Message_GetOrCreateMutableMap(
3608
- msg, field,
3609
- _upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_key_field)),
3610
- _upb_Map_CTypeSize(upb_MiniTableField_CType(map_entry_value_field)),
3611
- arena);
3612
- }
4028
+ // For a field `f` which is in a oneof, return the field of that
4029
+ // oneof that is actually set (or NULL if none).
4030
+ UPB_API_INLINE const upb_MiniTableField* upb_Message_WhichOneof(
4031
+ const upb_Message* msg, const upb_MiniTable* m,
4032
+ const upb_MiniTableField* f);
3613
4033
 
3614
4034
  // Updates a map entry given an entry message.
3615
4035
  bool upb_Message_SetMapEntry(upb_Map* map, const upb_MiniTable* mini_table,
@@ -3676,6 +4096,41 @@ UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val,
3676
4096
  #define UPB_MINI_TABLE_DECODE_H_
3677
4097
 
3678
4098
 
4099
+ #ifndef UPB_MINI_TABLE_SUB_H_
4100
+ #define UPB_MINI_TABLE_SUB_H_
4101
+
4102
+
4103
+ // Must be last.
4104
+
4105
+ typedef union upb_MiniTableSub upb_MiniTableSub;
4106
+
4107
+ #ifdef __cplusplus
4108
+ extern "C" {
4109
+ #endif
4110
+
4111
+ // Constructors
4112
+
4113
+ UPB_API_INLINE upb_MiniTableSub
4114
+ upb_MiniTableSub_FromEnum(const upb_MiniTableEnum* subenum);
4115
+
4116
+ UPB_API_INLINE upb_MiniTableSub
4117
+ upb_MiniTableSub_FromMessage(const upb_MiniTable* submsg);
4118
+
4119
+ // Getters
4120
+
4121
+ UPB_API_INLINE const upb_MiniTableEnum* upb_MiniTableSub_Enum(
4122
+ upb_MiniTableSub sub);
4123
+
4124
+ UPB_API_INLINE const upb_MiniTable* upb_MiniTableSub_Message(
4125
+ upb_MiniTableSub sub);
4126
+
4127
+ #ifdef __cplusplus
4128
+ } /* extern "C" */
4129
+ #endif
4130
+
4131
+
4132
+ #endif /* UPB_MINI_TABLE_SUB_H_ */
4133
+
3679
4134
  // Export the newer headers, for legacy users. New users should include the
3680
4135
  // more specific headers directly.
3681
4136
  // IWYU pragma: begin_exports
@@ -3928,6 +4383,23 @@ bool upb_ExtensionRegistry_AddArray(upb_ExtensionRegistry* r,
3928
4383
  const upb_MiniTableExtension** e,
3929
4384
  size_t count);
3930
4385
 
4386
+ #ifdef UPB_LINKARR_DECLARE
4387
+
4388
+ // Adds all extensions linked into the binary into the registry. The set of
4389
+ // linked extensions is assembled by the linker using linker arrays. This
4390
+ // will likely not work properly if the extensions are split across multiple
4391
+ // shared libraries.
4392
+ //
4393
+ // Returns true if all extensions were added successfully, false on out of
4394
+ // memory or if any extensions were already present.
4395
+ //
4396
+ // This API is currently not available on MSVC (though it *is* available on
4397
+ // Windows using clang-cl).
4398
+ UPB_API bool upb_ExtensionRegistry_AddAllLinkedExtensions(
4399
+ upb_ExtensionRegistry* r);
4400
+
4401
+ #endif // UPB_LINKARR_DECLARE
4402
+
3931
4403
  // Looks up the extension (if any) defined for message type |t| and field
3932
4404
  // number |num|. Returns the extension if found, otherwise NULL.
3933
4405
  UPB_API const upb_MiniTableExtension* upb_ExtensionRegistry_Lookup(
@@ -4165,6 +4637,9 @@ UPB_API upb_DecodeStatus upb_DecodeLengthPrefixed(
4165
4637
  const upb_MiniTable* mt, const upb_ExtensionRegistry* extreg, int options,
4166
4638
  upb_Arena* arena);
4167
4639
 
4640
+ // Utility function for wrapper languages to get an error string from a
4641
+ // upb_DecodeStatus.
4642
+ UPB_API const char* upb_DecodeStatus_String(upb_DecodeStatus status);
4168
4643
  #ifdef __cplusplus
4169
4644
  } /* extern "C" */
4170
4645
  #endif
@@ -4238,6 +4713,9 @@ UPB_API upb_EncodeStatus upb_EncodeLengthPrefixed(const upb_Message* msg,
4238
4713
  const upb_MiniTable* l,
4239
4714
  int options, upb_Arena* arena,
4240
4715
  char** buf, size_t* size);
4716
+ // Utility function for wrapper languages to get an error string from a
4717
+ // upb_EncodeStatus.
4718
+ UPB_API const char* upb_EncodeStatus_String(upb_EncodeStatus status);
4241
4719
 
4242
4720
  #ifdef __cplusplus
4243
4721
  } /* extern "C" */
@@ -4392,7 +4870,8 @@ TAGBYTES(r)
4392
4870
  * google/protobuf/descriptor.proto
4393
4871
  *
4394
4872
  * Do not edit -- your changes will be discarded when the file is
4395
- * regenerated. */
4873
+ * regenerated.
4874
+ * NO CHECKED-IN PROTOBUF GENCODE */
4396
4875
 
4397
4876
  #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_MINITABLE_H_
4398
4877
  #define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_MINITABLE_H_
@@ -4405,38 +4884,71 @@ extern "C" {
4405
4884
  #endif
4406
4885
 
4407
4886
  extern const upb_MiniTable google__protobuf__FileDescriptorSet_msg_init;
4887
+ extern const upb_MiniTable* google__protobuf__FileDescriptorSet_msg_init_ptr;
4408
4888
  extern const upb_MiniTable google__protobuf__FileDescriptorProto_msg_init;
4889
+ extern const upb_MiniTable* google__protobuf__FileDescriptorProto_msg_init_ptr;
4409
4890
  extern const upb_MiniTable google__protobuf__DescriptorProto_msg_init;
4891
+ extern const upb_MiniTable* google__protobuf__DescriptorProto_msg_init_ptr;
4410
4892
  extern const upb_MiniTable google__protobuf__DescriptorProto__ExtensionRange_msg_init;
4893
+ extern const upb_MiniTable* google__protobuf__DescriptorProto__ExtensionRange_msg_init_ptr;
4411
4894
  extern const upb_MiniTable google__protobuf__DescriptorProto__ReservedRange_msg_init;
4895
+ extern const upb_MiniTable* google__protobuf__DescriptorProto__ReservedRange_msg_init_ptr;
4412
4896
  extern const upb_MiniTable google__protobuf__ExtensionRangeOptions_msg_init;
4897
+ extern const upb_MiniTable* google__protobuf__ExtensionRangeOptions_msg_init_ptr;
4413
4898
  extern const upb_MiniTable google__protobuf__ExtensionRangeOptions__Declaration_msg_init;
4899
+ extern const upb_MiniTable* google__protobuf__ExtensionRangeOptions__Declaration_msg_init_ptr;
4414
4900
  extern const upb_MiniTable google__protobuf__FieldDescriptorProto_msg_init;
4901
+ extern const upb_MiniTable* google__protobuf__FieldDescriptorProto_msg_init_ptr;
4415
4902
  extern const upb_MiniTable google__protobuf__OneofDescriptorProto_msg_init;
4903
+ extern const upb_MiniTable* google__protobuf__OneofDescriptorProto_msg_init_ptr;
4416
4904
  extern const upb_MiniTable google__protobuf__EnumDescriptorProto_msg_init;
4905
+ extern const upb_MiniTable* google__protobuf__EnumDescriptorProto_msg_init_ptr;
4417
4906
  extern const upb_MiniTable google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init;
4907
+ extern const upb_MiniTable* google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init_ptr;
4418
4908
  extern const upb_MiniTable google__protobuf__EnumValueDescriptorProto_msg_init;
4909
+ extern const upb_MiniTable* google__protobuf__EnumValueDescriptorProto_msg_init_ptr;
4419
4910
  extern const upb_MiniTable google__protobuf__ServiceDescriptorProto_msg_init;
4911
+ extern const upb_MiniTable* google__protobuf__ServiceDescriptorProto_msg_init_ptr;
4420
4912
  extern const upb_MiniTable google__protobuf__MethodDescriptorProto_msg_init;
4913
+ extern const upb_MiniTable* google__protobuf__MethodDescriptorProto_msg_init_ptr;
4421
4914
  extern const upb_MiniTable google__protobuf__FileOptions_msg_init;
4915
+ extern const upb_MiniTable* google__protobuf__FileOptions_msg_init_ptr;
4422
4916
  extern const upb_MiniTable google__protobuf__MessageOptions_msg_init;
4917
+ extern const upb_MiniTable* google__protobuf__MessageOptions_msg_init_ptr;
4423
4918
  extern const upb_MiniTable google__protobuf__FieldOptions_msg_init;
4919
+ extern const upb_MiniTable* google__protobuf__FieldOptions_msg_init_ptr;
4424
4920
  extern const upb_MiniTable google__protobuf__FieldOptions__EditionDefault_msg_init;
4921
+ extern const upb_MiniTable* google__protobuf__FieldOptions__EditionDefault_msg_init_ptr;
4425
4922
  extern const upb_MiniTable google__protobuf__FieldOptions__FeatureSupport_msg_init;
4923
+ extern const upb_MiniTable* google__protobuf__FieldOptions__FeatureSupport_msg_init_ptr;
4426
4924
  extern const upb_MiniTable google__protobuf__OneofOptions_msg_init;
4925
+ extern const upb_MiniTable* google__protobuf__OneofOptions_msg_init_ptr;
4427
4926
  extern const upb_MiniTable google__protobuf__EnumOptions_msg_init;
4927
+ extern const upb_MiniTable* google__protobuf__EnumOptions_msg_init_ptr;
4428
4928
  extern const upb_MiniTable google__protobuf__EnumValueOptions_msg_init;
4929
+ extern const upb_MiniTable* google__protobuf__EnumValueOptions_msg_init_ptr;
4429
4930
  extern const upb_MiniTable google__protobuf__ServiceOptions_msg_init;
4931
+ extern const upb_MiniTable* google__protobuf__ServiceOptions_msg_init_ptr;
4430
4932
  extern const upb_MiniTable google__protobuf__MethodOptions_msg_init;
4933
+ extern const upb_MiniTable* google__protobuf__MethodOptions_msg_init_ptr;
4431
4934
  extern const upb_MiniTable google__protobuf__UninterpretedOption_msg_init;
4935
+ extern const upb_MiniTable* google__protobuf__UninterpretedOption_msg_init_ptr;
4432
4936
  extern const upb_MiniTable google__protobuf__UninterpretedOption__NamePart_msg_init;
4937
+ extern const upb_MiniTable* google__protobuf__UninterpretedOption__NamePart_msg_init_ptr;
4433
4938
  extern const upb_MiniTable google__protobuf__FeatureSet_msg_init;
4939
+ extern const upb_MiniTable* google__protobuf__FeatureSet_msg_init_ptr;
4434
4940
  extern const upb_MiniTable google__protobuf__FeatureSetDefaults_msg_init;
4941
+ extern const upb_MiniTable* google__protobuf__FeatureSetDefaults_msg_init_ptr;
4435
4942
  extern const upb_MiniTable google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init;
4943
+ extern const upb_MiniTable* google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init_ptr;
4436
4944
  extern const upb_MiniTable google__protobuf__SourceCodeInfo_msg_init;
4945
+ extern const upb_MiniTable* google__protobuf__SourceCodeInfo_msg_init_ptr;
4437
4946
  extern const upb_MiniTable google__protobuf__SourceCodeInfo__Location_msg_init;
4947
+ extern const upb_MiniTable* google__protobuf__SourceCodeInfo__Location_msg_init_ptr;
4438
4948
  extern const upb_MiniTable google__protobuf__GeneratedCodeInfo_msg_init;
4949
+ extern const upb_MiniTable* google__protobuf__GeneratedCodeInfo_msg_init_ptr;
4439
4950
  extern const upb_MiniTable google__protobuf__GeneratedCodeInfo__Annotation_msg_init;
4951
+ extern const upb_MiniTable* google__protobuf__GeneratedCodeInfo__Annotation_msg_init_ptr;
4440
4952
 
4441
4953
  extern const upb_MiniTableEnum google_protobuf_Edition_enum_init;
4442
4954
  extern const upb_MiniTableEnum google_protobuf_ExtensionRangeOptions_VerificationState_enum_init;
@@ -4896,7 +5408,8 @@ UPB_FORCEINLINE bool upb_EpsCopyInputStream_TryParseDelimitedFast(
4896
5408
  * google/protobuf/descriptor.proto
4897
5409
  *
4898
5410
  * Do not edit -- your changes will be discarded when the file is
4899
- * regenerated. */
5411
+ * regenerated.
5412
+ * NO CHECKED-IN PROTOBUF GENCODE */
4900
5413
 
4901
5414
  #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
4902
5415
  #define GOOGLE_PROTOBUF_DESCRIPTOR_PROTO_UPB_H_
@@ -5120,6 +5633,7 @@ UPB_INLINE void google_protobuf_FileDescriptorSet_clear_file(google_protobuf_Fil
5120
5633
  }
5121
5634
  UPB_INLINE const google_protobuf_FileDescriptorProto* const* google_protobuf_FileDescriptorSet_file(const google_protobuf_FileDescriptorSet* msg, size_t* size) {
5122
5635
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5636
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileDescriptorProto_msg_init);
5123
5637
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5124
5638
  if (arr) {
5125
5639
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5131,6 +5645,7 @@ UPB_INLINE const google_protobuf_FileDescriptorProto* const* google_protobuf_Fil
5131
5645
  }
5132
5646
  UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorSet_file_upb_array(const google_protobuf_FileDescriptorSet* msg, size_t* size) {
5133
5647
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5648
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileDescriptorProto_msg_init);
5134
5649
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5135
5650
  if (size) {
5136
5651
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5139,6 +5654,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorSet_file_upb_array(co
5139
5654
  }
5140
5655
  UPB_INLINE upb_Array* _google_protobuf_FileDescriptorSet_file_mutable_upb_array(google_protobuf_FileDescriptorSet* msg, size_t* size, upb_Arena* arena) {
5141
5656
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5657
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileDescriptorProto_msg_init);
5142
5658
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5143
5659
  &field, arena);
5144
5660
  if (size) {
@@ -5149,6 +5665,7 @@ UPB_INLINE upb_Array* _google_protobuf_FileDescriptorSet_file_mutable_upb_array(
5149
5665
 
5150
5666
  UPB_INLINE google_protobuf_FileDescriptorProto** google_protobuf_FileDescriptorSet_mutable_file(google_protobuf_FileDescriptorSet* msg, size_t* size) {
5151
5667
  upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5668
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileDescriptorProto_msg_init);
5152
5669
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
5153
5670
  if (arr) {
5154
5671
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5165,6 +5682,7 @@ UPB_INLINE google_protobuf_FileDescriptorProto** google_protobuf_FileDescriptorS
5165
5682
  }
5166
5683
  UPB_INLINE struct google_protobuf_FileDescriptorProto* google_protobuf_FileDescriptorSet_add_file(google_protobuf_FileDescriptorSet* msg, upb_Arena* arena) {
5167
5684
  upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5685
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileDescriptorProto_msg_init);
5168
5686
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
5169
5687
  UPB_UPCAST(msg), &field, arena);
5170
5688
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -5284,6 +5802,7 @@ UPB_INLINE void google_protobuf_FileDescriptorProto_clear_message_type(google_pr
5284
5802
  }
5285
5803
  UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_FileDescriptorProto_message_type(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5286
5804
  const upb_MiniTableField field = {4, UPB_SIZE(16, 56), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5805
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5287
5806
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5288
5807
  if (arr) {
5289
5808
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5295,6 +5814,7 @@ UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_FileDes
5295
5814
  }
5296
5815
  UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_message_type_upb_array(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5297
5816
  const upb_MiniTableField field = {4, UPB_SIZE(16, 56), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5817
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5298
5818
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5299
5819
  if (size) {
5300
5820
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5303,6 +5823,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_message_type_up
5303
5823
  }
5304
5824
  UPB_INLINE upb_Array* _google_protobuf_FileDescriptorProto_message_type_mutable_upb_array(google_protobuf_FileDescriptorProto* msg, size_t* size, upb_Arena* arena) {
5305
5825
  const upb_MiniTableField field = {4, UPB_SIZE(16, 56), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5826
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5306
5827
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5307
5828
  &field, arena);
5308
5829
  if (size) {
@@ -5316,6 +5837,7 @@ UPB_INLINE void google_protobuf_FileDescriptorProto_clear_enum_type(google_proto
5316
5837
  }
5317
5838
  UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_FileDescriptorProto_enum_type(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5318
5839
  const upb_MiniTableField field = {5, UPB_SIZE(20, 64), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5840
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5319
5841
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5320
5842
  if (arr) {
5321
5843
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5327,6 +5849,7 @@ UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_Fil
5327
5849
  }
5328
5850
  UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_enum_type_upb_array(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5329
5851
  const upb_MiniTableField field = {5, UPB_SIZE(20, 64), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5852
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5330
5853
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5331
5854
  if (size) {
5332
5855
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5335,6 +5858,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_enum_type_upb_a
5335
5858
  }
5336
5859
  UPB_INLINE upb_Array* _google_protobuf_FileDescriptorProto_enum_type_mutable_upb_array(google_protobuf_FileDescriptorProto* msg, size_t* size, upb_Arena* arena) {
5337
5860
  const upb_MiniTableField field = {5, UPB_SIZE(20, 64), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5861
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5338
5862
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5339
5863
  &field, arena);
5340
5864
  if (size) {
@@ -5348,6 +5872,7 @@ UPB_INLINE void google_protobuf_FileDescriptorProto_clear_service(google_protobu
5348
5872
  }
5349
5873
  UPB_INLINE const google_protobuf_ServiceDescriptorProto* const* google_protobuf_FileDescriptorProto_service(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5350
5874
  const upb_MiniTableField field = {6, UPB_SIZE(24, 72), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5875
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceDescriptorProto_msg_init);
5351
5876
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5352
5877
  if (arr) {
5353
5878
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5359,6 +5884,7 @@ UPB_INLINE const google_protobuf_ServiceDescriptorProto* const* google_protobuf_
5359
5884
  }
5360
5885
  UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_service_upb_array(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5361
5886
  const upb_MiniTableField field = {6, UPB_SIZE(24, 72), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5887
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceDescriptorProto_msg_init);
5362
5888
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5363
5889
  if (size) {
5364
5890
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5367,6 +5893,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_service_upb_arr
5367
5893
  }
5368
5894
  UPB_INLINE upb_Array* _google_protobuf_FileDescriptorProto_service_mutable_upb_array(google_protobuf_FileDescriptorProto* msg, size_t* size, upb_Arena* arena) {
5369
5895
  const upb_MiniTableField field = {6, UPB_SIZE(24, 72), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5896
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceDescriptorProto_msg_init);
5370
5897
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5371
5898
  &field, arena);
5372
5899
  if (size) {
@@ -5380,6 +5907,7 @@ UPB_INLINE void google_protobuf_FileDescriptorProto_clear_extension(google_proto
5380
5907
  }
5381
5908
  UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_FileDescriptorProto_extension(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5382
5909
  const upb_MiniTableField field = {7, UPB_SIZE(28, 80), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5910
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5383
5911
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5384
5912
  if (arr) {
5385
5913
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5391,6 +5919,7 @@ UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_Fi
5391
5919
  }
5392
5920
  UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_extension_upb_array(const google_protobuf_FileDescriptorProto* msg, size_t* size) {
5393
5921
  const upb_MiniTableField field = {7, UPB_SIZE(28, 80), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5922
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5394
5923
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5395
5924
  if (size) {
5396
5925
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5399,6 +5928,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FileDescriptorProto_extension_upb_a
5399
5928
  }
5400
5929
  UPB_INLINE upb_Array* _google_protobuf_FileDescriptorProto_extension_mutable_upb_array(google_protobuf_FileDescriptorProto* msg, size_t* size, upb_Arena* arena) {
5401
5930
  const upb_MiniTableField field = {7, UPB_SIZE(28, 80), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5931
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5402
5932
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5403
5933
  &field, arena);
5404
5934
  if (size) {
@@ -5414,6 +5944,7 @@ UPB_INLINE const google_protobuf_FileOptions* google_protobuf_FileDescriptorProt
5414
5944
  const google_protobuf_FileOptions* default_val = NULL;
5415
5945
  const google_protobuf_FileOptions* ret;
5416
5946
  const upb_MiniTableField field = {8, UPB_SIZE(32, 88), 66, 4, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5947
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileOptions_msg_init);
5417
5948
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
5418
5949
  &default_val, &ret);
5419
5950
  return ret;
@@ -5430,6 +5961,7 @@ UPB_INLINE const google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorP
5430
5961
  const google_protobuf_SourceCodeInfo* default_val = NULL;
5431
5962
  const google_protobuf_SourceCodeInfo* ret;
5432
5963
  const upb_MiniTableField field = {9, UPB_SIZE(36, 96), 67, 5, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
5964
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo_msg_init);
5433
5965
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
5434
5966
  &default_val, &ret);
5435
5967
  return ret;
@@ -5573,6 +6105,7 @@ UPB_INLINE bool google_protobuf_FileDescriptorProto_add_dependency(google_protob
5573
6105
  }
5574
6106
  UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_FileDescriptorProto_mutable_message_type(google_protobuf_FileDescriptorProto* msg, size_t* size) {
5575
6107
  upb_MiniTableField field = {4, UPB_SIZE(16, 56), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6108
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5576
6109
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
5577
6110
  if (arr) {
5578
6111
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5589,6 +6122,7 @@ UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_FileDescriptorProto
5589
6122
  }
5590
6123
  UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_FileDescriptorProto_add_message_type(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
5591
6124
  upb_MiniTableField field = {4, UPB_SIZE(16, 56), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6125
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5592
6126
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
5593
6127
  UPB_UPCAST(msg), &field, arena);
5594
6128
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -5603,6 +6137,7 @@ UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_FileDescripto
5603
6137
  }
5604
6138
  UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_FileDescriptorProto_mutable_enum_type(google_protobuf_FileDescriptorProto* msg, size_t* size) {
5605
6139
  upb_MiniTableField field = {5, UPB_SIZE(20, 64), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6140
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5606
6141
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
5607
6142
  if (arr) {
5608
6143
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5619,6 +6154,7 @@ UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_FileDescriptorP
5619
6154
  }
5620
6155
  UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_FileDescriptorProto_add_enum_type(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
5621
6156
  upb_MiniTableField field = {5, UPB_SIZE(20, 64), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6157
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5622
6158
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
5623
6159
  UPB_UPCAST(msg), &field, arena);
5624
6160
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -5633,6 +6169,7 @@ UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_FileDescr
5633
6169
  }
5634
6170
  UPB_INLINE google_protobuf_ServiceDescriptorProto** google_protobuf_FileDescriptorProto_mutable_service(google_protobuf_FileDescriptorProto* msg, size_t* size) {
5635
6171
  upb_MiniTableField field = {6, UPB_SIZE(24, 72), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6172
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceDescriptorProto_msg_init);
5636
6173
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
5637
6174
  if (arr) {
5638
6175
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5649,6 +6186,7 @@ UPB_INLINE google_protobuf_ServiceDescriptorProto** google_protobuf_FileDescript
5649
6186
  }
5650
6187
  UPB_INLINE struct google_protobuf_ServiceDescriptorProto* google_protobuf_FileDescriptorProto_add_service(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
5651
6188
  upb_MiniTableField field = {6, UPB_SIZE(24, 72), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6189
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceDescriptorProto_msg_init);
5652
6190
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
5653
6191
  UPB_UPCAST(msg), &field, arena);
5654
6192
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -5663,6 +6201,7 @@ UPB_INLINE struct google_protobuf_ServiceDescriptorProto* google_protobuf_FileDe
5663
6201
  }
5664
6202
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_FileDescriptorProto_mutable_extension(google_protobuf_FileDescriptorProto* msg, size_t* size) {
5665
6203
  upb_MiniTableField field = {7, UPB_SIZE(28, 80), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6204
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5666
6205
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
5667
6206
  if (arr) {
5668
6207
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5679,6 +6218,7 @@ UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_FileDescriptor
5679
6218
  }
5680
6219
  UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_FileDescriptorProto_add_extension(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
5681
6220
  upb_MiniTableField field = {7, UPB_SIZE(28, 80), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6221
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5682
6222
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
5683
6223
  UPB_UPCAST(msg), &field, arena);
5684
6224
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -5693,6 +6233,7 @@ UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_FileDesc
5693
6233
  }
5694
6234
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_options(google_protobuf_FileDescriptorProto *msg, google_protobuf_FileOptions* value) {
5695
6235
  const upb_MiniTableField field = {8, UPB_SIZE(32, 88), 66, 4, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6236
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FileOptions_msg_init);
5696
6237
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
5697
6238
  }
5698
6239
  UPB_INLINE struct google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_mutable_options(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
@@ -5705,6 +6246,7 @@ UPB_INLINE struct google_protobuf_FileOptions* google_protobuf_FileDescriptorPro
5705
6246
  }
5706
6247
  UPB_INLINE void google_protobuf_FileDescriptorProto_set_source_code_info(google_protobuf_FileDescriptorProto *msg, google_protobuf_SourceCodeInfo* value) {
5707
6248
  const upb_MiniTableField field = {9, UPB_SIZE(36, 96), 67, 5, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6249
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo_msg_init);
5708
6250
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
5709
6251
  }
5710
6252
  UPB_INLINE struct google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_mutable_source_code_info(google_protobuf_FileDescriptorProto* msg, upb_Arena* arena) {
@@ -5838,6 +6380,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_field(google_protobuf_Desc
5838
6380
  }
5839
6381
  UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_field(const google_protobuf_DescriptorProto* msg, size_t* size) {
5840
6382
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6383
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5841
6384
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5842
6385
  if (arr) {
5843
6386
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5849,6 +6392,7 @@ UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_De
5849
6392
  }
5850
6393
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_field_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
5851
6394
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6395
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5852
6396
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5853
6397
  if (size) {
5854
6398
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5857,6 +6401,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_field_upb_array(con
5857
6401
  }
5858
6402
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_field_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
5859
6403
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6404
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5860
6405
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5861
6406
  &field, arena);
5862
6407
  if (size) {
@@ -5870,6 +6415,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_nested_type(google_protobu
5870
6415
  }
5871
6416
  UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_DescriptorProto_nested_type(const google_protobuf_DescriptorProto* msg, size_t* size) {
5872
6417
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6418
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5873
6419
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5874
6420
  if (arr) {
5875
6421
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5881,6 +6427,7 @@ UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_Descrip
5881
6427
  }
5882
6428
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_nested_type_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
5883
6429
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6430
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5884
6431
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5885
6432
  if (size) {
5886
6433
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5889,6 +6436,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_nested_type_upb_arr
5889
6436
  }
5890
6437
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_nested_type_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
5891
6438
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6439
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
5892
6440
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5893
6441
  &field, arena);
5894
6442
  if (size) {
@@ -5902,6 +6450,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_enum_type(google_protobuf_
5902
6450
  }
5903
6451
  UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_DescriptorProto_enum_type(const google_protobuf_DescriptorProto* msg, size_t* size) {
5904
6452
  const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6453
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5905
6454
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5906
6455
  if (arr) {
5907
6456
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5913,6 +6462,7 @@ UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_Des
5913
6462
  }
5914
6463
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_enum_type_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
5915
6464
  const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6465
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5916
6466
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5917
6467
  if (size) {
5918
6468
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5921,6 +6471,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_enum_type_upb_array
5921
6471
  }
5922
6472
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_enum_type_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
5923
6473
  const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6474
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
5924
6475
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5925
6476
  &field, arena);
5926
6477
  if (size) {
@@ -5934,6 +6485,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_extension_range(google_pro
5934
6485
  }
5935
6486
  UPB_INLINE const google_protobuf_DescriptorProto_ExtensionRange* const* google_protobuf_DescriptorProto_extension_range(const google_protobuf_DescriptorProto* msg, size_t* size) {
5936
6487
  const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6488
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ExtensionRange_msg_init);
5937
6489
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5938
6490
  if (arr) {
5939
6491
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5945,6 +6497,7 @@ UPB_INLINE const google_protobuf_DescriptorProto_ExtensionRange* const* google_p
5945
6497
  }
5946
6498
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_extension_range_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
5947
6499
  const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6500
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ExtensionRange_msg_init);
5948
6501
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5949
6502
  if (size) {
5950
6503
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5953,6 +6506,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_extension_range_upb
5953
6506
  }
5954
6507
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_extension_range_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
5955
6508
  const upb_MiniTableField field = {5, UPB_SIZE(24, 56), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6509
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ExtensionRange_msg_init);
5956
6510
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5957
6511
  &field, arena);
5958
6512
  if (size) {
@@ -5966,6 +6520,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_extension(google_protobuf_
5966
6520
  }
5967
6521
  UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_extension(const google_protobuf_DescriptorProto* msg, size_t* size) {
5968
6522
  const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 0, 4, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6523
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5969
6524
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5970
6525
  if (arr) {
5971
6526
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -5977,6 +6532,7 @@ UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_De
5977
6532
  }
5978
6533
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_extension_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
5979
6534
  const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 0, 4, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6535
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5980
6536
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
5981
6537
  if (size) {
5982
6538
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -5985,6 +6541,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_extension_upb_array
5985
6541
  }
5986
6542
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_extension_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
5987
6543
  const upb_MiniTableField field = {6, UPB_SIZE(28, 64), 0, 4, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6544
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
5988
6545
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
5989
6546
  &field, arena);
5990
6547
  if (size) {
@@ -6000,6 +6557,7 @@ UPB_INLINE const google_protobuf_MessageOptions* google_protobuf_DescriptorProto
6000
6557
  const google_protobuf_MessageOptions* default_val = NULL;
6001
6558
  const google_protobuf_MessageOptions* ret;
6002
6559
  const upb_MiniTableField field = {7, UPB_SIZE(32, 72), 65, 5, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6560
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MessageOptions_msg_init);
6003
6561
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
6004
6562
  &default_val, &ret);
6005
6563
  return ret;
@@ -6014,6 +6572,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_oneof_decl(google_protobuf
6014
6572
  }
6015
6573
  UPB_INLINE const google_protobuf_OneofDescriptorProto* const* google_protobuf_DescriptorProto_oneof_decl(const google_protobuf_DescriptorProto* msg, size_t* size) {
6016
6574
  const upb_MiniTableField field = {8, UPB_SIZE(36, 80), 0, 6, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6575
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofDescriptorProto_msg_init);
6017
6576
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6018
6577
  if (arr) {
6019
6578
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6025,6 +6584,7 @@ UPB_INLINE const google_protobuf_OneofDescriptorProto* const* google_protobuf_De
6025
6584
  }
6026
6585
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_oneof_decl_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
6027
6586
  const upb_MiniTableField field = {8, UPB_SIZE(36, 80), 0, 6, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6587
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofDescriptorProto_msg_init);
6028
6588
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6029
6589
  if (size) {
6030
6590
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -6033,6 +6593,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_oneof_decl_upb_arra
6033
6593
  }
6034
6594
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_oneof_decl_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
6035
6595
  const upb_MiniTableField field = {8, UPB_SIZE(36, 80), 0, 6, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6596
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofDescriptorProto_msg_init);
6036
6597
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
6037
6598
  &field, arena);
6038
6599
  if (size) {
@@ -6046,6 +6607,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_clear_reserved_range(google_prot
6046
6607
  }
6047
6608
  UPB_INLINE const google_protobuf_DescriptorProto_ReservedRange* const* google_protobuf_DescriptorProto_reserved_range(const google_protobuf_DescriptorProto* msg, size_t* size) {
6048
6609
  const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 0, 7, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6610
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ReservedRange_msg_init);
6049
6611
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6050
6612
  if (arr) {
6051
6613
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6057,6 +6619,7 @@ UPB_INLINE const google_protobuf_DescriptorProto_ReservedRange* const* google_pr
6057
6619
  }
6058
6620
  UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_reserved_range_upb_array(const google_protobuf_DescriptorProto* msg, size_t* size) {
6059
6621
  const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 0, 7, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6622
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ReservedRange_msg_init);
6060
6623
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6061
6624
  if (size) {
6062
6625
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -6065,6 +6628,7 @@ UPB_INLINE const upb_Array* _google_protobuf_DescriptorProto_reserved_range_upb_
6065
6628
  }
6066
6629
  UPB_INLINE upb_Array* _google_protobuf_DescriptorProto_reserved_range_mutable_upb_array(google_protobuf_DescriptorProto* msg, size_t* size, upb_Arena* arena) {
6067
6630
  const upb_MiniTableField field = {9, UPB_SIZE(40, 88), 0, 7, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6631
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ReservedRange_msg_init);
6068
6632
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
6069
6633
  &field, arena);
6070
6634
  if (size) {
@@ -6111,6 +6675,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_set_name(google_protobuf_Descrip
6111
6675
  }
6112
6676
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_mutable_field(google_protobuf_DescriptorProto* msg, size_t* size) {
6113
6677
  upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6678
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
6114
6679
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6115
6680
  if (arr) {
6116
6681
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6127,6 +6692,7 @@ UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProt
6127
6692
  }
6128
6693
  UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_DescriptorProto_add_field(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6129
6694
  upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6695
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
6130
6696
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6131
6697
  UPB_UPCAST(msg), &field, arena);
6132
6698
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6141,6 +6707,7 @@ UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_Descript
6141
6707
  }
6142
6708
  UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_DescriptorProto_mutable_nested_type(google_protobuf_DescriptorProto* msg, size_t* size) {
6143
6709
  upb_MiniTableField field = {3, UPB_SIZE(16, 40), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6710
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
6144
6711
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6145
6712
  if (arr) {
6146
6713
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6157,6 +6724,7 @@ UPB_INLINE google_protobuf_DescriptorProto** google_protobuf_DescriptorProto_res
6157
6724
  }
6158
6725
  UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_DescriptorProto_add_nested_type(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6159
6726
  upb_MiniTableField field = {3, UPB_SIZE(16, 40), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6727
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto_msg_init);
6160
6728
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6161
6729
  UPB_UPCAST(msg), &field, arena);
6162
6730
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6171,6 +6739,7 @@ UPB_INLINE struct google_protobuf_DescriptorProto* google_protobuf_DescriptorPro
6171
6739
  }
6172
6740
  UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_DescriptorProto_mutable_enum_type(google_protobuf_DescriptorProto* msg, size_t* size) {
6173
6741
  upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6742
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
6174
6743
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6175
6744
  if (arr) {
6176
6745
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6187,6 +6756,7 @@ UPB_INLINE google_protobuf_EnumDescriptorProto** google_protobuf_DescriptorProto
6187
6756
  }
6188
6757
  UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_DescriptorProto_add_enum_type(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6189
6758
  upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6759
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto_msg_init);
6190
6760
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6191
6761
  UPB_UPCAST(msg), &field, arena);
6192
6762
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6201,6 +6771,7 @@ UPB_INLINE struct google_protobuf_EnumDescriptorProto* google_protobuf_Descripto
6201
6771
  }
6202
6772
  UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange** google_protobuf_DescriptorProto_mutable_extension_range(google_protobuf_DescriptorProto* msg, size_t* size) {
6203
6773
  upb_MiniTableField field = {5, UPB_SIZE(24, 56), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6774
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ExtensionRange_msg_init);
6204
6775
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6205
6776
  if (arr) {
6206
6777
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6217,6 +6788,7 @@ UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange** google_protobuf_Desc
6217
6788
  }
6218
6789
  UPB_INLINE struct google_protobuf_DescriptorProto_ExtensionRange* google_protobuf_DescriptorProto_add_extension_range(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6219
6790
  upb_MiniTableField field = {5, UPB_SIZE(24, 56), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6791
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ExtensionRange_msg_init);
6220
6792
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6221
6793
  UPB_UPCAST(msg), &field, arena);
6222
6794
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6231,6 +6803,7 @@ UPB_INLINE struct google_protobuf_DescriptorProto_ExtensionRange* google_protobu
6231
6803
  }
6232
6804
  UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProto_mutable_extension(google_protobuf_DescriptorProto* msg, size_t* size) {
6233
6805
  upb_MiniTableField field = {6, UPB_SIZE(28, 64), 0, 4, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6806
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
6234
6807
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6235
6808
  if (arr) {
6236
6809
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6247,6 +6820,7 @@ UPB_INLINE google_protobuf_FieldDescriptorProto** google_protobuf_DescriptorProt
6247
6820
  }
6248
6821
  UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_DescriptorProto_add_extension(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6249
6822
  upb_MiniTableField field = {6, UPB_SIZE(28, 64), 0, 4, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6823
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldDescriptorProto_msg_init);
6250
6824
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6251
6825
  UPB_UPCAST(msg), &field, arena);
6252
6826
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6261,6 +6835,7 @@ UPB_INLINE struct google_protobuf_FieldDescriptorProto* google_protobuf_Descript
6261
6835
  }
6262
6836
  UPB_INLINE void google_protobuf_DescriptorProto_set_options(google_protobuf_DescriptorProto *msg, google_protobuf_MessageOptions* value) {
6263
6837
  const upb_MiniTableField field = {7, UPB_SIZE(32, 72), 65, 5, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6838
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MessageOptions_msg_init);
6264
6839
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
6265
6840
  }
6266
6841
  UPB_INLINE struct google_protobuf_MessageOptions* google_protobuf_DescriptorProto_mutable_options(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
@@ -6273,6 +6848,7 @@ UPB_INLINE struct google_protobuf_MessageOptions* google_protobuf_DescriptorProt
6273
6848
  }
6274
6849
  UPB_INLINE google_protobuf_OneofDescriptorProto** google_protobuf_DescriptorProto_mutable_oneof_decl(google_protobuf_DescriptorProto* msg, size_t* size) {
6275
6850
  upb_MiniTableField field = {8, UPB_SIZE(36, 80), 0, 6, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6851
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofDescriptorProto_msg_init);
6276
6852
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6277
6853
  if (arr) {
6278
6854
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6289,6 +6865,7 @@ UPB_INLINE google_protobuf_OneofDescriptorProto** google_protobuf_DescriptorProt
6289
6865
  }
6290
6866
  UPB_INLINE struct google_protobuf_OneofDescriptorProto* google_protobuf_DescriptorProto_add_oneof_decl(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6291
6867
  upb_MiniTableField field = {8, UPB_SIZE(36, 80), 0, 6, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6868
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofDescriptorProto_msg_init);
6292
6869
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6293
6870
  UPB_UPCAST(msg), &field, arena);
6294
6871
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6303,6 +6880,7 @@ UPB_INLINE struct google_protobuf_OneofDescriptorProto* google_protobuf_Descript
6303
6880
  }
6304
6881
  UPB_INLINE google_protobuf_DescriptorProto_ReservedRange** google_protobuf_DescriptorProto_mutable_reserved_range(google_protobuf_DescriptorProto* msg, size_t* size) {
6305
6882
  upb_MiniTableField field = {9, UPB_SIZE(40, 88), 0, 7, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6883
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ReservedRange_msg_init);
6306
6884
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6307
6885
  if (arr) {
6308
6886
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6319,6 +6897,7 @@ UPB_INLINE google_protobuf_DescriptorProto_ReservedRange** google_protobuf_Descr
6319
6897
  }
6320
6898
  UPB_INLINE struct google_protobuf_DescriptorProto_ReservedRange* google_protobuf_DescriptorProto_add_reserved_range(google_protobuf_DescriptorProto* msg, upb_Arena* arena) {
6321
6899
  upb_MiniTableField field = {9, UPB_SIZE(40, 88), 0, 7, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
6900
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__DescriptorProto__ReservedRange_msg_init);
6322
6901
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6323
6902
  UPB_UPCAST(msg), &field, arena);
6324
6903
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6436,6 +7015,7 @@ UPB_INLINE const google_protobuf_ExtensionRangeOptions* google_protobuf_Descript
6436
7015
  const google_protobuf_ExtensionRangeOptions* default_val = NULL;
6437
7016
  const google_protobuf_ExtensionRangeOptions* ret;
6438
7017
  const upb_MiniTableField field = {3, UPB_SIZE(20, 24), 66, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7018
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions_msg_init);
6439
7019
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
6440
7020
  &default_val, &ret);
6441
7021
  return ret;
@@ -6455,6 +7035,7 @@ UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_set_end(google_pr
6455
7035
  }
6456
7036
  UPB_INLINE void google_protobuf_DescriptorProto_ExtensionRange_set_options(google_protobuf_DescriptorProto_ExtensionRange *msg, google_protobuf_ExtensionRangeOptions* value) {
6457
7037
  const upb_MiniTableField field = {3, UPB_SIZE(20, 24), 66, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7038
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions_msg_init);
6458
7039
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
6459
7040
  }
6460
7041
  UPB_INLINE struct google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_mutable_options(google_protobuf_DescriptorProto_ExtensionRange* msg, upb_Arena* arena) {
@@ -6586,6 +7167,7 @@ UPB_INLINE void google_protobuf_ExtensionRangeOptions_clear_declaration(google_p
6586
7167
  }
6587
7168
  UPB_INLINE const google_protobuf_ExtensionRangeOptions_Declaration* const* google_protobuf_ExtensionRangeOptions_declaration(const google_protobuf_ExtensionRangeOptions* msg, size_t* size) {
6588
7169
  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)};
7170
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions__Declaration_msg_init);
6589
7171
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6590
7172
  if (arr) {
6591
7173
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6597,6 +7179,7 @@ UPB_INLINE const google_protobuf_ExtensionRangeOptions_Declaration* const* googl
6597
7179
  }
6598
7180
  UPB_INLINE const upb_Array* _google_protobuf_ExtensionRangeOptions_declaration_upb_array(const google_protobuf_ExtensionRangeOptions* msg, size_t* size) {
6599
7181
  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)};
7182
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions__Declaration_msg_init);
6600
7183
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6601
7184
  if (size) {
6602
7185
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -6605,6 +7188,7 @@ UPB_INLINE const upb_Array* _google_protobuf_ExtensionRangeOptions_declaration_u
6605
7188
  }
6606
7189
  UPB_INLINE upb_Array* _google_protobuf_ExtensionRangeOptions_declaration_mutable_upb_array(google_protobuf_ExtensionRangeOptions* msg, size_t* size, upb_Arena* arena) {
6607
7190
  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)};
7191
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions__Declaration_msg_init);
6608
7192
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
6609
7193
  &field, arena);
6610
7194
  if (size) {
@@ -6636,6 +7220,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_ExtensionRangeOptio
6636
7220
  const google_protobuf_FeatureSet* default_val = NULL;
6637
7221
  const google_protobuf_FeatureSet* ret;
6638
7222
  const upb_MiniTableField field = {50, UPB_SIZE(20, 24), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7223
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
6639
7224
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
6640
7225
  &default_val, &ret);
6641
7226
  return ret;
@@ -6650,6 +7235,7 @@ UPB_INLINE void google_protobuf_ExtensionRangeOptions_clear_uninterpreted_option
6650
7235
  }
6651
7236
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ExtensionRangeOptions_uninterpreted_option(const google_protobuf_ExtensionRangeOptions* msg, size_t* size) {
6652
7237
  const upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7238
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
6653
7239
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6654
7240
  if (arr) {
6655
7241
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6661,6 +7247,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Ext
6661
7247
  }
6662
7248
  UPB_INLINE const upb_Array* _google_protobuf_ExtensionRangeOptions_uninterpreted_option_upb_array(const google_protobuf_ExtensionRangeOptions* msg, size_t* size) {
6663
7249
  const upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7250
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
6664
7251
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
6665
7252
  if (size) {
6666
7253
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -6669,6 +7256,7 @@ UPB_INLINE const upb_Array* _google_protobuf_ExtensionRangeOptions_uninterpreted
6669
7256
  }
6670
7257
  UPB_INLINE upb_Array* _google_protobuf_ExtensionRangeOptions_uninterpreted_option_mutable_upb_array(google_protobuf_ExtensionRangeOptions* msg, size_t* size, upb_Arena* arena) {
6671
7258
  const upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7259
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
6672
7260
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
6673
7261
  &field, arena);
6674
7262
  if (size) {
@@ -6679,6 +7267,7 @@ UPB_INLINE upb_Array* _google_protobuf_ExtensionRangeOptions_uninterpreted_optio
6679
7267
 
6680
7268
  UPB_INLINE google_protobuf_ExtensionRangeOptions_Declaration** google_protobuf_ExtensionRangeOptions_mutable_declaration(google_protobuf_ExtensionRangeOptions* msg, size_t* size) {
6681
7269
  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)};
7270
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions__Declaration_msg_init);
6682
7271
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6683
7272
  if (arr) {
6684
7273
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6695,6 +7284,7 @@ UPB_INLINE google_protobuf_ExtensionRangeOptions_Declaration** google_protobuf_E
6695
7284
  }
6696
7285
  UPB_INLINE struct google_protobuf_ExtensionRangeOptions_Declaration* google_protobuf_ExtensionRangeOptions_add_declaration(google_protobuf_ExtensionRangeOptions* msg, upb_Arena* arena) {
6697
7286
  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)};
7287
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ExtensionRangeOptions__Declaration_msg_init);
6698
7288
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6699
7289
  UPB_UPCAST(msg), &field, arena);
6700
7290
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -6713,6 +7303,7 @@ UPB_INLINE void google_protobuf_ExtensionRangeOptions_set_verification(google_pr
6713
7303
  }
6714
7304
  UPB_INLINE void google_protobuf_ExtensionRangeOptions_set_features(google_protobuf_ExtensionRangeOptions *msg, google_protobuf_FeatureSet* value) {
6715
7305
  const upb_MiniTableField field = {50, UPB_SIZE(20, 24), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7306
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
6716
7307
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
6717
7308
  }
6718
7309
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_ExtensionRangeOptions_mutable_features(google_protobuf_ExtensionRangeOptions* msg, upb_Arena* arena) {
@@ -6725,6 +7316,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_ExtensionRangeOpti
6725
7316
  }
6726
7317
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ExtensionRangeOptions_mutable_uninterpreted_option(google_protobuf_ExtensionRangeOptions* msg, size_t* size) {
6727
7318
  upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7319
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
6728
7320
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
6729
7321
  if (arr) {
6730
7322
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -6741,6 +7333,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ExtensionRangeO
6741
7333
  }
6742
7334
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ExtensionRangeOptions_add_uninterpreted_option(google_protobuf_ExtensionRangeOptions* msg, upb_Arena* arena) {
6743
7335
  upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7336
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
6744
7337
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
6745
7338
  UPB_UPCAST(msg), &field, arena);
6746
7339
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -7048,6 +7641,7 @@ UPB_INLINE const google_protobuf_FieldOptions* google_protobuf_FieldDescriptorPr
7048
7641
  const google_protobuf_FieldOptions* default_val = NULL;
7049
7642
  const google_protobuf_FieldOptions* ret;
7050
7643
  const upb_MiniTableField field = {8, UPB_SIZE(24, 96), 71, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7644
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions_msg_init);
7051
7645
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
7052
7646
  &default_val, &ret);
7053
7647
  return ret;
@@ -7135,6 +7729,7 @@ UPB_INLINE void google_protobuf_FieldDescriptorProto_set_default_value(google_pr
7135
7729
  }
7136
7730
  UPB_INLINE void google_protobuf_FieldDescriptorProto_set_options(google_protobuf_FieldDescriptorProto *msg, google_protobuf_FieldOptions* value) {
7137
7731
  const upb_MiniTableField field = {8, UPB_SIZE(24, 96), 71, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7732
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions_msg_init);
7138
7733
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
7139
7734
  }
7140
7735
  UPB_INLINE struct google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_mutable_options(google_protobuf_FieldDescriptorProto* msg, upb_Arena* arena) {
@@ -7218,6 +7813,7 @@ UPB_INLINE const google_protobuf_OneofOptions* google_protobuf_OneofDescriptorPr
7218
7813
  const google_protobuf_OneofOptions* default_val = NULL;
7219
7814
  const google_protobuf_OneofOptions* ret;
7220
7815
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7816
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofOptions_msg_init);
7221
7817
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
7222
7818
  &default_val, &ret);
7223
7819
  return ret;
@@ -7233,6 +7829,7 @@ UPB_INLINE void google_protobuf_OneofDescriptorProto_set_name(google_protobuf_On
7233
7829
  }
7234
7830
  UPB_INLINE void google_protobuf_OneofDescriptorProto_set_options(google_protobuf_OneofDescriptorProto *msg, google_protobuf_OneofOptions* value) {
7235
7831
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7832
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__OneofOptions_msg_init);
7236
7833
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
7237
7834
  }
7238
7835
  UPB_INLINE struct google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_mutable_options(google_protobuf_OneofDescriptorProto* msg, upb_Arena* arena) {
@@ -7302,6 +7899,7 @@ UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_value(google_protobuf_
7302
7899
  }
7303
7900
  UPB_INLINE const google_protobuf_EnumValueDescriptorProto* const* google_protobuf_EnumDescriptorProto_value(const google_protobuf_EnumDescriptorProto* msg, size_t* size) {
7304
7901
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7902
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueDescriptorProto_msg_init);
7305
7903
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
7306
7904
  if (arr) {
7307
7905
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -7313,6 +7911,7 @@ UPB_INLINE const google_protobuf_EnumValueDescriptorProto* const* google_protobu
7313
7911
  }
7314
7912
  UPB_INLINE const upb_Array* _google_protobuf_EnumDescriptorProto_value_upb_array(const google_protobuf_EnumDescriptorProto* msg, size_t* size) {
7315
7913
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7914
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueDescriptorProto_msg_init);
7316
7915
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
7317
7916
  if (size) {
7318
7917
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -7321,6 +7920,7 @@ UPB_INLINE const upb_Array* _google_protobuf_EnumDescriptorProto_value_upb_array
7321
7920
  }
7322
7921
  UPB_INLINE upb_Array* _google_protobuf_EnumDescriptorProto_value_mutable_upb_array(google_protobuf_EnumDescriptorProto* msg, size_t* size, upb_Arena* arena) {
7323
7922
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7923
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueDescriptorProto_msg_init);
7324
7924
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
7325
7925
  &field, arena);
7326
7926
  if (size) {
@@ -7336,6 +7936,7 @@ UPB_INLINE const google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProt
7336
7936
  const google_protobuf_EnumOptions* default_val = NULL;
7337
7937
  const google_protobuf_EnumOptions* ret;
7338
7938
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7939
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumOptions_msg_init);
7339
7940
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
7340
7941
  &default_val, &ret);
7341
7942
  return ret;
@@ -7350,6 +7951,7 @@ UPB_INLINE void google_protobuf_EnumDescriptorProto_clear_reserved_range(google_
7350
7951
  }
7351
7952
  UPB_INLINE const google_protobuf_EnumDescriptorProto_EnumReservedRange* const* google_protobuf_EnumDescriptorProto_reserved_range(const google_protobuf_EnumDescriptorProto* msg, size_t* size) {
7352
7953
  const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7954
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init);
7353
7955
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
7354
7956
  if (arr) {
7355
7957
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -7361,6 +7963,7 @@ UPB_INLINE const google_protobuf_EnumDescriptorProto_EnumReservedRange* const* g
7361
7963
  }
7362
7964
  UPB_INLINE const upb_Array* _google_protobuf_EnumDescriptorProto_reserved_range_upb_array(const google_protobuf_EnumDescriptorProto* msg, size_t* size) {
7363
7965
  const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7966
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init);
7364
7967
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
7365
7968
  if (size) {
7366
7969
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -7369,6 +7972,7 @@ UPB_INLINE const upb_Array* _google_protobuf_EnumDescriptorProto_reserved_range_
7369
7972
  }
7370
7973
  UPB_INLINE upb_Array* _google_protobuf_EnumDescriptorProto_reserved_range_mutable_upb_array(google_protobuf_EnumDescriptorProto* msg, size_t* size, upb_Arena* arena) {
7371
7974
  const upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
7975
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init);
7372
7976
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
7373
7977
  &field, arena);
7374
7978
  if (size) {
@@ -7415,6 +8019,7 @@ UPB_INLINE void google_protobuf_EnumDescriptorProto_set_name(google_protobuf_Enu
7415
8019
  }
7416
8020
  UPB_INLINE google_protobuf_EnumValueDescriptorProto** google_protobuf_EnumDescriptorProto_mutable_value(google_protobuf_EnumDescriptorProto* msg, size_t* size) {
7417
8021
  upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8022
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueDescriptorProto_msg_init);
7418
8023
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
7419
8024
  if (arr) {
7420
8025
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -7431,6 +8036,7 @@ UPB_INLINE google_protobuf_EnumValueDescriptorProto** google_protobuf_EnumDescri
7431
8036
  }
7432
8037
  UPB_INLINE struct google_protobuf_EnumValueDescriptorProto* google_protobuf_EnumDescriptorProto_add_value(google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena) {
7433
8038
  upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8039
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueDescriptorProto_msg_init);
7434
8040
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
7435
8041
  UPB_UPCAST(msg), &field, arena);
7436
8042
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -7445,6 +8051,7 @@ UPB_INLINE struct google_protobuf_EnumValueDescriptorProto* google_protobuf_Enum
7445
8051
  }
7446
8052
  UPB_INLINE void google_protobuf_EnumDescriptorProto_set_options(google_protobuf_EnumDescriptorProto *msg, google_protobuf_EnumOptions* value) {
7447
8053
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8054
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumOptions_msg_init);
7448
8055
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
7449
8056
  }
7450
8057
  UPB_INLINE struct google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_mutable_options(google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena) {
@@ -7457,6 +8064,7 @@ UPB_INLINE struct google_protobuf_EnumOptions* google_protobuf_EnumDescriptorPro
7457
8064
  }
7458
8065
  UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange** google_protobuf_EnumDescriptorProto_mutable_reserved_range(google_protobuf_EnumDescriptorProto* msg, size_t* size) {
7459
8066
  upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8067
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init);
7460
8068
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
7461
8069
  if (arr) {
7462
8070
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -7473,6 +8081,7 @@ UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange** google_protob
7473
8081
  }
7474
8082
  UPB_INLINE struct google_protobuf_EnumDescriptorProto_EnumReservedRange* google_protobuf_EnumDescriptorProto_add_reserved_range(google_protobuf_EnumDescriptorProto* msg, upb_Arena* arena) {
7475
8083
  upb_MiniTableField field = {4, UPB_SIZE(20, 48), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8084
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumDescriptorProto__EnumReservedRange_msg_init);
7476
8085
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
7477
8086
  UPB_UPCAST(msg), &field, arena);
7478
8087
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -7668,6 +8277,7 @@ UPB_INLINE const google_protobuf_EnumValueOptions* google_protobuf_EnumValueDesc
7668
8277
  const google_protobuf_EnumValueOptions* default_val = NULL;
7669
8278
  const google_protobuf_EnumValueOptions* ret;
7670
8279
  const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 66, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8280
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueOptions_msg_init);
7671
8281
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
7672
8282
  &default_val, &ret);
7673
8283
  return ret;
@@ -7687,6 +8297,7 @@ UPB_INLINE void google_protobuf_EnumValueDescriptorProto_set_number(google_proto
7687
8297
  }
7688
8298
  UPB_INLINE void google_protobuf_EnumValueDescriptorProto_set_options(google_protobuf_EnumValueDescriptorProto *msg, google_protobuf_EnumValueOptions* value) {
7689
8299
  const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 66, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8300
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__EnumValueOptions_msg_init);
7690
8301
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
7691
8302
  }
7692
8303
  UPB_INLINE struct google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_mutable_options(google_protobuf_EnumValueDescriptorProto* msg, upb_Arena* arena) {
@@ -7756,6 +8367,7 @@ UPB_INLINE void google_protobuf_ServiceDescriptorProto_clear_method(google_proto
7756
8367
  }
7757
8368
  UPB_INLINE const google_protobuf_MethodDescriptorProto* const* google_protobuf_ServiceDescriptorProto_method(const google_protobuf_ServiceDescriptorProto* msg, size_t* size) {
7758
8369
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8370
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodDescriptorProto_msg_init);
7759
8371
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
7760
8372
  if (arr) {
7761
8373
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -7767,6 +8379,7 @@ UPB_INLINE const google_protobuf_MethodDescriptorProto* const* google_protobuf_S
7767
8379
  }
7768
8380
  UPB_INLINE const upb_Array* _google_protobuf_ServiceDescriptorProto_method_upb_array(const google_protobuf_ServiceDescriptorProto* msg, size_t* size) {
7769
8381
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8382
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodDescriptorProto_msg_init);
7770
8383
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
7771
8384
  if (size) {
7772
8385
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -7775,6 +8388,7 @@ UPB_INLINE const upb_Array* _google_protobuf_ServiceDescriptorProto_method_upb_a
7775
8388
  }
7776
8389
  UPB_INLINE upb_Array* _google_protobuf_ServiceDescriptorProto_method_mutable_upb_array(google_protobuf_ServiceDescriptorProto* msg, size_t* size, upb_Arena* arena) {
7777
8390
  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8391
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodDescriptorProto_msg_init);
7778
8392
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
7779
8393
  &field, arena);
7780
8394
  if (size) {
@@ -7790,6 +8404,7 @@ UPB_INLINE const google_protobuf_ServiceOptions* google_protobuf_ServiceDescript
7790
8404
  const google_protobuf_ServiceOptions* default_val = NULL;
7791
8405
  const google_protobuf_ServiceOptions* ret;
7792
8406
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8407
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceOptions_msg_init);
7793
8408
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
7794
8409
  &default_val, &ret);
7795
8410
  return ret;
@@ -7805,6 +8420,7 @@ UPB_INLINE void google_protobuf_ServiceDescriptorProto_set_name(google_protobuf_
7805
8420
  }
7806
8421
  UPB_INLINE google_protobuf_MethodDescriptorProto** google_protobuf_ServiceDescriptorProto_mutable_method(google_protobuf_ServiceDescriptorProto* msg, size_t* size) {
7807
8422
  upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8423
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodDescriptorProto_msg_init);
7808
8424
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
7809
8425
  if (arr) {
7810
8426
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -7821,6 +8437,7 @@ UPB_INLINE google_protobuf_MethodDescriptorProto** google_protobuf_ServiceDescri
7821
8437
  }
7822
8438
  UPB_INLINE struct google_protobuf_MethodDescriptorProto* google_protobuf_ServiceDescriptorProto_add_method(google_protobuf_ServiceDescriptorProto* msg, upb_Arena* arena) {
7823
8439
  upb_MiniTableField field = {2, UPB_SIZE(12, 32), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8440
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodDescriptorProto_msg_init);
7824
8441
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
7825
8442
  UPB_UPCAST(msg), &field, arena);
7826
8443
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -7835,6 +8452,7 @@ UPB_INLINE struct google_protobuf_MethodDescriptorProto* google_protobuf_Service
7835
8452
  }
7836
8453
  UPB_INLINE void google_protobuf_ServiceDescriptorProto_set_options(google_protobuf_ServiceDescriptorProto *msg, google_protobuf_ServiceOptions* value) {
7837
8454
  const upb_MiniTableField field = {3, UPB_SIZE(16, 40), 65, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8455
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__ServiceOptions_msg_init);
7838
8456
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
7839
8457
  }
7840
8458
  UPB_INLINE struct google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_mutable_options(google_protobuf_ServiceDescriptorProto* msg, upb_Arena* arena) {
@@ -7938,6 +8556,7 @@ UPB_INLINE const google_protobuf_MethodOptions* google_protobuf_MethodDescriptor
7938
8556
  const google_protobuf_MethodOptions* default_val = NULL;
7939
8557
  const google_protobuf_MethodOptions* ret;
7940
8558
  const upb_MiniTableField field = {4, UPB_SIZE(12, 64), 67, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8559
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodOptions_msg_init);
7941
8560
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
7942
8561
  &default_val, &ret);
7943
8562
  return ret;
@@ -7993,6 +8612,7 @@ UPB_INLINE void google_protobuf_MethodDescriptorProto_set_output_type(google_pro
7993
8612
  }
7994
8613
  UPB_INLINE void google_protobuf_MethodDescriptorProto_set_options(google_protobuf_MethodDescriptorProto *msg, google_protobuf_MethodOptions* value) {
7995
8614
  const upb_MiniTableField field = {4, UPB_SIZE(12, 64), 67, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8615
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__MethodOptions_msg_init);
7996
8616
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
7997
8617
  }
7998
8618
  UPB_INLINE struct google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_mutable_options(google_protobuf_MethodDescriptorProto* msg, upb_Arena* arena) {
@@ -8360,6 +8980,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_FileOptions_feature
8360
8980
  const google_protobuf_FeatureSet* default_val = NULL;
8361
8981
  const google_protobuf_FeatureSet* ret;
8362
8982
  const upb_MiniTableField field = {50, UPB_SIZE(24, 184), 83, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8983
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
8363
8984
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
8364
8985
  &default_val, &ret);
8365
8986
  return ret;
@@ -8374,6 +8995,7 @@ UPB_INLINE void google_protobuf_FileOptions_clear_uninterpreted_option(google_pr
8374
8995
  }
8375
8996
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FileOptions_uninterpreted_option(const google_protobuf_FileOptions* msg, size_t* size) {
8376
8997
  const upb_MiniTableField field = {999, UPB_SIZE(28, 192), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
8998
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8377
8999
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
8378
9000
  if (arr) {
8379
9001
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -8385,6 +9007,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Fil
8385
9007
  }
8386
9008
  UPB_INLINE const upb_Array* _google_protobuf_FileOptions_uninterpreted_option_upb_array(const google_protobuf_FileOptions* msg, size_t* size) {
8387
9009
  const upb_MiniTableField field = {999, UPB_SIZE(28, 192), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9010
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8388
9011
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
8389
9012
  if (size) {
8390
9013
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -8393,6 +9016,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FileOptions_uninterpreted_option_up
8393
9016
  }
8394
9017
  UPB_INLINE upb_Array* _google_protobuf_FileOptions_uninterpreted_option_mutable_upb_array(google_protobuf_FileOptions* msg, size_t* size, upb_Arena* arena) {
8395
9018
  const upb_MiniTableField field = {999, UPB_SIZE(28, 192), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9019
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8396
9020
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
8397
9021
  &field, arena);
8398
9022
  if (size) {
@@ -8479,6 +9103,7 @@ UPB_INLINE void google_protobuf_FileOptions_set_ruby_package(google_protobuf_Fil
8479
9103
  }
8480
9104
  UPB_INLINE void google_protobuf_FileOptions_set_features(google_protobuf_FileOptions *msg, google_protobuf_FeatureSet* value) {
8481
9105
  const upb_MiniTableField field = {50, UPB_SIZE(24, 184), 83, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9106
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
8482
9107
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
8483
9108
  }
8484
9109
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FileOptions_mutable_features(google_protobuf_FileOptions* msg, upb_Arena* arena) {
@@ -8491,6 +9116,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FileOptions_mutabl
8491
9116
  }
8492
9117
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FileOptions_mutable_uninterpreted_option(google_protobuf_FileOptions* msg, size_t* size) {
8493
9118
  upb_MiniTableField field = {999, UPB_SIZE(28, 192), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9119
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8494
9120
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
8495
9121
  if (arr) {
8496
9122
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -8507,6 +9133,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FileOptions_res
8507
9133
  }
8508
9134
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FileOptions_add_uninterpreted_option(google_protobuf_FileOptions* msg, upb_Arena* arena) {
8509
9135
  upb_MiniTableField field = {999, UPB_SIZE(28, 192), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9136
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8510
9137
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
8511
9138
  UPB_UPCAST(msg), &field, arena);
8512
9139
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -8644,6 +9271,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_MessageOptions_feat
8644
9271
  const google_protobuf_FeatureSet* default_val = NULL;
8645
9272
  const google_protobuf_FeatureSet* ret;
8646
9273
  const upb_MiniTableField field = {12, 16, 69, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9274
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
8647
9275
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
8648
9276
  &default_val, &ret);
8649
9277
  return ret;
@@ -8658,6 +9286,7 @@ UPB_INLINE void google_protobuf_MessageOptions_clear_uninterpreted_option(google
8658
9286
  }
8659
9287
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MessageOptions_uninterpreted_option(const google_protobuf_MessageOptions* msg, size_t* size) {
8660
9288
  const upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9289
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8661
9290
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
8662
9291
  if (arr) {
8663
9292
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -8669,6 +9298,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Mes
8669
9298
  }
8670
9299
  UPB_INLINE const upb_Array* _google_protobuf_MessageOptions_uninterpreted_option_upb_array(const google_protobuf_MessageOptions* msg, size_t* size) {
8671
9300
  const upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9301
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8672
9302
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
8673
9303
  if (size) {
8674
9304
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -8677,6 +9307,7 @@ UPB_INLINE const upb_Array* _google_protobuf_MessageOptions_uninterpreted_option
8677
9307
  }
8678
9308
  UPB_INLINE upb_Array* _google_protobuf_MessageOptions_uninterpreted_option_mutable_upb_array(google_protobuf_MessageOptions* msg, size_t* size, upb_Arena* arena) {
8679
9309
  const upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9310
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8680
9311
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
8681
9312
  &field, arena);
8682
9313
  if (size) {
@@ -8707,6 +9338,7 @@ UPB_INLINE void google_protobuf_MessageOptions_set_deprecated_legacy_json_field_
8707
9338
  }
8708
9339
  UPB_INLINE void google_protobuf_MessageOptions_set_features(google_protobuf_MessageOptions *msg, google_protobuf_FeatureSet* value) {
8709
9340
  const upb_MiniTableField field = {12, 16, 69, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9341
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
8710
9342
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
8711
9343
  }
8712
9344
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_MessageOptions_mutable_features(google_protobuf_MessageOptions* msg, upb_Arena* arena) {
@@ -8719,6 +9351,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_MessageOptions_mut
8719
9351
  }
8720
9352
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MessageOptions_mutable_uninterpreted_option(google_protobuf_MessageOptions* msg, size_t* size) {
8721
9353
  upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9354
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8722
9355
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
8723
9356
  if (arr) {
8724
9357
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -8735,6 +9368,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MessageOptions_
8735
9368
  }
8736
9369
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MessageOptions_add_uninterpreted_option(google_protobuf_MessageOptions* msg, upb_Arena* arena) {
8737
9370
  upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9371
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
8738
9372
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
8739
9373
  UPB_UPCAST(msg), &field, arena);
8740
9374
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -8966,6 +9600,7 @@ UPB_INLINE void google_protobuf_FieldOptions_clear_edition_defaults(google_proto
8966
9600
  }
8967
9601
  UPB_INLINE const google_protobuf_FieldOptions_EditionDefault* const* google_protobuf_FieldOptions_edition_defaults(const google_protobuf_FieldOptions* msg, size_t* size) {
8968
9602
  const upb_MiniTableField field = {20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9603
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__EditionDefault_msg_init);
8969
9604
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
8970
9605
  if (arr) {
8971
9606
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -8977,6 +9612,7 @@ UPB_INLINE const google_protobuf_FieldOptions_EditionDefault* const* google_prot
8977
9612
  }
8978
9613
  UPB_INLINE const upb_Array* _google_protobuf_FieldOptions_edition_defaults_upb_array(const google_protobuf_FieldOptions* msg, size_t* size) {
8979
9614
  const upb_MiniTableField field = {20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9615
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__EditionDefault_msg_init);
8980
9616
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
8981
9617
  if (size) {
8982
9618
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -8985,6 +9621,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FieldOptions_edition_defaults_upb_a
8985
9621
  }
8986
9622
  UPB_INLINE upb_Array* _google_protobuf_FieldOptions_edition_defaults_mutable_upb_array(google_protobuf_FieldOptions* msg, size_t* size, upb_Arena* arena) {
8987
9623
  const upb_MiniTableField field = {20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9624
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__EditionDefault_msg_init);
8988
9625
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
8989
9626
  &field, arena);
8990
9627
  if (size) {
@@ -9000,6 +9637,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_FieldOptions_featur
9000
9637
  const google_protobuf_FeatureSet* default_val = NULL;
9001
9638
  const google_protobuf_FeatureSet* ret;
9002
9639
  const upb_MiniTableField field = {21, UPB_SIZE(40, 48), 73, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9640
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9003
9641
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9004
9642
  &default_val, &ret);
9005
9643
  return ret;
@@ -9016,6 +9654,7 @@ UPB_INLINE const google_protobuf_FieldOptions_FeatureSupport* google_protobuf_Fi
9016
9654
  const google_protobuf_FieldOptions_FeatureSupport* default_val = NULL;
9017
9655
  const google_protobuf_FieldOptions_FeatureSupport* ret;
9018
9656
  const upb_MiniTableField field = {22, UPB_SIZE(44, 56), 74, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9657
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__FeatureSupport_msg_init);
9019
9658
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9020
9659
  &default_val, &ret);
9021
9660
  return ret;
@@ -9030,6 +9669,7 @@ UPB_INLINE void google_protobuf_FieldOptions_clear_uninterpreted_option(google_p
9030
9669
  }
9031
9670
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FieldOptions_uninterpreted_option(const google_protobuf_FieldOptions* msg, size_t* size) {
9032
9671
  const upb_MiniTableField field = {999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9672
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9033
9673
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9034
9674
  if (arr) {
9035
9675
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9041,6 +9681,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Fie
9041
9681
  }
9042
9682
  UPB_INLINE const upb_Array* _google_protobuf_FieldOptions_uninterpreted_option_upb_array(const google_protobuf_FieldOptions* msg, size_t* size) {
9043
9683
  const upb_MiniTableField field = {999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9684
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9044
9685
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9045
9686
  if (size) {
9046
9687
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -9049,6 +9690,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FieldOptions_uninterpreted_option_u
9049
9690
  }
9050
9691
  UPB_INLINE upb_Array* _google_protobuf_FieldOptions_uninterpreted_option_mutable_upb_array(google_protobuf_FieldOptions* msg, size_t* size, upb_Arena* arena) {
9051
9692
  const upb_MiniTableField field = {999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9693
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9052
9694
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
9053
9695
  &field, arena);
9054
9696
  if (size) {
@@ -9123,6 +9765,7 @@ UPB_INLINE bool google_protobuf_FieldOptions_add_targets(google_protobuf_FieldOp
9123
9765
  }
9124
9766
  UPB_INLINE google_protobuf_FieldOptions_EditionDefault** google_protobuf_FieldOptions_mutable_edition_defaults(google_protobuf_FieldOptions* msg, size_t* size) {
9125
9767
  upb_MiniTableField field = {20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9768
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__EditionDefault_msg_init);
9126
9769
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
9127
9770
  if (arr) {
9128
9771
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9139,6 +9782,7 @@ UPB_INLINE google_protobuf_FieldOptions_EditionDefault** google_protobuf_FieldOp
9139
9782
  }
9140
9783
  UPB_INLINE struct google_protobuf_FieldOptions_EditionDefault* google_protobuf_FieldOptions_add_edition_defaults(google_protobuf_FieldOptions* msg, upb_Arena* arena) {
9141
9784
  upb_MiniTableField field = {20, UPB_SIZE(36, 40), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9785
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__EditionDefault_msg_init);
9142
9786
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
9143
9787
  UPB_UPCAST(msg), &field, arena);
9144
9788
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -9153,6 +9797,7 @@ UPB_INLINE struct google_protobuf_FieldOptions_EditionDefault* google_protobuf_F
9153
9797
  }
9154
9798
  UPB_INLINE void google_protobuf_FieldOptions_set_features(google_protobuf_FieldOptions *msg, google_protobuf_FeatureSet* value) {
9155
9799
  const upb_MiniTableField field = {21, UPB_SIZE(40, 48), 73, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9800
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9156
9801
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
9157
9802
  }
9158
9803
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FieldOptions_mutable_features(google_protobuf_FieldOptions* msg, upb_Arena* arena) {
@@ -9165,6 +9810,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FieldOptions_mutab
9165
9810
  }
9166
9811
  UPB_INLINE void google_protobuf_FieldOptions_set_feature_support(google_protobuf_FieldOptions *msg, google_protobuf_FieldOptions_FeatureSupport* value) {
9167
9812
  const upb_MiniTableField field = {22, UPB_SIZE(44, 56), 74, 2, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9813
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__FeatureSupport_msg_init);
9168
9814
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
9169
9815
  }
9170
9816
  UPB_INLINE struct google_protobuf_FieldOptions_FeatureSupport* google_protobuf_FieldOptions_mutable_feature_support(google_protobuf_FieldOptions* msg, upb_Arena* arena) {
@@ -9177,6 +9823,7 @@ UPB_INLINE struct google_protobuf_FieldOptions_FeatureSupport* google_protobuf_F
9177
9823
  }
9178
9824
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FieldOptions_mutable_uninterpreted_option(google_protobuf_FieldOptions* msg, size_t* size) {
9179
9825
  upb_MiniTableField field = {999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9826
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9180
9827
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
9181
9828
  if (arr) {
9182
9829
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9193,6 +9840,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_FieldOptions_re
9193
9840
  }
9194
9841
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_FieldOptions_add_uninterpreted_option(google_protobuf_FieldOptions* msg, upb_Arena* arena) {
9195
9842
  upb_MiniTableField field = {999, UPB_SIZE(48, 64), 0, 3, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
9843
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9196
9844
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
9197
9845
  UPB_UPCAST(msg), &field, arena);
9198
9846
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -9446,6 +10094,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_OneofOptions_featur
9446
10094
  const google_protobuf_FeatureSet* default_val = NULL;
9447
10095
  const google_protobuf_FeatureSet* ret;
9448
10096
  const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10097
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9449
10098
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9450
10099
  &default_val, &ret);
9451
10100
  return ret;
@@ -9460,6 +10109,7 @@ UPB_INLINE void google_protobuf_OneofOptions_clear_uninterpreted_option(google_p
9460
10109
  }
9461
10110
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_OneofOptions_uninterpreted_option(const google_protobuf_OneofOptions* msg, size_t* size) {
9462
10111
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10112
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9463
10113
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9464
10114
  if (arr) {
9465
10115
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9471,6 +10121,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_One
9471
10121
  }
9472
10122
  UPB_INLINE const upb_Array* _google_protobuf_OneofOptions_uninterpreted_option_upb_array(const google_protobuf_OneofOptions* msg, size_t* size) {
9473
10123
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10124
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9474
10125
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9475
10126
  if (size) {
9476
10127
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -9479,6 +10130,7 @@ UPB_INLINE const upb_Array* _google_protobuf_OneofOptions_uninterpreted_option_u
9479
10130
  }
9480
10131
  UPB_INLINE upb_Array* _google_protobuf_OneofOptions_uninterpreted_option_mutable_upb_array(google_protobuf_OneofOptions* msg, size_t* size, upb_Arena* arena) {
9481
10132
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10133
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9482
10134
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
9483
10135
  &field, arena);
9484
10136
  if (size) {
@@ -9489,6 +10141,7 @@ UPB_INLINE upb_Array* _google_protobuf_OneofOptions_uninterpreted_option_mutable
9489
10141
 
9490
10142
  UPB_INLINE void google_protobuf_OneofOptions_set_features(google_protobuf_OneofOptions *msg, google_protobuf_FeatureSet* value) {
9491
10143
  const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10144
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9492
10145
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
9493
10146
  }
9494
10147
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_OneofOptions_mutable_features(google_protobuf_OneofOptions* msg, upb_Arena* arena) {
@@ -9501,6 +10154,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_OneofOptions_mutab
9501
10154
  }
9502
10155
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_OneofOptions_mutable_uninterpreted_option(google_protobuf_OneofOptions* msg, size_t* size) {
9503
10156
  upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10157
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9504
10158
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
9505
10159
  if (arr) {
9506
10160
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9517,6 +10171,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_OneofOptions_re
9517
10171
  }
9518
10172
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_OneofOptions_add_uninterpreted_option(google_protobuf_OneofOptions* msg, upb_Arena* arena) {
9519
10173
  upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10174
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9520
10175
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
9521
10176
  UPB_UPCAST(msg), &field, arena);
9522
10177
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -9622,6 +10277,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_EnumOptions_feature
9622
10277
  const google_protobuf_FeatureSet* default_val = NULL;
9623
10278
  const google_protobuf_FeatureSet* ret;
9624
10279
  const upb_MiniTableField field = {7, UPB_SIZE(12, 16), 67, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10280
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9625
10281
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9626
10282
  &default_val, &ret);
9627
10283
  return ret;
@@ -9636,6 +10292,7 @@ UPB_INLINE void google_protobuf_EnumOptions_clear_uninterpreted_option(google_pr
9636
10292
  }
9637
10293
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumOptions_uninterpreted_option(const google_protobuf_EnumOptions* msg, size_t* size) {
9638
10294
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10295
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9639
10296
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9640
10297
  if (arr) {
9641
10298
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9647,6 +10304,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Enu
9647
10304
  }
9648
10305
  UPB_INLINE const upb_Array* _google_protobuf_EnumOptions_uninterpreted_option_upb_array(const google_protobuf_EnumOptions* msg, size_t* size) {
9649
10306
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10307
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9650
10308
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9651
10309
  if (size) {
9652
10310
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -9655,6 +10313,7 @@ UPB_INLINE const upb_Array* _google_protobuf_EnumOptions_uninterpreted_option_up
9655
10313
  }
9656
10314
  UPB_INLINE upb_Array* _google_protobuf_EnumOptions_uninterpreted_option_mutable_upb_array(google_protobuf_EnumOptions* msg, size_t* size, upb_Arena* arena) {
9657
10315
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10316
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9658
10317
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
9659
10318
  &field, arena);
9660
10319
  if (size) {
@@ -9677,6 +10336,7 @@ UPB_INLINE void google_protobuf_EnumOptions_set_deprecated_legacy_json_field_con
9677
10336
  }
9678
10337
  UPB_INLINE void google_protobuf_EnumOptions_set_features(google_protobuf_EnumOptions *msg, google_protobuf_FeatureSet* value) {
9679
10338
  const upb_MiniTableField field = {7, UPB_SIZE(12, 16), 67, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10339
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9680
10340
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
9681
10341
  }
9682
10342
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_EnumOptions_mutable_features(google_protobuf_EnumOptions* msg, upb_Arena* arena) {
@@ -9689,6 +10349,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_EnumOptions_mutabl
9689
10349
  }
9690
10350
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumOptions_mutable_uninterpreted_option(google_protobuf_EnumOptions* msg, size_t* size) {
9691
10351
  upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10352
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9692
10353
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
9693
10354
  if (arr) {
9694
10355
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9705,6 +10366,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumOptions_res
9705
10366
  }
9706
10367
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumOptions_add_uninterpreted_option(google_protobuf_EnumOptions* msg, upb_Arena* arena) {
9707
10368
  upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10369
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9708
10370
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
9709
10371
  UPB_UPCAST(msg), &field, arena);
9710
10372
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -9778,6 +10440,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_EnumValueOptions_fe
9778
10440
  const google_protobuf_FeatureSet* default_val = NULL;
9779
10441
  const google_protobuf_FeatureSet* ret;
9780
10442
  const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10443
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9781
10444
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9782
10445
  &default_val, &ret);
9783
10446
  return ret;
@@ -9810,6 +10473,7 @@ UPB_INLINE const google_protobuf_FieldOptions_FeatureSupport* google_protobuf_En
9810
10473
  const google_protobuf_FieldOptions_FeatureSupport* default_val = NULL;
9811
10474
  const google_protobuf_FieldOptions_FeatureSupport* ret;
9812
10475
  const upb_MiniTableField field = {4, UPB_SIZE(20, 24), 67, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10476
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__FeatureSupport_msg_init);
9813
10477
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9814
10478
  &default_val, &ret);
9815
10479
  return ret;
@@ -9824,6 +10488,7 @@ UPB_INLINE void google_protobuf_EnumValueOptions_clear_uninterpreted_option(goog
9824
10488
  }
9825
10489
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumValueOptions_uninterpreted_option(const google_protobuf_EnumValueOptions* msg, size_t* size) {
9826
10490
  const upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10491
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9827
10492
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9828
10493
  if (arr) {
9829
10494
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9835,6 +10500,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Enu
9835
10500
  }
9836
10501
  UPB_INLINE const upb_Array* _google_protobuf_EnumValueOptions_uninterpreted_option_upb_array(const google_protobuf_EnumValueOptions* msg, size_t* size) {
9837
10502
  const upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10503
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9838
10504
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9839
10505
  if (size) {
9840
10506
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -9843,6 +10509,7 @@ UPB_INLINE const upb_Array* _google_protobuf_EnumValueOptions_uninterpreted_opti
9843
10509
  }
9844
10510
  UPB_INLINE upb_Array* _google_protobuf_EnumValueOptions_uninterpreted_option_mutable_upb_array(google_protobuf_EnumValueOptions* msg, size_t* size, upb_Arena* arena) {
9845
10511
  const upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10512
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9846
10513
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
9847
10514
  &field, arena);
9848
10515
  if (size) {
@@ -9857,6 +10524,7 @@ UPB_INLINE void google_protobuf_EnumValueOptions_set_deprecated(google_protobuf_
9857
10524
  }
9858
10525
  UPB_INLINE void google_protobuf_EnumValueOptions_set_features(google_protobuf_EnumValueOptions *msg, google_protobuf_FeatureSet* value) {
9859
10526
  const upb_MiniTableField field = {2, UPB_SIZE(12, 16), 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10527
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9860
10528
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
9861
10529
  }
9862
10530
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_EnumValueOptions_mutable_features(google_protobuf_EnumValueOptions* msg, upb_Arena* arena) {
@@ -9873,6 +10541,7 @@ UPB_INLINE void google_protobuf_EnumValueOptions_set_debug_redact(google_protobu
9873
10541
  }
9874
10542
  UPB_INLINE void google_protobuf_EnumValueOptions_set_feature_support(google_protobuf_EnumValueOptions *msg, google_protobuf_FieldOptions_FeatureSupport* value) {
9875
10543
  const upb_MiniTableField field = {4, UPB_SIZE(20, 24), 67, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10544
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FieldOptions__FeatureSupport_msg_init);
9876
10545
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
9877
10546
  }
9878
10547
  UPB_INLINE struct google_protobuf_FieldOptions_FeatureSupport* google_protobuf_EnumValueOptions_mutable_feature_support(google_protobuf_EnumValueOptions* msg, upb_Arena* arena) {
@@ -9885,6 +10554,7 @@ UPB_INLINE struct google_protobuf_FieldOptions_FeatureSupport* google_protobuf_E
9885
10554
  }
9886
10555
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumValueOptions_mutable_uninterpreted_option(google_protobuf_EnumValueOptions* msg, size_t* size) {
9887
10556
  upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10557
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9888
10558
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
9889
10559
  if (arr) {
9890
10560
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9901,6 +10571,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_EnumValueOption
9901
10571
  }
9902
10572
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_EnumValueOptions_add_uninterpreted_option(google_protobuf_EnumValueOptions* msg, upb_Arena* arena) {
9903
10573
  upb_MiniTableField field = {999, UPB_SIZE(24, 32), 0, 2, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10574
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9904
10575
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
9905
10576
  UPB_UPCAST(msg), &field, arena);
9906
10577
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -9974,6 +10645,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_ServiceOptions_feat
9974
10645
  const google_protobuf_FeatureSet* default_val = NULL;
9975
10646
  const google_protobuf_FeatureSet* ret;
9976
10647
  const upb_MiniTableField field = {34, UPB_SIZE(12, 16), 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10648
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
9977
10649
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
9978
10650
  &default_val, &ret);
9979
10651
  return ret;
@@ -9988,6 +10660,7 @@ UPB_INLINE void google_protobuf_ServiceOptions_clear_uninterpreted_option(google
9988
10660
  }
9989
10661
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ServiceOptions_uninterpreted_option(const google_protobuf_ServiceOptions* msg, size_t* size) {
9990
10662
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10663
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
9991
10664
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
9992
10665
  if (arr) {
9993
10666
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -9999,6 +10672,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Ser
9999
10672
  }
10000
10673
  UPB_INLINE const upb_Array* _google_protobuf_ServiceOptions_uninterpreted_option_upb_array(const google_protobuf_ServiceOptions* msg, size_t* size) {
10001
10674
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10675
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10002
10676
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10003
10677
  if (size) {
10004
10678
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -10007,6 +10681,7 @@ UPB_INLINE const upb_Array* _google_protobuf_ServiceOptions_uninterpreted_option
10007
10681
  }
10008
10682
  UPB_INLINE upb_Array* _google_protobuf_ServiceOptions_uninterpreted_option_mutable_upb_array(google_protobuf_ServiceOptions* msg, size_t* size, upb_Arena* arena) {
10009
10683
  const upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10684
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10010
10685
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
10011
10686
  &field, arena);
10012
10687
  if (size) {
@@ -10021,6 +10696,7 @@ UPB_INLINE void google_protobuf_ServiceOptions_set_deprecated(google_protobuf_Se
10021
10696
  }
10022
10697
  UPB_INLINE void google_protobuf_ServiceOptions_set_features(google_protobuf_ServiceOptions *msg, google_protobuf_FeatureSet* value) {
10023
10698
  const upb_MiniTableField field = {34, UPB_SIZE(12, 16), 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10699
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10024
10700
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
10025
10701
  }
10026
10702
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_ServiceOptions_mutable_features(google_protobuf_ServiceOptions* msg, upb_Arena* arena) {
@@ -10033,6 +10709,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_ServiceOptions_mut
10033
10709
  }
10034
10710
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ServiceOptions_mutable_uninterpreted_option(google_protobuf_ServiceOptions* msg, size_t* size) {
10035
10711
  upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10712
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10036
10713
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
10037
10714
  if (arr) {
10038
10715
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10049,6 +10726,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_ServiceOptions_
10049
10726
  }
10050
10727
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_ServiceOptions_add_uninterpreted_option(google_protobuf_ServiceOptions* msg, upb_Arena* arena) {
10051
10728
  upb_MiniTableField field = {999, UPB_SIZE(16, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10729
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10052
10730
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
10053
10731
  UPB_UPCAST(msg), &field, arena);
10054
10732
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -10138,6 +10816,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_MethodOptions_featu
10138
10816
  const google_protobuf_FeatureSet* default_val = NULL;
10139
10817
  const google_protobuf_FeatureSet* ret;
10140
10818
  const upb_MiniTableField field = {35, 16, 66, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10819
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10141
10820
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
10142
10821
  &default_val, &ret);
10143
10822
  return ret;
@@ -10152,6 +10831,7 @@ UPB_INLINE void google_protobuf_MethodOptions_clear_uninterpreted_option(google_
10152
10831
  }
10153
10832
  UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MethodOptions_uninterpreted_option(const google_protobuf_MethodOptions* msg, size_t* size) {
10154
10833
  const upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10834
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10155
10835
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10156
10836
  if (arr) {
10157
10837
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10163,6 +10843,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_Met
10163
10843
  }
10164
10844
  UPB_INLINE const upb_Array* _google_protobuf_MethodOptions_uninterpreted_option_upb_array(const google_protobuf_MethodOptions* msg, size_t* size) {
10165
10845
  const upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10846
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10166
10847
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10167
10848
  if (size) {
10168
10849
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -10171,6 +10852,7 @@ UPB_INLINE const upb_Array* _google_protobuf_MethodOptions_uninterpreted_option_
10171
10852
  }
10172
10853
  UPB_INLINE upb_Array* _google_protobuf_MethodOptions_uninterpreted_option_mutable_upb_array(google_protobuf_MethodOptions* msg, size_t* size, upb_Arena* arena) {
10173
10854
  const upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10855
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10174
10856
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
10175
10857
  &field, arena);
10176
10858
  if (size) {
@@ -10189,6 +10871,7 @@ UPB_INLINE void google_protobuf_MethodOptions_set_idempotency_level(google_proto
10189
10871
  }
10190
10872
  UPB_INLINE void google_protobuf_MethodOptions_set_features(google_protobuf_MethodOptions *msg, google_protobuf_FeatureSet* value) {
10191
10873
  const upb_MiniTableField field = {35, 16, 66, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10874
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10192
10875
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
10193
10876
  }
10194
10877
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_MethodOptions_mutable_features(google_protobuf_MethodOptions* msg, upb_Arena* arena) {
@@ -10201,6 +10884,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_MethodOptions_muta
10201
10884
  }
10202
10885
  UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MethodOptions_mutable_uninterpreted_option(google_protobuf_MethodOptions* msg, size_t* size) {
10203
10886
  upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10887
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10204
10888
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
10205
10889
  if (arr) {
10206
10890
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10217,6 +10901,7 @@ UPB_INLINE google_protobuf_UninterpretedOption** google_protobuf_MethodOptions_r
10217
10901
  }
10218
10902
  UPB_INLINE struct google_protobuf_UninterpretedOption* google_protobuf_MethodOptions_add_uninterpreted_option(google_protobuf_MethodOptions* msg, upb_Arena* arena) {
10219
10903
  upb_MiniTableField field = {999, UPB_SIZE(20, 24), 0, 1, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
10904
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption_msg_init);
10220
10905
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
10221
10906
  UPB_UPCAST(msg), &field, arena);
10222
10907
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -10272,6 +10957,7 @@ UPB_INLINE void google_protobuf_UninterpretedOption_clear_name(google_protobuf_U
10272
10957
  }
10273
10958
  UPB_INLINE const google_protobuf_UninterpretedOption_NamePart* const* google_protobuf_UninterpretedOption_name(const google_protobuf_UninterpretedOption* msg, size_t* size) {
10274
10959
  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)};
10960
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption__NamePart_msg_init);
10275
10961
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10276
10962
  if (arr) {
10277
10963
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10283,6 +10969,7 @@ UPB_INLINE const google_protobuf_UninterpretedOption_NamePart* const* google_pro
10283
10969
  }
10284
10970
  UPB_INLINE const upb_Array* _google_protobuf_UninterpretedOption_name_upb_array(const google_protobuf_UninterpretedOption* msg, size_t* size) {
10285
10971
  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)};
10972
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption__NamePart_msg_init);
10286
10973
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10287
10974
  if (size) {
10288
10975
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -10291,6 +10978,7 @@ UPB_INLINE const upb_Array* _google_protobuf_UninterpretedOption_name_upb_array(
10291
10978
  }
10292
10979
  UPB_INLINE upb_Array* _google_protobuf_UninterpretedOption_name_mutable_upb_array(google_protobuf_UninterpretedOption* msg, size_t* size, upb_Arena* arena) {
10293
10980
  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)};
10981
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption__NamePart_msg_init);
10294
10982
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
10295
10983
  &field, arena);
10296
10984
  if (size) {
@@ -10397,6 +11085,7 @@ UPB_INLINE bool google_protobuf_UninterpretedOption_has_aggregate_value(const go
10397
11085
 
10398
11086
  UPB_INLINE google_protobuf_UninterpretedOption_NamePart** google_protobuf_UninterpretedOption_mutable_name(google_protobuf_UninterpretedOption* msg, size_t* size) {
10399
11087
  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)};
11088
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption__NamePart_msg_init);
10400
11089
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
10401
11090
  if (arr) {
10402
11091
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10413,6 +11102,7 @@ UPB_INLINE google_protobuf_UninterpretedOption_NamePart** google_protobuf_Uninte
10413
11102
  }
10414
11103
  UPB_INLINE struct google_protobuf_UninterpretedOption_NamePart* google_protobuf_UninterpretedOption_add_name(google_protobuf_UninterpretedOption* msg, upb_Arena* arena) {
10415
11104
  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)};
11105
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__UninterpretedOption__NamePart_msg_init);
10416
11106
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
10417
11107
  UPB_UPCAST(msg), &field, arena);
10418
11108
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -10728,6 +11418,7 @@ UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_defaults(google_protobu
10728
11418
  }
10729
11419
  UPB_INLINE const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* const* google_protobuf_FeatureSetDefaults_defaults(const google_protobuf_FeatureSetDefaults* msg, size_t* size) {
10730
11420
  const upb_MiniTableField field = {1, UPB_SIZE(12, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11421
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init);
10731
11422
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10732
11423
  if (arr) {
10733
11424
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10739,6 +11430,7 @@ UPB_INLINE const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* co
10739
11430
  }
10740
11431
  UPB_INLINE const upb_Array* _google_protobuf_FeatureSetDefaults_defaults_upb_array(const google_protobuf_FeatureSetDefaults* msg, size_t* size) {
10741
11432
  const upb_MiniTableField field = {1, UPB_SIZE(12, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11433
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init);
10742
11434
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10743
11435
  if (size) {
10744
11436
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -10747,6 +11439,7 @@ UPB_INLINE const upb_Array* _google_protobuf_FeatureSetDefaults_defaults_upb_arr
10747
11439
  }
10748
11440
  UPB_INLINE upb_Array* _google_protobuf_FeatureSetDefaults_defaults_mutable_upb_array(google_protobuf_FeatureSetDefaults* msg, size_t* size, upb_Arena* arena) {
10749
11441
  const upb_MiniTableField field = {1, UPB_SIZE(12, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11442
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init);
10750
11443
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
10751
11444
  &field, arena);
10752
11445
  if (size) {
@@ -10789,6 +11482,7 @@ UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_maximum_edition(const goo
10789
11482
 
10790
11483
  UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault** google_protobuf_FeatureSetDefaults_mutable_defaults(google_protobuf_FeatureSetDefaults* msg, size_t* size) {
10791
11484
  upb_MiniTableField field = {1, UPB_SIZE(12, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11485
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init);
10792
11486
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
10793
11487
  if (arr) {
10794
11488
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10805,6 +11499,7 @@ UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault** google_
10805
11499
  }
10806
11500
  UPB_INLINE struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_add_defaults(google_protobuf_FeatureSetDefaults* msg, upb_Arena* arena) {
10807
11501
  upb_MiniTableField field = {1, UPB_SIZE(12, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11502
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSetDefaults__FeatureSetEditionDefault_msg_init);
10808
11503
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
10809
11504
  UPB_UPCAST(msg), &field, arena);
10810
11505
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -10886,6 +11581,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_
10886
11581
  const google_protobuf_FeatureSet* default_val = NULL;
10887
11582
  const google_protobuf_FeatureSet* ret;
10888
11583
  const upb_MiniTableField field = {4, 16, 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11584
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10889
11585
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
10890
11586
  &default_val, &ret);
10891
11587
  return ret;
@@ -10902,6 +11598,7 @@ UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_
10902
11598
  const google_protobuf_FeatureSet* default_val = NULL;
10903
11599
  const google_protobuf_FeatureSet* ret;
10904
11600
  const upb_MiniTableField field = {5, UPB_SIZE(20, 24), 66, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11601
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10905
11602
  _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
10906
11603
  &default_val, &ret);
10907
11604
  return ret;
@@ -10917,6 +11614,7 @@ UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_
10917
11614
  }
10918
11615
  UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_overridable_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault *msg, google_protobuf_FeatureSet* value) {
10919
11616
  const upb_MiniTableField field = {4, 16, 65, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11617
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10920
11618
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
10921
11619
  }
10922
11620
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_mutable_overridable_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, upb_Arena* arena) {
@@ -10929,6 +11627,7 @@ UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults
10929
11627
  }
10930
11628
  UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_fixed_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault *msg, google_protobuf_FeatureSet* value) {
10931
11629
  const upb_MiniTableField field = {5, UPB_SIZE(20, 24), 66, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11630
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__FeatureSet_msg_init);
10932
11631
  upb_Message_SetBaseField((upb_Message *)msg, &field, &value);
10933
11632
  }
10934
11633
  UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_mutable_fixed_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, upb_Arena* arena) {
@@ -10982,6 +11681,7 @@ UPB_INLINE void google_protobuf_SourceCodeInfo_clear_location(google_protobuf_So
10982
11681
  }
10983
11682
  UPB_INLINE const google_protobuf_SourceCodeInfo_Location* const* google_protobuf_SourceCodeInfo_location(const google_protobuf_SourceCodeInfo* msg, size_t* size) {
10984
11683
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11684
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo__Location_msg_init);
10985
11685
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10986
11686
  if (arr) {
10987
11687
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -10993,6 +11693,7 @@ UPB_INLINE const google_protobuf_SourceCodeInfo_Location* const* google_protobuf
10993
11693
  }
10994
11694
  UPB_INLINE const upb_Array* _google_protobuf_SourceCodeInfo_location_upb_array(const google_protobuf_SourceCodeInfo* msg, size_t* size) {
10995
11695
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11696
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo__Location_msg_init);
10996
11697
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
10997
11698
  if (size) {
10998
11699
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -11001,6 +11702,7 @@ UPB_INLINE const upb_Array* _google_protobuf_SourceCodeInfo_location_upb_array(c
11001
11702
  }
11002
11703
  UPB_INLINE upb_Array* _google_protobuf_SourceCodeInfo_location_mutable_upb_array(google_protobuf_SourceCodeInfo* msg, size_t* size, upb_Arena* arena) {
11003
11704
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11705
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo__Location_msg_init);
11004
11706
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
11005
11707
  &field, arena);
11006
11708
  if (size) {
@@ -11011,6 +11713,7 @@ UPB_INLINE upb_Array* _google_protobuf_SourceCodeInfo_location_mutable_upb_array
11011
11713
 
11012
11714
  UPB_INLINE google_protobuf_SourceCodeInfo_Location** google_protobuf_SourceCodeInfo_mutable_location(google_protobuf_SourceCodeInfo* msg, size_t* size) {
11013
11715
  upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11716
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo__Location_msg_init);
11014
11717
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
11015
11718
  if (arr) {
11016
11719
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -11027,6 +11730,7 @@ UPB_INLINE google_protobuf_SourceCodeInfo_Location** google_protobuf_SourceCodeI
11027
11730
  }
11028
11731
  UPB_INLINE struct google_protobuf_SourceCodeInfo_Location* google_protobuf_SourceCodeInfo_add_location(google_protobuf_SourceCodeInfo* msg, upb_Arena* arena) {
11029
11732
  upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
11733
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__SourceCodeInfo__Location_msg_init);
11030
11734
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
11031
11735
  UPB_UPCAST(msg), &field, arena);
11032
11736
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -11340,6 +12044,7 @@ UPB_INLINE void google_protobuf_GeneratedCodeInfo_clear_annotation(google_protob
11340
12044
  }
11341
12045
  UPB_INLINE const google_protobuf_GeneratedCodeInfo_Annotation* const* google_protobuf_GeneratedCodeInfo_annotation(const google_protobuf_GeneratedCodeInfo* msg, size_t* size) {
11342
12046
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
12047
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__GeneratedCodeInfo__Annotation_msg_init);
11343
12048
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
11344
12049
  if (arr) {
11345
12050
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -11351,6 +12056,7 @@ UPB_INLINE const google_protobuf_GeneratedCodeInfo_Annotation* const* google_pro
11351
12056
  }
11352
12057
  UPB_INLINE const upb_Array* _google_protobuf_GeneratedCodeInfo_annotation_upb_array(const google_protobuf_GeneratedCodeInfo* msg, size_t* size) {
11353
12058
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
12059
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__GeneratedCodeInfo__Annotation_msg_init);
11354
12060
  const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
11355
12061
  if (size) {
11356
12062
  *size = arr ? arr->UPB_PRIVATE(size) : 0;
@@ -11359,6 +12065,7 @@ UPB_INLINE const upb_Array* _google_protobuf_GeneratedCodeInfo_annotation_upb_ar
11359
12065
  }
11360
12066
  UPB_INLINE upb_Array* _google_protobuf_GeneratedCodeInfo_annotation_mutable_upb_array(google_protobuf_GeneratedCodeInfo* msg, size_t* size, upb_Arena* arena) {
11361
12067
  const upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
12068
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__GeneratedCodeInfo__Annotation_msg_init);
11362
12069
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
11363
12070
  &field, arena);
11364
12071
  if (size) {
@@ -11369,6 +12076,7 @@ UPB_INLINE upb_Array* _google_protobuf_GeneratedCodeInfo_annotation_mutable_upb_
11369
12076
 
11370
12077
  UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation** google_protobuf_GeneratedCodeInfo_mutable_annotation(google_protobuf_GeneratedCodeInfo* msg, size_t* size) {
11371
12078
  upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
12079
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__GeneratedCodeInfo__Annotation_msg_init);
11372
12080
  upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
11373
12081
  if (arr) {
11374
12082
  if (size) *size = arr->UPB_PRIVATE(size);
@@ -11385,6 +12093,7 @@ UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation** google_protobuf_Genera
11385
12093
  }
11386
12094
  UPB_INLINE struct google_protobuf_GeneratedCodeInfo_Annotation* google_protobuf_GeneratedCodeInfo_add_annotation(google_protobuf_GeneratedCodeInfo* msg, upb_Arena* arena) {
11387
12095
  upb_MiniTableField field = {1, 8, 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
12096
+ UPB_PRIVATE(_upb_MiniTable_StrongReference)(&google__protobuf__GeneratedCodeInfo__Annotation_msg_init);
11388
12097
  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
11389
12098
  UPB_UPCAST(msg), &field, arena);
11390
12099
  if (!arr || !UPB_PRIVATE(_upb_Array_ResizeUninitialized)(
@@ -11885,6 +12594,7 @@ bool upb_FieldDef_HasOptions(const upb_FieldDef* f);
11885
12594
  UPB_API bool upb_FieldDef_HasPresence(const upb_FieldDef* f);
11886
12595
  bool upb_FieldDef_HasSubDef(const upb_FieldDef* f);
11887
12596
  uint32_t upb_FieldDef_Index(const upb_FieldDef* f);
12597
+ UPB_API bool upb_FieldDef_IsEnum(const upb_FieldDef* f);
11888
12598
  bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
11889
12599
  UPB_API bool upb_FieldDef_IsMap(const upb_FieldDef* f);
11890
12600
  bool upb_FieldDef_IsOptional(const upb_FieldDef* f);
@@ -12353,8 +13063,8 @@ UPB_API upb_MutableMessageValue upb_Message_Mutable(upb_Message* msg,
12353
13063
  upb_Arena* a);
12354
13064
 
12355
13065
  // Returns the field that is set in the oneof, or NULL if none are set.
12356
- UPB_API const upb_FieldDef* upb_Message_WhichOneof(const upb_Message* msg,
12357
- const upb_OneofDef* o);
13066
+ UPB_API const upb_FieldDef* upb_Message_WhichOneofByDef(const upb_Message* msg,
13067
+ const upb_OneofDef* o);
12358
13068
 
12359
13069
  // Clear all data and unknown fields.
12360
13070
  void upb_Message_ClearByDef(upb_Message* msg, const upb_MessageDef* m);
@@ -12853,6 +13563,29 @@ upb_UnknownCompareResult UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
12853
13563
 
12854
13564
  #endif /* UPB_MESSAGE_INTERNAL_COMPARE_UNKNOWN_H_ */
12855
13565
 
13566
+ #ifndef THIRD_PARTY_UPB_UPB_MESSAGE_INTERNAL_ITERATOR_H_
13567
+ #define THIRD_PARTY_UPB_UPB_MESSAGE_INTERNAL_ITERATOR_H_
13568
+
13569
+ #include <stddef.h>
13570
+
13571
+
13572
+ // Must be last.
13573
+
13574
+ #define kUpb_BaseField_Begin ((size_t)-1)
13575
+ #define kUpb_Extension_Begin ((size_t)-1)
13576
+
13577
+ bool UPB_PRIVATE(_upb_Message_NextBaseField)(const upb_Message* msg,
13578
+ const upb_MiniTable* m,
13579
+ const upb_MiniTableField** out_f,
13580
+ upb_MessageValue* out_v,
13581
+ size_t* iter);
13582
+
13583
+ bool UPB_PRIVATE(_upb_Message_NextExtension)(
13584
+ const upb_Message* msg, const upb_MiniTable* m,
13585
+ const upb_MiniTableExtension** out_e, upb_MessageValue* out_v,
13586
+ size_t* iter);
13587
+ #endif // THIRD_PARTY_UPB_UPB_MESSAGE_INTERNAL_ITERATOR_H_
13588
+
12856
13589
  #ifndef UPB_MESSAGE_COPY_H_
12857
13590
  #define UPB_MESSAGE_COPY_H_
12858
13591
 
@@ -12895,6 +13628,26 @@ void upb_Message_ShallowCopy(upb_Message* dst, const upb_Message* src,
12895
13628
 
12896
13629
 
12897
13630
  #endif // UPB_MESSAGE_COPY_H_
13631
+ #ifndef THIRD_PARTY_UPB_UPB_MESSAGE_MERGE_H_
13632
+ #define THIRD_PARTY_UPB_UPB_MESSAGE_MERGE_H_
13633
+
13634
+
13635
+ // Must be last.
13636
+
13637
+ #ifdef __cplusplus
13638
+ extern "C" {
13639
+ #endif
13640
+
13641
+ UPB_API bool upb_Message_MergeFrom(upb_Message* dst, const upb_Message* src,
13642
+ const upb_MiniTable* mt,
13643
+ const upb_ExtensionRegistry* extreg,
13644
+ upb_Arena* arena);
13645
+
13646
+ #ifdef __cplusplus
13647
+ } /* extern "C" */
13648
+ #endif
13649
+
13650
+ #endif // THIRD_PARTY_UPB_UPB_MESSAGE_MERGE_H_
12898
13651
 
12899
13652
  #ifndef UPB_MINI_DESCRIPTOR_INTERNAL_BASE92_H_
12900
13653
  #define UPB_MINI_DESCRIPTOR_INTERNAL_BASE92_H_
@@ -14056,7 +14809,7 @@ upb_ServiceDef* _upb_ServiceDefs_New(upb_DefBuilder* ctx, int n,
14056
14809
  // features. This is used for feature resolution under Editions.
14057
14810
  // NOLINTBEGIN
14058
14811
  // clang-format off
14059
- #define UPB_INTERNAL_UPB_EDITION_DEFAULTS "\n\023\030\346\007\"\000*\014\010\001\020\002\030\002 \003(\0010\002\n\023\030\347\007\"\000*\014\010\002\020\001\030\001 \002(\0010\001\n\023\030\350\007\"\014\010\001\020\001\030\001 \002(\0010\001*\000 \346\007(\350\007"
14812
+ #define UPB_INTERNAL_UPB_EDITION_DEFAULTS "\n\023\030\204\007\"\000*\014\010\001\020\002\030\002 \003(\0010\002\n\023\030\347\007\"\000*\014\010\002\020\001\030\001 \002(\0010\001\n\023\030\350\007\"\014\010\001\020\001\030\001 \002(\0010\001*\000 \346\007(\350\007"
14060
14813
  // clang-format on
14061
14814
  // NOLINTEND
14062
14815
 
@@ -14347,3 +15100,7 @@ upb_MethodDef* _upb_MethodDefs_New(upb_DefBuilder* ctx, int n,
14347
15100
  #undef UPB_USE_C11_ATOMICS
14348
15101
  #undef UPB_PRIVATE
14349
15102
  #undef UPB_ONLYBITS
15103
+ #undef UPB_LINKARR_DECLARE
15104
+ #undef UPB_LINKARR_APPEND
15105
+ #undef UPB_LINKARR_START
15106
+ #undef UPB_LINKARR_STOP