xref: /third_party/protobuf/ruby/ext/google/protobuf_c/upb.h

94 int msvc_snprintf(char* s, size_t n, const char* format, ...);
95 int msvc_vsnprintf(char* s, size_t n, const char* format, va_list arg);
240 const char *upb_status_errmsg(const upb_status *status);
241 bool upb_ok(const upb_status *status);
245 void upb_status_seterrmsg(upb_status *status, const char *msg);
246 void upb_status_seterrf(upb_status *status, const char *fmt, ...);
247 void upb_status_vseterrf(upb_status *status, const char *fmt, va_list args);
252   const char *data;
256 UPB_INLINE upb_strview upb_strview_make(const char *data, size_t size) {
263 UPB_INLINE upb_strview upb_strview_makez(const char *data) {
362   const size_t maxalign = 16;
372 size_t upb_arena_bytesallocated(const upb_arena *a);
522 char *upb_strdup(const char *s, upb_alloc *a);
525 char *upb_strdup2(const char *s, size_t len, upb_alloc *a);
527 UPB_INLINE char *upb_gstrdup(const char *s) {
569 FUNCS(constptr, constptr,     const void*,  uintptr_t,  UPB_CTYPE_CONSTPTR)
629   /* Internal chaining.  This is const so we can create static initializers for
630    * tables.  We cast away const sometimes, but *only* when the containing
631    * upb_table is known to be non-const.  This requires a bit of care, but
633   const struct _upb_tabent *next;
642    * Making this const isn't entirely accurate; what we really want is for it to
643    * have the same const-ness as the table it's inside.  But there's no way to
644    * declare that in C.  So we have to make it const so that we can statically
645    * initialize const hash tables.  Then we cast away const when we have to.
647   const upb_tabent *entries;
656   const upb_tabval *array;  /* Array part of the table. See const note above. */
663 UPB_INLINE size_t upb_table_size(const upb_table *t) {
671 UPB_INLINE bool upb_tabent_isempty(const upb_tabent *e) {
676 uint32_t upb_murmur_hash2(const void * key, size_t len, uint32_t seed);
686 static const upb_tabent *upb_getentry(const upb_table *t, uint32_t hash) {
718 size_t upb_inttable_count(const upb_inttable *t);
719 UPB_INLINE size_t upb_strtable_count(const upb_strtable *t) {
723 void upb_inttable_packedsize(const upb_inttable *t, size_t *size);
724 void upb_strtable_packedsize(const upb_strtable *t, size_t *size);
725 upb_inttable *upb_inttable_pack(const upb_inttable *t, void *p, size_t *ofs,
727 upb_strtable *upb_strtable_pack(const upb_strtable *t, void *p, size_t *ofs,
740 bool upb_strtable_insert3(upb_strtable *t, const char *key, size_t len,
748 UPB_INLINE bool upb_strtable_insert2(upb_strtable *t, const char *key,
754 UPB_INLINE bool upb_strtable_insert(upb_strtable *t, const char *key,
761 bool upb_inttable_lookup(const upb_inttable *t, uintptr_t key, upb_value *v);
762 bool upb_strtable_lookup2(const upb_strtable *t, const char *key, size_t len,
766 UPB_INLINE bool upb_strtable_lookup(const upb_strtable *t, const char *key,
774 bool upb_strtable_remove3(upb_strtable *t, const char *key, size_t len,
777 UPB_INLINE bool upb_strtable_remove2(upb_strtable *t, const char *key,
783 UPB_INLINE bool upb_strtable_remove(upb_strtable *t, const char *key,
803 bool upb_inttable_insertptr2(upb_inttable *t, const void *key, upb_value val,
805 bool upb_inttable_removeptr(upb_inttable *t, const void *key, upb_value *val);
807     const upb_inttable *t, const void *key, upb_value *val);
809 UPB_INLINE bool upb_inttable_insertptr(upb_inttable *t, const void *key,
825 UPB_INLINE bool upb_inttable_lookup32(const upb_inttable *t, uint32_t key,
837     const upb_tabent *e;
881  *     const char *key = upb_strtable_iter_key(&i);
882  *     const upb_value val = upb_strtable_iter_value(&i);
888   const upb_strtable *t;
892 void upb_strtable_begin(upb_strtable_iter *i, const upb_strtable *t);
894 bool upb_strtable_done(const upb_strtable_iter *i);
895 upb_strview upb_strtable_iter_key(const upb_strtable_iter *i);
896 upb_value upb_strtable_iter_value(const upb_strtable_iter *i);
898 bool upb_strtable_iter_isequal(const upb_strtable_iter *i1,
899                                const upb_strtable_iter *i2);
914   const upb_inttable *t;
919 UPB_INLINE const upb_tabent *str_tabent(const upb_strtable_iter *i) {
923 void upb_inttable_begin(upb_inttable_iter *i, const upb_inttable *t);
925 bool upb_inttable_done(const upb_inttable_iter *i);
926 uintptr_t upb_inttable_iter_key(const upb_inttable_iter *i);
927 upb_value upb_inttable_iter_value(const upb_inttable_iter *i);
929 bool upb_inttable_iter_isequal(const upb_inttable_iter *i1,
930                                const upb_inttable_iter *i2);
945 #define PTR_AT(msg, ofs, type) (type*)((const char*)msg + ofs)
972   const struct upb_msglayout *const* submsgs;
973   const upb_msglayout_field *fields;
1004 upb_msg *_upb_msg_new(const upb_msglayout *l, upb_arena *a);
1008 bool _upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
1012 const char *upb_msg_getunknown(const upb_msg *msg, size_t *len);
1014 UPB_INLINE bool _upb_has_field(const void *msg, size_t idx) {
1015   return (*PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
1018 UPB_INLINE bool _upb_sethas(const void *msg, size_t idx) {
1022 UPB_INLINE bool _upb_clearhas(const void *msg, size_t idx) {
1026 UPB_INLINE bool _upb_has_oneof_field(const void *msg, size_t case_ofs, int32_t num) {
1030 UPB_INLINE bool _upb_has_submsg_nohasbit(const void *msg, size_t ofs) {
1031   return *PTR_AT(msg, ofs, const void*) != NULL;
1034 UPB_INLINE bool _upb_isrepeated(const upb_msglayout_field *field) {
1047 UPB_INLINE const void *_upb_array_constptr(const upb_array *arr) {
1064 bool _upb_array_append_fallback(upb_array **arr_ptr, const void *value,
1067 UPB_INLINE const void *_upb_array_accessor(const void *msg, size_t ofs,
1069   const upb_array *arr = *PTR_AT(msg, ofs, const upb_array*);
1107                                            const void *value,
1161 UPB_INLINE upb_strview _upb_map_tokey(const void *key, size_t size) {
1165     return upb_strview_make((const char*)key, size);
1177 UPB_INLINE upb_value _upb_map_tovalue(const void *val, size_t size,
1192     const upb_strview *strp = (const upb_strview*)upb_value_getptr(val);
1201 UPB_INLINE size_t _upb_map_size(const upb_map *map) {
1205 UPB_INLINE bool _upb_map_get(const upb_map *map, const void *key,
1216 UPB_INLINE void* _upb_map_next(const upb_map *map, size_t *iter) {
1226 UPB_INLINE bool _upb_map_set(upb_map *map, const void *key, size_t key_size,
1237 UPB_INLINE bool _upb_map_delete(upb_map *map, const void *key, size_t key_size) {
1248 UPB_INLINE size_t _upb_msg_map_size(const upb_msg *msg, size_t ofs) {
1253 UPB_INLINE bool _upb_msg_map_get(const upb_msg *msg, size_t ofs,
1254                                  const void *key, size_t key_size, void *val,
1261 UPB_INLINE void *_upb_msg_map_next(const upb_msg *msg, size_t ofs,
1268 UPB_INLINE bool _upb_msg_map_set(upb_msg *msg, size_t ofs, const void *key,
1278 UPB_INLINE bool _upb_msg_map_delete(upb_msg *msg, size_t ofs, const void *key,
1293 UPB_INLINE void _upb_msg_map_key(const void* msg, void* key, size_t size) {
1294   const upb_tabent *ent = (const upb_tabent*)msg;
1302 UPB_INLINE void _upb_msg_map_value(const void* msg, void* val, size_t size) {
1303   const upb_tabent *ent = (const upb_tabent*)msg;
1309 UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val, size_t size) {
1334 bool upb_decode(const char *buf, size_t size, upb_msg *msg,
1335                 const upb_msglayout *l, upb_arena *arena);
1354 char *upb_encode(const void *msg, const upb_msglayout *l, upb_arena *arena,
1433 extern const upb_msglayout google_protobuf_FileDescriptorSet_msginit;
1434 extern const upb_msglayout google_protobuf_FileDescriptorProto_msginit;
1435 extern const upb_msglayout google_protobuf_DescriptorProto_msginit;
1436 extern const upb_msglayout google_protobuf_DescriptorProto_ExtensionRange_msginit;
1437 extern const upb_msglayout google_protobuf_DescriptorProto_ReservedRange_msginit;
1438 extern const upb_msglayout google_protobuf_ExtensionRangeOptions_msginit;
1439 extern const upb_msglayout google_protobuf_FieldDescriptorProto_msginit;
1440 extern const upb_msglayout google_protobuf_OneofDescriptorProto_msginit;
1441 extern const upb_msglayout google_protobuf_EnumDescriptorProto_msginit;
1442 extern const upb_msglayout google_protobuf_EnumDescriptorProto_EnumReservedRange_msginit;
1443 extern const upb_msglayout google_protobuf_EnumValueDescriptorProto_msginit;
1444 extern const upb_msglayout google_protobuf_ServiceDescriptorProto_msginit;
1445 extern const upb_msglayout google_protobuf_MethodDescriptorProto_msginit;
1446 extern const upb_msglayout google_protobuf_FileOptions_msginit;
1447 extern const upb_msglayout google_protobuf_MessageOptions_msginit;
1448 extern const upb_msglayout google_protobuf_FieldOptions_msginit;
1449 extern const upb_msglayout google_protobuf_OneofOptions_msginit;
1450 extern const upb_msglayout google_protobuf_EnumOptions_msginit;
1451 extern const upb_msglayout google_protobuf_EnumValueOptions_msginit;
1452 extern const upb_msglayout google_protobuf_ServiceOptions_msginit;
1453 extern const upb_msglayout google_protobuf_MethodOptions_msginit;
1454 extern const upb_msglayout google_protobuf_UninterpretedOption_msginit;
1455 extern const upb_msglayout google_protobuf_UninterpretedOption_NamePart_msginit;
1456 extern const upb_msglayout google_protobuf_SourceCodeInfo_msginit;
1457 extern const upb_msglayout google_protobuf_SourceCodeInfo_Location_msginit;
1458 extern const upb_msglayout google_protobuf_GeneratedCodeInfo_msginit;
1459 extern const upb_msglayout google_protobuf_GeneratedCodeInfo_Annotation_msginit;
1518 UPB_INLINE google_protobuf_FileDescriptorSet *google_protobuf_FileDescriptorSet_parse(const char *buf, size_t size,
1523 UPB_INLINE char *google_protobuf_FileDescriptorSet_serialize(const google_protobuf_FileDescriptorSet *msg, upb_arena *arena, size_t *len) {
1527 UPB_INLINE bool google_protobuf_FileDescriptorSet_has_file(const google_protobuf_FileDescriptorSet *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
1528 UPB_INLINE const google_protobuf_FileDescriptorProto* const* google_protobuf_FileDescriptorSet_file(const google_protobuf_FileDescriptorSet *msg, size_t *len) { return (const google_protobuf_FileDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
1549 UPB_INLINE google_protobuf_FileDescriptorProto *google_protobuf_FileDescriptorProto_parse(const char *buf, size_t size,
1554 UPB_INLINE char *google_protobuf_FileDescriptorProto_serialize(const google_protobuf_FileDescriptorProto *msg, upb_arena *arena, size_t *len) {
1558 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_name(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 1); }
1559 UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_name(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
1560 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_package(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 2); }
1561 UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_package(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview); }
1562 UPB_INLINE upb_strview const* google_protobuf_FileDescriptorProto_dependency(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len); }
1563 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_message_type(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(40, 80)); }
1564 UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_FileDescriptorProto_message_type(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(40, 80), len); }
1565 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_enum_type(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(44, 88)); }
1566 UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_FileDescriptorProto_enum_type(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(44, 88), len); }
1567 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_service(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(48, 96)); }
1568 UPB_INLINE const google_protobuf_ServiceDescriptorProto* const* google_protobuf_FileDescriptorProto_service(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_ServiceDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(48, 96), len); }
1569 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_extension(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(52, 104)); }
1570 UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_FileDescriptorProto_extension(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(52, 104), len); }
1571 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_options(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 4); }
1572 UPB_INLINE const google_protobuf_FileOptions* google_protobuf_FileDescriptorProto_options(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const google_protobuf_FileOptions*); }
1573 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_source_code_info(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 5); }
1574 UPB_INLINE const google_protobuf_SourceCodeInfo* google_protobuf_FileDescriptorProto_source_code_info(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 64), const google_protobuf_SourceCodeInfo*); }
1575 UPB_INLINE int32_t const* google_protobuf_FileDescriptorProto_public_dependency(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(56, 112), len); }
1576 UPB_INLINE int32_t const* google_protobuf_FileDescriptorProto_weak_dependency(const google_protobuf_FileDescriptorProto *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(60, 120), len); }
1577 UPB_INLINE bool google_protobuf_FileDescriptorProto_has_syntax(const google_protobuf_FileDescriptorProto *msg) { return _upb_has_field(msg, 3); }
1578 UPB_INLINE upb_strview google_protobuf_FileDescriptorProto_syntax(const google_protobuf_FileDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_strview); }
1706 UPB_INLINE google_protobuf_DescriptorProto *google_protobuf_DescriptorProto_parse(const char *buf, size_t size,
1711 UPB_INLINE char *google_protobuf_DescriptorProto_serialize(const google_protobuf_DescriptorProto *msg, upb_arena *arena, size_t *len) {
1715 UPB_INLINE bool google_protobuf_DescriptorProto_has_name(const google_protobuf_DescriptorProto *msg) { return _upb_has_field(msg, 1); }
1716 UPB_INLINE upb_strview google_protobuf_DescriptorProto_name(const google_protobuf_DescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
1717 UPB_INLINE bool google_protobuf_DescriptorProto_has_field(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32)); }
1718 UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_field(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len); }
1719 UPB_INLINE bool google_protobuf_DescriptorProto_has_nested_type(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40)); }
1720 UPB_INLINE const google_protobuf_DescriptorProto* const* google_protobuf_DescriptorProto_nested_type(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len); }
1721 UPB_INLINE bool google_protobuf_DescriptorProto_has_enum_type(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(24, 48)); }
1722 UPB_INLINE const google_protobuf_EnumDescriptorProto* const* google_protobuf_DescriptorProto_enum_type(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
1723 UPB_INLINE bool google_protobuf_DescriptorProto_has_extension_range(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 56)); }
1724 UPB_INLINE const google_protobuf_DescriptorProto_ExtensionRange* const* google_protobuf_DescriptorProto_extension_range(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto_ExtensionRange* const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len); }
1725 UPB_INLINE bool google_protobuf_DescriptorProto_has_extension(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(32, 64)); }
1726 UPB_INLINE const google_protobuf_FieldDescriptorProto* const* google_protobuf_DescriptorProto_extension(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_FieldDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(32, 64), len); }
1727 UPB_INLINE bool google_protobuf_DescriptorProto_has_options(const google_protobuf_DescriptorProto *msg) { return _upb_has_field(msg, 2); }
1728 UPB_INLINE const google_protobuf_MessageOptions* google_protobuf_DescriptorProto_options(const google_protobuf_DescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_MessageOptions*); }
1729 UPB_INLINE bool google_protobuf_DescriptorProto_has_oneof_decl(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(36, 72)); }
1730 UPB_INLINE const google_protobuf_OneofDescriptorProto* const* google_protobuf_DescriptorProto_oneof_decl(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_OneofDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(36, 72), len); }
1731 UPB_INLINE bool google_protobuf_DescriptorProto_has_reserved_range(const google_protobuf_DescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(40, 80)); }
1732 UPB_INLINE const google_protobuf_DescriptorProto_ReservedRange* const* google_protobuf_DescriptorProto_reserved_range(const google_protobuf_DescriptorProto *msg, size_t *len) { return (const google_protobuf_DescriptorProto_ReservedRange* const*)_upb_array_accessor(msg, UPB_SIZE(40, 80), len); }
1733 UPB_INLINE upb_strview const* google_protobuf_DescriptorProto_reserved_name(const google_protobuf_DescriptorProto *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(44, 88), len); }
1859 UPB_INLINE google_protobuf_DescriptorProto_ExtensionRange *google_protobuf_DescriptorProto_ExtensionRange_parse(const char *buf, size_t size,
1864 UPB_INLINE char *google_protobuf_DescriptorProto_ExtensionRange_serialize(const google_protobuf_DescriptorProto_ExtensionRange *msg, upb_arena *arena, size_t *len) {
1868 UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_start(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return _upb_has_field(msg, 1); }
1869 UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_start(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
1870 UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_end(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return _upb_has_field(msg, 2); }
1871 UPB_INLINE int32_t google_protobuf_DescriptorProto_ExtensionRange_end(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
1872 UPB_INLINE bool google_protobuf_DescriptorProto_ExtensionRange_has_options(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return _upb_has_field(msg, 3); }
1873 UPB_INLINE const google_protobuf_ExtensionRangeOptions* google_protobuf_DescriptorProto_ExtensionRange_options(const google_protobuf_DescriptorProto_ExtensionRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), const google_protobuf_ExtensionRangeOptions*); }
1902 UPB_INLINE google_protobuf_DescriptorProto_ReservedRange *google_protobuf_DescriptorProto_ReservedRange_parse(const char *buf, size_t size,
1907 UPB_INLINE char *google_protobuf_DescriptorProto_ReservedRange_serialize(const google_protobuf_DescriptorProto_ReservedRange *msg, upb_arena *arena, size_t *len) {
1911 UPB_INLINE bool google_protobuf_DescriptorProto_ReservedRange_has_start(const google_protobuf_DescriptorProto_ReservedRange *msg) { return _upb_has_field(msg, 1); }
1912 UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_start(const google_protobuf_DescriptorProto_ReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
1913 UPB_INLINE bool google_protobuf_DescriptorProto_ReservedRange_has_end(const google_protobuf_DescriptorProto_ReservedRange *msg) { return _upb_has_field(msg, 2); }
1914 UPB_INLINE int32_t google_protobuf_DescriptorProto_ReservedRange_end(const google_protobuf_DescriptorProto_ReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
1930 UPB_INLINE google_protobuf_ExtensionRangeOptions *google_protobuf_ExtensionRangeOptions_parse(const char *buf, size_t size,
1935 UPB_INLINE char *google_protobuf_ExtensionRangeOptions_serialize(const google_protobuf_ExtensionRangeOptions *msg, upb_arena *arena, size_t *len) {
1939 UPB_INLINE bool google_protobuf_ExtensionRangeOptions_has_uninterpreted_option(const google_protobuf_ExtensionRangeOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
1940 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ExtensionRangeOptions_uninterpreted_option(const google_protobuf_ExtensionRangeOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
1961 UPB_INLINE google_protobuf_FieldDescriptorProto *google_protobuf_FieldDescriptorProto_parse(const char *buf, size_t size,
1966 UPB_INLINE char *google_protobuf_FieldDescriptorProto_serialize(const google_protobuf_FieldDescriptorProto *msg, upb_arena *arena, size_t *len) {
1970 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 6); }
1971 UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_name(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(36, 40), upb_strview); }
1972 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_extendee(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 7); }
1973 UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_extendee(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(44, 56), upb_strview); }
1974 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_number(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 3); }
1975 UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_number(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), int32_t); }
1976 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_label(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 1); }
1977 UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_label(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
1978 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 2); }
1979 UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_type(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t); }
1980 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_type_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 8); }
1981 UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_type_name(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(52, 72), upb_strview); }
1982 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_default_value(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 9); }
1983 UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_default_value(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(60, 88), upb_strview); }
1984 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_options(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 11); }
1985 UPB_INLINE const google_protobuf_FieldOptions* google_protobuf_FieldDescriptorProto_options(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(76, 120), const google_protobuf_FieldOptions*); }
1986 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_oneof_index(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 4); }
1987 UPB_INLINE int32_t google_protobuf_FieldDescriptorProto_oneof_index(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 28), int32_t); }
1988 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_json_name(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 10); }
1989 UPB_INLINE upb_strview google_protobuf_FieldDescriptorProto_json_name(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(68, 104), upb_strview); }
1990 UPB_INLINE bool google_protobuf_FieldDescriptorProto_has_proto3_optional(const google_protobuf_FieldDescriptorProto *msg) { return _upb_has_field(msg, 5); }
1991 UPB_INLINE bool google_protobuf_FieldDescriptorProto_proto3_optional(const google_protobuf_FieldDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), bool); }
2052 UPB_INLINE google_protobuf_OneofDescriptorProto *google_protobuf_OneofDescriptorProto_parse(const char *buf, size_t size,
2057 UPB_INLINE char *google_protobuf_OneofDescriptorProto_serialize(const google_protobuf_OneofDescriptorProto *msg, upb_arena *arena, size_t *len) {
2061 UPB_INLINE bool google_protobuf_OneofDescriptorProto_has_name(const google_protobuf_OneofDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2062 UPB_INLINE upb_strview google_protobuf_OneofDescriptorProto_name(const google_protobuf_OneofDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2063 UPB_INLINE bool google_protobuf_OneofDescriptorProto_has_options(const google_protobuf_OneofDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2064 UPB_INLINE const google_protobuf_OneofOptions* google_protobuf_OneofDescriptorProto_options(const google_protobuf_OneofDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_OneofOptions*); }
2089 UPB_INLINE google_protobuf_EnumDescriptorProto *google_protobuf_EnumDescriptorProto_parse(const char *buf, size_t size,
2094 UPB_INLINE char *google_protobuf_EnumDescriptorProto_serialize(const google_protobuf_EnumDescriptorProto *msg, upb_arena *arena, size_t *len) {
2098 UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_name(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2099 UPB_INLINE upb_strview google_protobuf_EnumDescriptorProto_name(const google_protobuf_EnumDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2100 UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_value(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32)); }
2101 UPB_INLINE const google_protobuf_EnumValueDescriptorProto* const* google_protobuf_EnumDescriptorProto_value(const google_protobuf_EnumDescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumValueDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len); }
2102 UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_options(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2103 UPB_INLINE const google_protobuf_EnumOptions* google_protobuf_EnumDescriptorProto_options(const google_protobuf_EnumDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_EnumOptions*); }
2104 UPB_INLINE bool google_protobuf_EnumDescriptorProto_has_reserved_range(const google_protobuf_EnumDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 40)); }
2105 UPB_INLINE const google_protobuf_EnumDescriptorProto_EnumReservedRange* const* google_protobuf_EnumDescriptorProto_reserved_range(const google_protobuf_EnumDescriptorProto *msg, size_t *len) { return (const google_protobuf_EnumDescriptorProto_EnumReservedRange* const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len); }
2106 UPB_INLINE upb_strview const* google_protobuf_EnumDescriptorProto_reserved_name(const google_protobuf_EnumDescriptorProto *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
2167 UPB_INLINE google_protobuf_EnumDescriptorProto_EnumReservedRange *google_protobuf_EnumDescriptorProto_EnumReservedRange_parse(const char *buf, size_t size,
2172 UPB_INLINE char *google_protobuf_EnumDescriptorProto_EnumReservedRange_serialize(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg, upb_arena *arena, size_t *len) {
2176 UPB_INLINE bool google_protobuf_EnumDescriptorProto_EnumReservedRange_has_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return _upb_has_field(msg, 1); }
2177 UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_start(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
2178 UPB_INLINE bool google_protobuf_EnumDescriptorProto_EnumReservedRange_has_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return _upb_has_field(msg, 2); }
2179 UPB_INLINE int32_t google_protobuf_EnumDescriptorProto_EnumReservedRange_end(const google_protobuf_EnumDescriptorProto_EnumReservedRange *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2195 UPB_INLINE google_protobuf_EnumValueDescriptorProto *google_protobuf_EnumValueDescriptorProto_parse(const char *buf, size_t size,
2200 UPB_INLINE char *google_protobuf_EnumValueDescriptorProto_serialize(const google_protobuf_EnumValueDescriptorProto *msg, upb_arena *arena, size_t *len) {
2204 UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_name(const google_protobuf_EnumValueDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2205 UPB_INLINE upb_strview google_protobuf_EnumValueDescriptorProto_name(const google_protobuf_EnumValueDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), upb_strview); }
2206 UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_number(const google_protobuf_EnumValueDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2207 UPB_INLINE int32_t google_protobuf_EnumValueDescriptorProto_number(const google_protobuf_EnumValueDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
2208 UPB_INLINE bool google_protobuf_EnumValueDescriptorProto_has_options(const google_protobuf_EnumValueDescriptorProto *msg) { return _upb_has_field(msg, 3); }
2209 UPB_INLINE const google_protobuf_EnumValueOptions* google_protobuf_EnumValueDescriptorProto_options(const google_protobuf_EnumValueDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 24), const google_protobuf_EnumValueOptions*); }
2238 UPB_INLINE google_protobuf_ServiceDescriptorProto *google_protobuf_ServiceDescriptorProto_parse(const char *buf, size_t size,
2243 UPB_INLINE char *google_protobuf_ServiceDescriptorProto_serialize(const google_protobuf_ServiceDescriptorProto *msg, upb_arena *arena, size_t *len) {
2247 UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_name(const google_protobuf_ServiceDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2248 UPB_INLINE upb_strview google_protobuf_ServiceDescriptorProto_name(const google_protobuf_ServiceDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2249 UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_method(const google_protobuf_ServiceDescriptorProto *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(16, 32)); }
2250 UPB_INLINE const google_protobuf_MethodDescriptorProto* const* google_protobuf_ServiceDescriptorProto_method(const google_protobuf_ServiceDescriptorProto *msg, size_t *len) { return (const google_protobuf_MethodDescriptorProto* const*)_upb_array_accessor(msg, UPB_SIZE(16, 32), len); }
2251 UPB_INLINE bool google_protobuf_ServiceDescriptorProto_has_options(const google_protobuf_ServiceDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2252 UPB_INLINE const google_protobuf_ServiceOptions* google_protobuf_ServiceDescriptorProto_options(const google_protobuf_ServiceDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const google_protobuf_ServiceOptions*); }
2290 UPB_INLINE google_protobuf_MethodDescriptorProto *google_protobuf_MethodDescriptorProto_parse(const char *buf, size_t size,
2295 UPB_INLINE char *google_protobuf_MethodDescriptorProto_serialize(const google_protobuf_MethodDescriptorProto *msg, upb_arena *arena, size_t *len) {
2299 UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_name(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 3); }
2300 UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_name(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2301 UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_input_type(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 4); }
2302 UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_input_type(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview); }
2303 UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_output_type(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 5); }
2304 UPB_INLINE upb_strview google_protobuf_MethodDescriptorProto_output_type(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(20, 40), upb_strview); }
2305 UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_options(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 6); }
2306 UPB_INLINE const google_protobuf_MethodOptions* google_protobuf_MethodDescriptorProto_options(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), const google_protobuf_MethodOptions*); }
2307 UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_client_streaming(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 1); }
2308 UPB_INLINE bool google_protobuf_MethodDescriptorProto_client_streaming(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2309 UPB_INLINE bool google_protobuf_MethodDescriptorProto_has_server_streaming(const google_protobuf_MethodDescriptorProto *msg) { return _upb_has_field(msg, 2); }
2310 UPB_INLINE bool google_protobuf_MethodDescriptorProto_server_streaming(const google_protobuf_MethodDescriptorProto *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool); }
2351 UPB_INLINE google_protobuf_FileOptions *google_protobuf_FileOptions_parse(const char *buf, size_t size,
2356 UPB_INLINE char *google_protobuf_FileOptions_serialize(const google_protobuf_FileOptions *msg, upb_arena *arena, size_t *len) {
2360 UPB_INLINE bool google_protobuf_FileOptions_has_java_package(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 11); }
2361 UPB_INLINE upb_strview google_protobuf_FileOptions_java_package(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(28, 32), upb_strview); }
2362 UPB_INLINE bool google_protobuf_FileOptions_has_java_outer_classname(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 12); }
2363 UPB_INLINE upb_strview google_protobuf_FileOptions_java_outer_classname(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(36, 48), upb_strview); }
2364 UPB_INLINE bool google_protobuf_FileOptions_has_optimize_for(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 1); }
2365 UPB_INLINE int32_t google_protobuf_FileOptions_optimize_for(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2366 UPB_INLINE bool google_protobuf_FileOptions_has_java_multiple_files(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 2); }
2367 UPB_INLINE bool google_protobuf_FileOptions_java_multiple_files(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool); }
2368 UPB_INLINE bool google_protobuf_FileOptions_has_go_package(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 13); }
2369 UPB_INLINE upb_strview google_protobuf_FileOptions_go_package(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(44, 64), upb_strview); }
2370 UPB_INLINE bool google_protobuf_FileOptions_has_cc_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 3); }
2371 UPB_INLINE bool google_protobuf_FileOptions_cc_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(17, 17), bool); }
2372 UPB_INLINE bool google_protobuf_FileOptions_has_java_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 4); }
2373 UPB_INLINE bool google_protobuf_FileOptions_java_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(18, 18), bool); }
2374 UPB_INLINE bool google_protobuf_FileOptions_has_py_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 5); }
2375 UPB_INLINE bool google_protobuf_FileOptions_py_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(19, 19), bool); }
2376 UPB_INLINE bool google_protobuf_FileOptions_has_java_generate_equals_and_hash(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 6); }
2377 UPB_INLINE bool google_protobuf_FileOptions_java_generate_equals_and_hash(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(20, 20), bool); }
2378 UPB_INLINE bool google_protobuf_FileOptions_has_deprecated(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 7); }
2379 UPB_INLINE bool google_protobuf_FileOptions_deprecated(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(21, 21), bool); }
2380 UPB_INLINE bool google_protobuf_FileOptions_has_java_string_check_utf8(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 8); }
2381 UPB_INLINE bool google_protobuf_FileOptions_java_string_check_utf8(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(22, 22), bool); }
2382 UPB_INLINE bool google_protobuf_FileOptions_has_cc_enable_arenas(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 9); }
2383 UPB_INLINE bool google_protobuf_FileOptions_cc_enable_arenas(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(23, 23), bool); }
2384 UPB_INLINE bool google_protobuf_FileOptions_has_objc_class_prefix(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 14); }
2385 UPB_INLINE upb_strview google_protobuf_FileOptions_objc_class_prefix(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(52, 80), upb_strview); }
2386 UPB_INLINE bool google_protobuf_FileOptions_has_csharp_namespace(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 15); }
2387 UPB_INLINE upb_strview google_protobuf_FileOptions_csharp_namespace(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(60, 96), upb_strview); }
2388 UPB_INLINE bool google_protobuf_FileOptions_has_swift_prefix(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 16); }
2389 UPB_INLINE upb_strview google_protobuf_FileOptions_swift_prefix(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(68, 112), upb_strview); }
2390 UPB_INLINE bool google_protobuf_FileOptions_has_php_class_prefix(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 17); }
2391 UPB_INLINE upb_strview google_protobuf_FileOptions_php_class_prefix(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(76, 128), upb_strview); }
2392 UPB_INLINE bool google_protobuf_FileOptions_has_php_namespace(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 18); }
2393 UPB_INLINE upb_strview google_protobuf_FileOptions_php_namespace(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(84, 144), upb_strview); }
2394 UPB_INLINE bool google_protobuf_FileOptions_has_php_generic_services(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 10); }
2395 UPB_INLINE bool google_protobuf_FileOptions_php_generic_services(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
2396 UPB_INLINE bool google_protobuf_FileOptions_has_php_metadata_namespace(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 19); }
2397 UPB_INLINE upb_strview google_protobuf_FileOptions_php_metadata_namespace(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(92, 160), upb_strview); }
2398 UPB_INLINE bool google_protobuf_FileOptions_has_ruby_package(const google_protobuf_FileOptions *msg) { return _upb_has_field(msg, 20); }
2399 UPB_INLINE upb_strview google_protobuf_FileOptions_ruby_package(const google_protobuf_FileOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(100, 176), upb_strview); }
2400 UPB_INLINE bool google_protobuf_FileOptions_has_uninterpreted_option(const google_protobuf_FileOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(108, 192)); }
2401 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FileOptions_uninterpreted_option(const google_protobuf_FileOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(108, 192), len); }
2502 UPB_INLINE google_protobuf_MessageOptions *google_protobuf_MessageOptions_parse(const char *buf, size_t size,
2507 UPB_INLINE char *google_protobuf_MessageOptions_serialize(const google_protobuf_MessageOptions *msg, upb_arena *arena, size_t *len) {
2511 UPB_INLINE bool google_protobuf_MessageOptions_has_message_set_wire_format(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 1); }
2512 UPB_INLINE bool google_protobuf_MessageOptions_message_set_wire_format(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2513 UPB_INLINE bool google_protobuf_MessageOptions_has_no_standard_descriptor_accessor(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 2); }
2514 UPB_INLINE bool google_protobuf_MessageOptions_no_standard_descriptor_accessor(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool); }
2515 UPB_INLINE bool google_protobuf_MessageOptions_has_deprecated(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 3); }
2516 UPB_INLINE bool google_protobuf_MessageOptions_deprecated(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(3, 3), bool); }
2517 UPB_INLINE bool google_protobuf_MessageOptions_has_map_entry(const google_protobuf_MessageOptions *msg) { return _upb_has_field(msg, 4); }
2518 UPB_INLINE bool google_protobuf_MessageOptions_map_entry(const google_protobuf_MessageOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), bool); }
2519 UPB_INLINE bool google_protobuf_MessageOptions_has_uninterpreted_option(const google_protobuf_MessageOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(8, 8)); }
2520 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MessageOptions_uninterpreted_option(const google_protobuf_MessageOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(8, 8), len); }
2557 UPB_INLINE google_protobuf_FieldOptions *google_protobuf_FieldOptions_parse(const char *buf, size_t size,
2562 UPB_INLINE char *google_protobuf_FieldOptions_serialize(const google_protobuf_FieldOptions *msg, upb_arena *arena, size_t *len) {
2566 UPB_INLINE bool google_protobuf_FieldOptions_has_ctype(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 1); }
2567 UPB_INLINE int32_t google_protobuf_FieldOptions_ctype(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2568 UPB_INLINE bool google_protobuf_FieldOptions_has_packed(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 3); }
2569 UPB_INLINE bool google_protobuf_FieldOptions_packed(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), bool); }
2570 UPB_INLINE bool google_protobuf_FieldOptions_has_deprecated(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 4); }
2571 UPB_INLINE bool google_protobuf_FieldOptions_deprecated(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(25, 25), bool); }
2572 UPB_INLINE bool google_protobuf_FieldOptions_has_lazy(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 5); }
2573 UPB_INLINE bool google_protobuf_FieldOptions_lazy(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(26, 26), bool); }
2574 UPB_INLINE bool google_protobuf_FieldOptions_has_jstype(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 2); }
2575 UPB_INLINE int32_t google_protobuf_FieldOptions_jstype(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int32_t); }
2576 UPB_INLINE bool google_protobuf_FieldOptions_has_weak(const google_protobuf_FieldOptions *msg) { return _upb_has_field(msg, 6); }
2577 UPB_INLINE bool google_protobuf_FieldOptions_weak(const google_protobuf_FieldOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(27, 27), bool); }
2578 UPB_INLINE bool google_protobuf_FieldOptions_has_uninterpreted_option(const google_protobuf_FieldOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(28, 32)); }
2579 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_FieldOptions_uninterpreted_option(const google_protobuf_FieldOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(28, 32), len); }
2624 UPB_INLINE google_protobuf_OneofOptions *google_protobuf_OneofOptions_parse(const char *buf, size_t size,
2629 UPB_INLINE char *google_protobuf_OneofOptions_serialize(const google_protobuf_OneofOptions *msg, upb_arena *arena, size_t *len) {
2633 UPB_INLINE bool google_protobuf_OneofOptions_has_uninterpreted_option(const google_protobuf_OneofOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
2634 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_OneofOptions_uninterpreted_option(const google_protobuf_OneofOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
2655 UPB_INLINE google_protobuf_EnumOptions *google_protobuf_EnumOptions_parse(const char *buf, size_t size,
2660 UPB_INLINE char *google_protobuf_EnumOptions_serialize(const google_protobuf_EnumOptions *msg, upb_arena *arena, size_t *len) {
2664 UPB_INLINE bool google_protobuf_EnumOptions_has_allow_alias(const google_protobuf_EnumOptions *msg) { return _upb_has_field(msg, 1); }
2665 UPB_INLINE bool google_protobuf_EnumOptions_allow_alias(const google_protobuf_EnumOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2666 UPB_INLINE bool google_protobuf_EnumOptions_has_deprecated(const google_protobuf_EnumOptions *msg) { return _upb_has_field(msg, 2); }
2667 UPB_INLINE bool google_protobuf_EnumOptions_deprecated(const google_protobuf_EnumOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(2, 2), bool); }
2668 UPB_INLINE bool google_protobuf_EnumOptions_has_uninterpreted_option(const google_protobuf_EnumOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8)); }
2669 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumOptions_uninterpreted_option(const google_protobuf_EnumOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
2698 UPB_INLINE google_protobuf_EnumValueOptions *google_protobuf_EnumValueOptions_parse(const char *buf, size_t size,
2703 UPB_INLINE char *google_protobuf_EnumValueOptions_serialize(const google_protobuf_EnumValueOptions *msg, upb_arena *arena, size_t *len) {
2707 UPB_INLINE bool google_protobuf_EnumValueOptions_has_deprecated(const google_protobuf_EnumValueOptions *msg) { return _upb_has_field(msg, 1); }
2708 UPB_INLINE bool google_protobuf_EnumValueOptions_deprecated(const google_protobuf_EnumValueOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2709 UPB_INLINE bool google_protobuf_EnumValueOptions_has_uninterpreted_option(const google_protobuf_EnumValueOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8)); }
2710 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_EnumValueOptions_uninterpreted_option(const google_protobuf_EnumValueOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
2735 UPB_INLINE google_protobuf_ServiceOptions *google_protobuf_ServiceOptions_parse(const char *buf, size_t size,
2740 UPB_INLINE char *google_protobuf_ServiceOptions_serialize(const google_protobuf_ServiceOptions *msg, upb_arena *arena, size_t *len) {
2744 UPB_INLINE bool google_protobuf_ServiceOptions_has_deprecated(const google_protobuf_ServiceOptions *msg) { return _upb_has_field(msg, 1); }
2745 UPB_INLINE bool google_protobuf_ServiceOptions_deprecated(const google_protobuf_ServiceOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2746 UPB_INLINE bool google_protobuf_ServiceOptions_has_uninterpreted_option(const google_protobuf_ServiceOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(4, 8)); }
2747 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_ServiceOptions_uninterpreted_option(const google_protobuf_ServiceOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(4, 8), len); }
2772 UPB_INLINE google_protobuf_MethodOptions *google_protobuf_MethodOptions_parse(const char *buf, size_t size,
2777 UPB_INLINE char *google_protobuf_MethodOptions_serialize(const google_protobuf_MethodOptions *msg, upb_arena *arena, size_t *len) {
2781 UPB_INLINE bool google_protobuf_MethodOptions_has_deprecated(const google_protobuf_MethodOptions *msg) { return _upb_has_field(msg, 2); }
2782 UPB_INLINE bool google_protobuf_MethodOptions_deprecated(const google_protobuf_MethodOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), bool); }
2783 UPB_INLINE bool google_protobuf_MethodOptions_has_idempotency_level(const google_protobuf_MethodOptions *msg) { return _upb_has_field(msg, 1); }
2784 UPB_INLINE int32_t google_protobuf_MethodOptions_idempotency_level(const google_protobuf_MethodOptions *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
2785 UPB_INLINE bool google_protobuf_MethodOptions_has_uninterpreted_option(const google_protobuf_MethodOptions *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(20, 24)); }
2786 UPB_INLINE const google_protobuf_UninterpretedOption* const* google_protobuf_MethodOptions_uninterpreted_option(const google_protobuf_MethodOptions *msg, size_t *len) { return (const google_protobuf_UninterpretedOption* const*)_upb_array_accessor(msg, UPB_SIZE(20, 24), len); }
2815 UPB_INLINE google_protobuf_UninterpretedOption *google_protobuf_UninterpretedOption_parse(const char *buf, size_t size,
2820 UPB_INLINE char *google_protobuf_UninterpretedOption_serialize(const google_protobuf_UninterpretedOption *msg, upb_arena *arena, size_t *len) {
2824 UPB_INLINE bool google_protobuf_UninterpretedOption_has_name(const google_protobuf_UninterpretedOption *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(56, 80)); }
2825 UPB_INLINE const google_protobuf_UninterpretedOption_NamePart* const* google_protobuf_UninterpretedOption_name(const google_protobuf_UninterpretedOption *msg, size_t *len) { return (const google_protobuf_UninterpretedOption_NamePart* const*)_upb_array_accessor(msg, UPB_SIZE(56, 80), len); }
2826 UPB_INLINE bool google_protobuf_UninterpretedOption_has_identifier_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 4); }
2827 UPB_INLINE upb_strview google_protobuf_UninterpretedOption_identifier_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(32, 32), upb_strview); }
2828 UPB_INLINE bool google_protobuf_UninterpretedOption_has_positive_int_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 1); }
2829 UPB_INLINE uint64_t google_protobuf_UninterpretedOption_positive_int_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), uint64_t); }
2830 UPB_INLINE bool google_protobuf_UninterpretedOption_has_negative_int_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 2); }
2831 UPB_INLINE int64_t google_protobuf_UninterpretedOption_negative_int_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(16, 16), int64_t); }
2832 UPB_INLINE bool google_protobuf_UninterpretedOption_has_double_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 3); }
2833 UPB_INLINE double google_protobuf_UninterpretedOption_double_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(24, 24), double); }
2834 UPB_INLINE bool google_protobuf_UninterpretedOption_has_string_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 5); }
2835 UPB_INLINE upb_strview google_protobuf_UninterpretedOption_string_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(40, 48), upb_strview); }
2836 UPB_INLINE bool google_protobuf_UninterpretedOption_has_aggregate_value(const google_protobuf_UninterpretedOption *msg) { return _upb_has_field(msg, 6); }
2837 UPB_INLINE upb_strview google_protobuf_UninterpretedOption_aggregate_value(const google_protobuf_UninterpretedOption *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(48, 64), upb_strview); }
2882 UPB_INLINE google_protobuf_UninterpretedOption_NamePart *google_protobuf_UninterpretedOption_NamePart_parse(const char *buf, size_t size,
2887 UPB_INLINE char *google_protobuf_UninterpretedOption_NamePart_serialize(const google_protobuf_UninterpretedOption_NamePart *msg, upb_arena *arena, size_t *len) {
2891 UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_has_name_part(const google_protobuf_UninterpretedOption_NamePart *msg) { return _upb_has_field(msg, 2); }
2892 UPB_INLINE upb_strview google_protobuf_UninterpretedOption_NamePart_name_part(const google_protobuf_UninterpretedOption_NamePart *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2893 UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_has_is_extension(const google_protobuf_UninterpretedOption_NamePart *msg) { return _upb_has_field(msg, 1); }
2894 UPB_INLINE bool google_protobuf_UninterpretedOption_NamePart_is_extension(const google_protobuf_UninterpretedOption_NamePart *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(1, 1), bool); }
2910 UPB_INLINE google_protobuf_SourceCodeInfo *google_protobuf_SourceCodeInfo_parse(const char *buf, size_t size,
2915 UPB_INLINE char *google_protobuf_SourceCodeInfo_serialize(const google_protobuf_SourceCodeInfo *msg, upb_arena *arena, size_t *len) {
2919 UPB_INLINE bool google_protobuf_SourceCodeInfo_has_location(const google_protobuf_SourceCodeInfo *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
2920 UPB_INLINE const google_protobuf_SourceCodeInfo_Location* const* google_protobuf_SourceCodeInfo_location(const google_protobuf_SourceCodeInfo *msg, size_t *len) { return (const google_protobuf_SourceCodeInfo_Location* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
2941 UPB_INLINE google_protobuf_SourceCodeInfo_Location *google_protobuf_SourceCodeInfo_Location_parse(const char *buf, size_t size,
2946 UPB_INLINE char *google_protobuf_SourceCodeInfo_Location_serialize(const google_protobuf_SourceCodeInfo_Location *msg, upb_arena *arena, size_t *len) {
2950 UPB_INLINE int32_t const* google_protobuf_SourceCodeInfo_Location_path(const google_protobuf_SourceCodeInfo_Location *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(20, 40), len); }
2951 UPB_INLINE int32_t const* google_protobuf_SourceCodeInfo_Location_span(const google_protobuf_SourceCodeInfo_Location *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(24, 48), len); }
2952 UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_has_leading_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return _upb_has_field(msg, 1); }
2953 UPB_INLINE upb_strview google_protobuf_SourceCodeInfo_Location_leading_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
2954 UPB_INLINE bool google_protobuf_SourceCodeInfo_Location_has_trailing_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return _upb_has_field(msg, 2); }
2955 UPB_INLINE upb_strview google_protobuf_SourceCodeInfo_Location_trailing_comments(const google_protobuf_SourceCodeInfo_Location *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), upb_strview); }
2956 UPB_INLINE upb_strview const* google_protobuf_SourceCodeInfo_Location_leading_detached_comments(const google_protobuf_SourceCodeInfo_Location *msg, size_t *len) { return (upb_strview const*)_upb_array_accessor(msg, UPB_SIZE(28, 56), len); }
3002 UPB_INLINE google_protobuf_GeneratedCodeInfo *google_protobuf_GeneratedCodeInfo_parse(const char *buf, size_t size,
3007 UPB_INLINE char *google_protobuf_GeneratedCodeInfo_serialize(const google_protobuf_GeneratedCodeInfo *msg, upb_arena *arena, size_t *len) {
3011 UPB_INLINE bool google_protobuf_GeneratedCodeInfo_has_annotation(const google_protobuf_GeneratedCodeInfo *msg) { return _upb_has_submsg_nohasbit(msg, UPB_SIZE(0, 0)); }
3012 UPB_INLINE const google_protobuf_GeneratedCodeInfo_Annotation* const* google_protobuf_GeneratedCodeInfo_annotation(const google_protobuf_GeneratedCodeInfo *msg, size_t *len) { return (const google_protobuf_GeneratedCodeInfo_Annotation* const*)_upb_array_accessor(msg, UPB_SIZE(0, 0), len); }
3033 UPB_INLINE google_protobuf_GeneratedCodeInfo_Annotation *google_protobuf_GeneratedCodeInfo_Annotation_parse(const char *buf, size_t size,
3038 UPB_INLINE char *google_protobuf_GeneratedCodeInfo_Annotation_serialize(const google_protobuf_GeneratedCodeInfo_Annotation *msg, upb_arena *arena, size_t *len) {
3042 UPB_INLINE int32_t const* google_protobuf_GeneratedCodeInfo_Annotation_path(const google_protobuf_GeneratedCodeInfo_Annotation *msg, size_t *len) { return (int32_t const*)_upb_array_accessor(msg, UPB_SIZE(20, 32), len); }
3043 UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_source_file(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return _upb_has_field(msg, 3); }
3044 UPB_INLINE upb_strview google_protobuf_GeneratedCodeInfo_Annotation_source_file(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 16), upb_strview); }
3045 UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_begin(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return _upb_has_field(msg, 1); }
3046 UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_begin(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 4), int32_t); }
3047 UPB_INLINE bool google_protobuf_GeneratedCodeInfo_Annotation_has_end(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return _upb_has_field(msg, 2); }
3048 UPB_INLINE int32_t google_protobuf_GeneratedCodeInfo_Annotation_end(const google_protobuf_GeneratedCodeInfo_Annotation *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(8, 8), int32_t); }
3151 const char *upb_fielddef_fullname(const upb_fielddef *f);
3152 upb_fieldtype_t upb_fielddef_type(const upb_fielddef *f);
3153 upb_descriptortype_t upb_fielddef_descriptortype(const upb_fielddef *f);
3154 upb_label_t upb_fielddef_label(const upb_fielddef *f);
3155 uint32_t upb_fielddef_number(const upb_fielddef *f);
3156 const char *upb_fielddef_name(const upb_fielddef *f);
3157 const char *upb_fielddef_jsonname(const upb_fielddef *f);
3158 bool upb_fielddef_isextension(const upb_fielddef *f);
3159 bool upb_fielddef_lazy(const upb_fielddef *f);
3160 bool upb_fielddef_packed(const upb_fielddef *f);
3161 const upb_filedef *upb_fielddef_file(const upb_fielddef *f);
3162 const upb_msgdef *upb_fielddef_containingtype(const upb_fielddef *f);
3163 const upb_oneofdef *upb_fielddef_containingoneof(const upb_fielddef *f);
3164 const upb_oneofdef *upb_fielddef_realcontainingoneof(const upb_fielddef *f);
3165 uint32_t upb_fielddef_index(const upb_fielddef *f);
3166 bool upb_fielddef_issubmsg(const upb_fielddef *f);
3167 bool upb_fielddef_isstring(const upb_fielddef *f);
3168 bool upb_fielddef_isseq(const upb_fielddef *f);
3169 bool upb_fielddef_isprimitive(const upb_fielddef *f);
3170 bool upb_fielddef_ismap(const upb_fielddef *f);
3171 int64_t upb_fielddef_defaultint64(const upb_fielddef *f);
3172 int32_t upb_fielddef_defaultint32(const upb_fielddef *f);
3173 uint64_t upb_fielddef_defaultuint64(const upb_fielddef *f);
3174 uint32_t upb_fielddef_defaultuint32(const upb_fielddef *f);
3175 bool upb_fielddef_defaultbool(const upb_fielddef *f);
3176 float upb_fielddef_defaultfloat(const upb_fielddef *f);
3177 double upb_fielddef_defaultdouble(const upb_fielddef *f);
3178 const char *upb_fielddef_defaultstr(const upb_fielddef *f, size_t *len);
3179 bool upb_fielddef_hassubdef(const upb_fielddef *f);
3180 bool upb_fielddef_haspresence(const upb_fielddef *f);
3181 const upb_msgdef *upb_fielddef_msgsubdef(const upb_fielddef *f);
3182 const upb_enumdef *upb_fielddef_enumsubdef(const upb_fielddef *f);
3183 const upb_msglayout_field *upb_fielddef_layout(const upb_fielddef *f);
3186 uint32_t upb_fielddef_selectorbase(const upb_fielddef *f);
3192 const char *upb_oneofdef_name(const upb_oneofdef *o);
3193 const upb_msgdef *upb_oneofdef_containingtype(const upb_oneofdef *o);
3194 int upb_oneofdef_numfields(const upb_oneofdef *o);
3195 uint32_t upb_oneofdef_index(const upb_oneofdef *o);
3196 bool upb_oneofdef_issynthetic(const upb_oneofdef *o);
3202 const upb_fielddef *upb_oneofdef_ntof(const upb_oneofdef *o,
3203                                       const char *name, size_t length);
3204 UPB_INLINE const upb_fielddef *upb_oneofdef_ntofz(const upb_oneofdef *o,
3205                                                   const char *name) {
3208 const upb_fielddef *upb_oneofdef_itof(const upb_oneofdef *o, uint32_t num);
3215 void upb_oneof_begin(upb_oneof_iter *iter, const upb_oneofdef *o);
3218 upb_fielddef *upb_oneof_iter_field(const upb_oneof_iter *iter);
3220 bool upb_oneof_iter_isequal(const upb_oneof_iter *iter1,
3221                             const upb_oneof_iter *iter2);
3244 const char *upb_msgdef_fullname(const upb_msgdef *m);
3245 const upb_filedef *upb_msgdef_file(const upb_msgdef *m);
3246 const char *upb_msgdef_name(const upb_msgdef *m);
3247 int upb_msgdef_numfields(const upb_msgdef *m);
3248 int upb_msgdef_numoneofs(const upb_msgdef *m);
3249 int upb_msgdef_numrealoneofs(const upb_msgdef *m);
3250 upb_syntax_t upb_msgdef_syntax(const upb_msgdef *m);
3251 bool upb_msgdef_mapentry(const upb_msgdef *m);
3252 upb_wellknowntype_t upb_msgdef_wellknowntype(const upb_msgdef *m);
3253 bool upb_msgdef_isnumberwrapper(const upb_msgdef *m);
3254 const upb_fielddef *upb_msgdef_itof(const upb_msgdef *m, uint32_t i);
3255 const upb_fielddef *upb_msgdef_ntof(const upb_msgdef *m, const char *name,
3257 const upb_oneofdef *upb_msgdef_ntoo(const upb_msgdef *m, const char *name,
3259 const upb_msglayout *upb_msgdef_layout(const upb_msgdef *m);
3260 const upb_fielddef *_upb_msgdef_field(const upb_msgdef *m, int i);
3262 UPB_INLINE const upb_oneofdef *upb_msgdef_ntooz(const upb_msgdef *m,
3263                                                const char *name) {
3267 UPB_INLINE const upb_fielddef *upb_msgdef_ntofz(const upb_msgdef *m,
3268                                                 const char *name) {
3273 size_t upb_msgdef_selectorcount(const upb_msgdef *m);
3274 uint32_t upb_msgdef_submsgfieldcount(const upb_msgdef *m);
3279 bool upb_msgdef_lookupname(const upb_msgdef *m, const char *name, size_t len,
3280                            const upb_fielddef **f, const upb_oneofdef **o);
3282 UPB_INLINE bool upb_msgdef_lookupnamez(const upb_msgdef *m, const char *name,
3283                                        const upb_fielddef **f,
3284                                        const upb_oneofdef **o) {
3289 const upb_fielddef *upb_msgdef_lookupjsonname(const upb_msgdef *m,
3290                                               const char *name, size_t len);
3302  * For C we don't have separate iterators for const and non-const.
3304  * const if the upb_msgdef* is const. */
3305 void upb_msg_field_begin(upb_msg_field_iter *iter, const upb_msgdef *m);
3307 bool upb_msg_field_done(const upb_msg_field_iter *iter);
3308 upb_fielddef *upb_msg_iter_field(const upb_msg_field_iter *iter);
3310 bool upb_msg_field_iter_isequal(const upb_msg_field_iter * iter1,
3311                                 const upb_msg_field_iter * iter2);
3315 void upb_msg_oneof_begin(upb_msg_oneof_iter * iter, const upb_msgdef *m);
3317 bool upb_msg_oneof_done(const upb_msg_oneof_iter *iter);
3318 const upb_oneofdef *upb_msg_iter_oneof(const upb_msg_oneof_iter *iter);
3320 bool upb_msg_oneof_iter_isequal(const upb_msg_oneof_iter *iter1,
3321                                 const upb_msg_oneof_iter *iter2);
3327 const char *upb_enumdef_fullname(const upb_enumdef *e);
3328 const char *upb_enumdef_name(const upb_enumdef *e);
3329 const upb_filedef *upb_enumdef_file(const upb_enumdef *e);
3330 int32_t upb_enumdef_default(const upb_enumdef *e);
3331 int upb_enumdef_numvals(const upb_enumdef *e);
3338 bool upb_enumdef_ntoi(const upb_enumdef *e, const char *name, size_t len,
3340 UPB_INLINE bool upb_enumdef_ntoiz(const upb_enumdef *e,
3341                                   const char *name, int32_t *num) {
3344 const char *upb_enumdef_iton(const upb_enumdef *e, int32_t num);
3351 void upb_enum_begin(upb_enum_iter *iter, const upb_enumdef *e);
3354 const char *upb_enum_iter_name(upb_enum_iter *iter);
3359 const char *upb_filedef_name(const upb_filedef *f);
3360 const char *upb_filedef_package(const upb_filedef *f);
3361 const char *upb_filedef_phpprefix(const upb_filedef *f);
3362 const char *upb_filedef_phpnamespace(const upb_filedef *f);
3363 upb_syntax_t upb_filedef_syntax(const upb_filedef *f);
3364 int upb_filedef_depcount(const upb_filedef *f);
3365 int upb_filedef_msgcount(const upb_filedef *f);
3366 int upb_filedef_enumcount(const upb_filedef *f);
3367 const upb_filedef *upb_filedef_dep(const upb_filedef *f, int i);
3368 const upb_msgdef *upb_filedef_msg(const upb_filedef *f, int i);
3369 const upb_enumdef *upb_filedef_enum(const upb_filedef *f, int i);
3375 const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym);
3376 const upb_msgdef *upb_symtab_lookupmsg2(
3377     const upb_symtab *s, const char *sym, size_t len);
3378 const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym);
3379 const upb_filedef *upb_symtab_lookupfile(const upb_symtab *s, const char *name);
3380 int upb_symtab_filecount(const upb_symtab *s);
3381 const upb_filedef *upb_symtab_addfile(
3382     upb_symtab *s, const google_protobuf_FileDescriptorProto *file,
3388   const upb_msglayout **layouts;  /* Pre-order layouts of all messages. */
3389   const char *filename;
3393 bool _upb_symtab_loaddefinit(upb_symtab *s, const upb_def_init *init);
3415   const upb_map* map_val;
3416   const upb_msg* msg_val;
3417   const upb_array* array_val;
3430 upb_msg *upb_msg_new(const upb_msgdef *m, upb_arena *a);
3433 upb_msgval upb_msg_get(const upb_msg *msg, const upb_fielddef *f);
3438 upb_mutmsgval upb_msg_mutable(upb_msg *msg, const upb_fielddef *f, upb_arena *a);
3441 bool upb_msg_has(const upb_msg *msg, const upb_fielddef *f);
3444 bool upb_msg_hasoneof(const upb_msg *msg, const upb_oneofdef *o);
3448 void upb_msg_set(upb_msg *msg, const upb_fielddef *f, upb_msgval val,
3452 void upb_msg_clearfield(upb_msg *msg, const upb_fielddef *f);
3457  * const upb_fielddef *f;
3469 bool upb_msg_next(const upb_msg *msg, const upb_msgdef *m,
3470                   const upb_symtab *ext_pool, const upb_fielddef **f,
3475 void upb_msg_addunknown(upb_msg *msg, const char *data, size_t len,
3479 const char *upb_msg_getunknown(const upb_msg *msg, size_t *len);
3487 size_t upb_array_size(const upb_array *arr);
3490 upb_msgval upb_array_get(const upb_array *arr, size_t i);
3509 size_t upb_map_size(const upb_map *map);
3514 bool upb_map_get(const upb_map *map, upb_msgval key, upb_msgval *val);
3540 bool upb_mapiter_next(const upb_map *map, size_t *iter);
3543 upb_msgval upb_mapiter_key(const upb_map *map, size_t iter);
3544 upb_msgval upb_mapiter_value(const upb_map *map, size_t iter);
3547  * iterator must not have been initialized const. */
3637 template<class T> const void *UniquePtrForType() {
3638   static const char ch = 0;
3647   const void *handler_data;
3648   const void *closure_type;
3649   const void *return_closure_type;
3660   const char *buf;
3667   const void *obj;
3668   const void *objtype;
3672   void SetAttachedObject(const T* _obj) {
3678   const T *GetAttachedObject() const {
3679     return objtype == UniquePtrForType<T>() ? static_cast<const T *>(obj)
3689 typedef bool upb_unknown_handlerfunc(void *c, const void *hd, const char *buf,
3691 typedef bool upb_startmsg_handlerfunc(void *c, const void*);
3692 typedef bool upb_endmsg_handlerfunc(void *c, const void *, upb_status *status);
3693 typedef void* upb_startfield_handlerfunc(void *c, const void *hd);
3694 typedef bool upb_endfield_handlerfunc(void *c, const void *hd);
3695 typedef bool upb_int32_handlerfunc(void *c, const void *hd, int32_t val);
3696 typedef bool upb_int64_handlerfunc(void *c, const void *hd, int64_t val);
3697 typedef bool upb_uint32_handlerfunc(void *c, const void *hd, uint32_t val);
3698 typedef bool upb_uint64_handlerfunc(void *c, const void *hd, uint64_t val);
3699 typedef bool upb_float_handlerfunc(void *c, const void *hd, float val);
3700 typedef bool upb_double_handlerfunc(void *c, const void *hd, double val);
3701 typedef bool upb_bool_handlerfunc(void *c, const void *hd, bool val);
3702 typedef void *upb_startstr_handlerfunc(void *c, const void *hd,
3704 typedef size_t upb_string_handlerfunc(void *c, const void *hd, const char *buf,
3705                                       size_t n, const upb_bufhandle* handle);
3715 const upb_status *upb_handlers_status(upb_handlers *h);
3717 const upb_msgdef *upb_handlers_msgdef(const upb_handlers *h);
3720                              const upb_handlerattr *attr);
3722                               const upb_handlerattr *attr);
3724                             const upb_handlerattr *attr);
3725 bool upb_handlers_setint32(upb_handlers *h, const upb_fielddef *f,
3727                            const upb_handlerattr *attr);
3728 bool upb_handlers_setint64(upb_handlers *h, const upb_fielddef *f,
3730                            const upb_handlerattr *attr);
3731 bool upb_handlers_setuint32(upb_handlers *h, const upb_fielddef *f,
3733                             const upb_handlerattr *attr);
3734 bool upb_handlers_setuint64(upb_handlers *h, const upb_fielddef *f,
3736                             const upb_handlerattr *attr);
3737 bool upb_handlers_setfloat(upb_handlers *h, const upb_fielddef *f,
3739                            const upb_handlerattr *attr);
3740 bool upb_handlers_setdouble(upb_handlers *h, const upb_fielddef *f,
3742                             const upb_handlerattr *attr);
3743 bool upb_handlers_setbool(upb_handlers *h, const upb_fielddef *f,
3745                           const upb_handlerattr *attr);
3746 bool upb_handlers_setstartstr(upb_handlers *h, const upb_fielddef *f,
3748                               const upb_handlerattr *attr);
3749 bool upb_handlers_setstring(upb_handlers *h, const upb_fielddef *f,
3751                             const upb_handlerattr *attr);
3752 bool upb_handlers_setendstr(upb_handlers *h, const upb_fielddef *f,
3754                             const upb_handlerattr *attr);
3755 bool upb_handlers_setstartseq(upb_handlers *h, const upb_fielddef *f,
3757                               const upb_handlerattr *attr);
3758 bool upb_handlers_setstartsubmsg(upb_handlers *h, const upb_fielddef *f,
3760                                  const upb_handlerattr *attr);
3761 bool upb_handlers_setendsubmsg(upb_handlers *h, const upb_fielddef *f,
3763                                const upb_handlerattr *attr);
3764 bool upb_handlers_setendseq(upb_handlers *h, const upb_fielddef *f,
3766                             const upb_handlerattr *attr);
3769 const upb_handlers *upb_handlers_getsubhandlers(const upb_handlers *h,
3770                                                 const upb_fielddef *f);
3771 const upb_handlers *upb_handlers_getsubhandlers_sel(const upb_handlers *h,
3773 upb_func *upb_handlers_gethandler(const upb_handlers *h, upb_selector_t s,
3774                                   const void **handler_data);
3775 bool upb_handlers_getattr(const upb_handlers *h, upb_selector_t s,
3779 upb_handlertype_t upb_handlers_getprimitivehandlertype(const upb_fielddef *f);
3780 bool upb_handlers_getselector(const upb_fielddef *f, upb_handlertype_t type,
3798  *   void OnValue1(MyClosure* c, const MyHandlerData* d, int32_t val) {
3848   void AddCleanup(upb_handlers* h) const;
3849   FuncPtr handler() const { return handler_; }
3850   const upb_handlerattr& attr() const { return attr_; }
3853   Handler(const Handler&) = delete;
3854   Handler& operator=(const Handler&) = delete;
3878   upb_handlers* ptr() const { return ptr_; }
3883   typedef Handler<void *(*)(void *, const void *)> StartFieldHandler;
3884   typedef Handler<bool (*)(void *, const void *)> EndFieldHandler;
3885   typedef Handler<bool (*)(void *, const void *)> StartMessageHandler;
3886   typedef Handler<bool (*)(void *, const void *, upb_status *)>
3888   typedef Handler<void *(*)(void *, const void *, size_t)> StartStringHandler;
3889   typedef Handler<size_t (*)(void *, const void *, const char *, size_t,
3890                              const upb_bufhandle *)>
3894     typedef Handler<bool(*)(void *, const void *, T)> H;
3909   typedef void HandlersCallback(const void *closure, upb_handlers *h);
3912   MessageDefPtr message_def() const {
3931   bool SetStartMessageHandler(const StartMessageHandler &h) {
3944   bool SetEndMessageHandler(const EndMessageHandler& h) {
3953    *   bool OnValue(MyClosure* c, const MyHandlerData* d, int32_t val) {
3969   bool SetInt32Handler(FieldDefPtr f, const Int32Handler &h) {
3974   bool SetInt64Handler (FieldDefPtr f,  const Int64Handler& h) {
3979   bool SetUInt32Handler(FieldDefPtr f, const UInt32Handler& h) {
3984   bool SetUInt64Handler(FieldDefPtr f, const UInt64Handler& h) {
3989   bool SetFloatHandler (FieldDefPtr f,  const FloatHandler& h) {
3994   bool SetDoubleHandler(FieldDefPtr f, const DoubleHandler& h) {
3999   bool SetBoolHandler(FieldDefPtr f, const BoolHandler &h) {
4011       const typename ValueHandler<typename CanonicalType<T>::Type>::H &handler);
4015    *   MySubClosure* startstr(MyClosure* c, const MyHandlerData* d,
4031    *   size_t str(MyClosure* closure, const MyHandlerData* d,
4032    *              const char *str, size_t len) {
4043    *   bool endstr(MyClosure* c, const MyHandlerData* d) {
4049   bool SetStartStringHandler(FieldDefPtr f, const StartStringHandler &h) {
4054   bool SetStringHandler(FieldDefPtr f, const StringHandler& h) {
4059   bool SetEndStringHandler(FieldDefPtr f, const EndFieldHandler& h) {
4066    *   MySubClosure *startseq(MyClosure* c, const MyHandlerData* d) {
4078   bool SetStartSequenceHandler(FieldDefPtr f, const StartFieldHandler &h) {
4086    *   MySubClosure* startsubmsg(MyClosure* c, const MyHandlerData* d) {
4098   bool SetStartSubMessageHandler(FieldDefPtr f, const StartFieldHandler& h) {
4106    *   bool endsubmsg(MyClosure* c, const MyHandlerData* d) {
4114   bool SetEndSubMessageHandler(FieldDefPtr f, const EndFieldHandler &h) {
4122    *   bool endseq(MyClosure* c, const MyHandlerData* d) {
4130   bool SetEndSequenceHandler(FieldDefPtr f, const EndFieldHandler &h) {
4154 typedef void upb_handlers_callback(const void *closure, upb_handlers *h);
4157                                        const void *closure);
4159 const upb_handlers *upb_handlercache_get(upb_handlercache *cache,
4160                                          const upb_msgdef *md);
4169   HandlerCache(upb_handlers_callback *callback, const void *closure)
4177   const upb_handlers *Get(MessageDefPtr md) {
4258                               const upb_fielddef *f,
4264 bool upb_msg_getscalarhandlerdata(const upb_handlers *h,
4374 /* Template to remove "const" from "const T*" and just return "T*".
4381 template <class T> struct remove_constptr<const T *> { typedef T *type; };
4491  * Note that the second parameter is a const pointer, but our stored bound value
4492  * is non-const so we can free it when the handlers are destroyed. */
4852           void F(P1, P2, const char *, size_t, const upb_bufhandle *)>
4853 size_t ReturnStringLen(P1 p1, P2 p2, const char *p3, size_t p4,
4854                        const upb_bufhandle *p5) {
4862           bool F(P1, P2, const char *, size_t, const upb_bufhandle *)>
4863 size_t ReturnNOr0(P1 p1, P2 p2, const char *p3, size_t p4,
4864                   const upb_bufhandle *p5) {
4923           void F(P1, P2, const char *, size_t, const upb_bufhandle *), class I>
4925     Func5<void, P1, P2, const char *, size_t, const upb_bufhandle *, F, I>,
4927   typedef Func5<size_t, P1, P2, const char *, size_t, const upb_bufhandle *,
4934           bool F(P1, P2, const char *, size_t, const upb_bufhandle *), class I>
4936     Func5<bool, P1, P2, const char *, size_t, const upb_bufhandle *, F, I>,
4938   typedef Func5<size_t, P1, P2, const char *, size_t, const upb_bufhandle *,
4953 R IgnoreHandlerData2(void *p1, const void *hd) {
4960 R IgnoreHandlerData3(void *p1, const void *hd, P2Wrapper p2) {
4966 R IgnoreHandlerData4(void *p1, const void *hd, P2 p2, P3 p3) {
4972 R IgnoreHandlerData5(void *p1, const void *hd, P2 p2, P3 p3, P4 p4) {
4977 template <class R, class P1, R F(P1, const char*, size_t)>
4978 R IgnoreHandlerDataIgnoreHandle(void *p1, const void *hd, const char *p2,
4979                                 size_t p3, const upb_bufhandle *handle) {
4987 R CastHandlerData2(void *c, const void *hd) {
4993 R CastHandlerData3(void *c, const void *hd, P3Wrapper p3) {
4999 R CastHandlerData5(void *c, const void *hd, P3 p3, P4 p4, P5 p5) {
5003 template <class R, class P1, class P2, R F(P1, P2, const char *, size_t)>
5004 R CastHandlerDataIgnoreHandle(void *c, const void *hd, const char *p3,
5005                               size_t p4, const upb_bufhandle *handle) {
5013   typedef Func2<R, void *, const void *, IgnoreHandlerData2<R, P1, F>, I> Func;
5020   typedef Func3<R, void *, const void *, P3_2,
5026 template <class R, class P1, R F(P1, const char *, size_t), class I, class T>
5027 struct ConvertParams<Func3<R, P1, const char *, size_t, F, I>, T> {
5028   typedef Func5<R, void *, const void *, const char *, size_t,
5029                 const upb_bufhandle *, IgnoreHandlerDataIgnoreHandle<R, P1, F>,
5036   typedef Func5<R, void *, const void *, P2, P3, P4,
5043   typedef Func2<R, void *, const void *, CastHandlerData2<R, P1, P2, F>, I>
5051   typedef Func3<R, void *, const void *, P3_2,
5056 template <class R, class P1, class P2, R F(P1, P2, const char *, size_t),
5058 struct ConvertParams<BoundFunc4<R, P1, P2, const char *, size_t, F, I>, T> {
5059   typedef Func5<R, void *, const void *, const char *, size_t,
5060                 const upb_bufhandle *,
5068   typedef Func5<R, void *, const void *, P3, P4, P5,
5081       FieldDefPtr f, const HandlersPtr::utype##Handler &handler) {    \
5170 inline void Handler<T>::AddCleanup(upb_handlers* h) const {
5235   const upb_handlers *handlers;
5244     const void *hd;                                                   \
5260 UPB_INLINE void upb_sink_reset(upb_sink *s, const upb_handlers *h, void *c) {
5266                                      const char *buf, size_t n,
5267                                      const upb_bufhandle *handle) {
5270   const void *hd;
5278 UPB_INLINE bool upb_sink_putunknown(upb_sink s, const char *buf, size_t n) {
5281   const void *hd;
5293   const void *hd;
5305   const void *hd;
5318   const void *hd;
5332   const void *hd;
5344   const void *hd;
5358   const void *hd;
5370   const void *hd;
5388   const void *hd;
5440   Sink(const Sink&) = default;
5441   Sink& operator=(const Sink&) = default;
5443   Sink(const upb_sink& sink) : sink_(sink) {}
5444   Sink &operator=(const upb_sink &sink) {
5455   template <class T> Sink(const upb_handlers* handlers, T* closure) {
5462   template <class T> void Reset(const upb_handlers* handlers, T* closure) {
5470   template <class T> T* GetObject() const {
5538   size_t PutStringBuffer(HandlersPtr::Selector s, const char *buf, size_t len,
5539                          const upb_bufhandle *handle) {
5594   const upb_byteshandler *handler;
5598 UPB_INLINE void upb_bytessink_reset(upb_bytessink* s, const upb_byteshandler *h,
5620                                        const char *buf, size_t size,
5621                                        const upb_bufhandle* handle) {
5649   BytesSink(const BytesSink&) = default;
5650   BytesSink& operator=(const BytesSink&) = default;
5652   BytesSink(const upb_bytessink& sink) : sink_(sink) {}
5653   BytesSink &operator=(const upb_bytessink &sink) {
5664   template <class T> BytesSink(const upb_byteshandler* handler, T* closure) {
5669   template <class T> void Reset(const upb_byteshandler* handler, T* closure) {
5677   size_t PutBuffer(void *subc, const char *buf, size_t len,
5678                    const upb_bufhandle *handle) {
5698 bool upb_bufsrc_putbuf(const char *buf, size_t len, upb_bytessink sink);
5704 template <class T> bool PutBuffer(const T& str, BytesSink sink) {
5765 const upb_handlers *upb_pbdecodermethod_desthandlers(
5766     const upb_pbdecodermethod *m);
5767 const upb_byteshandler *upb_pbdecodermethod_inputhandler(
5768     const upb_pbdecodermethod *m);
5769 bool upb_pbdecodermethod_isnative(const upb_pbdecodermethod *m);
5779   DecoderMethodPtr(const upb_pbdecodermethod* ptr) : ptr_(ptr) {}
5781   const upb_pbdecodermethod* ptr() { return ptr_; }
5786   const Handlers *dest_handlers() const {
5791   const BytesHandler* input_handler() const {
5796   bool is_native() const {
5801   const upb_pbdecodermethod* ptr_;
5822                                     const upb_pbdecodermethod *method,
5824 const upb_pbdecodermethod *upb_pbdecoder_method(const upb_pbdecoder *d);
5826 uint64_t upb_pbdecoder_bytesparsed(const upb_pbdecoder *d);
5827 size_t upb_pbdecoder_maxnesting(const upb_pbdecoder *d);
5855   const DecoderMethodPtr method() const {
5883   static const size_t kSize = UPB_PB_DECODER_SIZE;
5905 bool upb_pbcodecache_allowjit(const upb_pbcodecache *c);
5908 const upb_pbdecodermethod *upb_pbcodecache_get(upb_pbcodecache *c,
5909                                                const upb_msgdef *md);
5926   const upb_pbcodecache* ptr() const { return ptr_.get(); }
5935   bool allow_jit() const { return upb_pbcodecache_allowjit(ptr()); }
5948   const DecoderMethodPtr Get(MessageDefPtr md) {
6074   const uint32_t *base;
6092   const mgroup *group;
6101   const upb_handlers *dest_handlers_;
6116   const upb_pbdecodermethod *method_;
6119   const uint32_t *pc, *last;
6122   const char *buf, *ptr, *end, *checkpoint;
6125   const char *delim_end;
6128   const char *data_end;
6144   const char *buf_param;
6146   const upb_bufhandle *handle;
6150   const uint32_t **callstack;
6157 void *upb_pbdecoder_startbc(void *closure, const void *pc, size_t size_hint);
6158 size_t upb_pbdecoder_decode(void *closure, const void *hd, const char *buf,
6159                             size_t size, const upb_bufhandle *handle);
6160 bool upb_pbdecoder_end(void *closure, const void *handler_data);
6163 int32_t upb_pbdecoder_resume(upb_pbdecoder *d, void *p, const char *buf,
6164                              size_t size, const upb_bufhandle *handle);
6172 void upb_pbdecoder_seterr(upb_pbdecoder *d, const char *msg);
6175 extern const char *kPbDecoderStackOverflow;
6176 extern const char *kPbDecoderSubmessageTooLong;
6179 const char *upb_pbdecoder_getopname(unsigned int op);
6257 extern const uint8_t upb_pb_native_wire_types[];
6291   const char *p;  /* NULL if the varint was unterminated. */
6295 UPB_INLINE upb_decoderet upb_decoderet_make(const char *p, uint64_t val) {
6310 UPB_INLINE upb_decoderet upb_vdecode_check2_ ## name(const char *_p) {         \
6332 UPB_INLINE upb_decoderet upb_vdecode_fast(const char *p) {
6436 upb_pb_encoder* upb_pb_encoder_create(upb_arena* a, const upb_handlers* h,
6454   static EncoderPtr Create(Arena* arena, const Handlers* handlers,
6468   static const size_t kSize = UPB_PB_ENCODER_SIZE;
6505 upb_textprinter *upb_textprinter_create(upb_arena *arena, const upb_handlers *h,
6575 const upb_byteshandler* upb_json_parsermethod_inputhandler(
6576     const upb_json_parsermethod* m);
6584   ParserMethodPtr(const upb_json_parsermethod* ptr) : ptr_(ptr) {}
6586   const upb_json_parsermethod* ptr() const { return ptr_; }
6588   const BytesHandler* input_handler() const {
6593   const upb_json_parsermethod* ptr_;
6614                                         const upb_json_parsermethod* m,
6615                                         const upb_symtab* symtab,
6661 const upb_json_parsermethod* upb_json_codecache_get(upb_json_codecache* cache,
6662                                                     const upb_msgdef* md);
6714 upb_json_printer *upb_json_printer_create(upb_arena *a, const upb_handlers *h,
6717 const upb_handlers *upb_json_printer_newhandlers(const upb_msgdef *md,
6719                                                  const void *owner);
6733   static PrinterPtr Create(Arena *arena, const upb::Handlers *handlers,
6742   static const size_t kSize = UPB_JSON_PRINTER_SIZE;

Indexes created Thu Nov 07 10:32:03 CST 2024