Chiebot-Mirror
/
protobuf
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Editions: Add FeatureSetDefaults type for communicating default feature set data.

Browse Source 
This will be used to seed feature resolution, which becomes just an edition lookup followed by proto merges.  Runtime and generators that need to resolve their own features will be able to leverage this to avoid reimplementing all of the reflective logic that goes into the default calculation.

PiperOrigin-RevId: 559271634
pull/13646/head
Mike Kruskal 2 years ago committed by Copybara-Service
parent 7c13a3b821
commit ba9647030d
8 changed files with 2126 additions and 107 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 129
      php/ext/google/protobuf/php-upb.c
  2. 235
      php/ext/google/protobuf/php-upb.h
  3. 49
      ruby/ext/google/protobuf_c/ruby-upb.c
  4. 225
      ruby/ext/google/protobuf_c/ruby-upb.h
  5. 697
      src/google/protobuf/descriptor.pb.cc
  6. 786
      src/google/protobuf/descriptor.pb.h
  7. 24
      src/google/protobuf/descriptor.proto
  8. 36
      src/google/protobuf/descriptor_unittest.cc

129
php/ext/google/protobuf/php-upb.c
Unescape View File

@ -754,7 +754,7 @@ bool _upb_mapsorter_pushexts(_upb_mapsorter* s,
* regenerated. */
static const char descriptor[10687] = {'\n', ' ', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 'd', 'e', 's', 'c', 'r', 'i', 'p',
static const char descriptor[10993] = {'\n', ' ', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 'd', 'e', 's', 'c', 'r', 'i', 'p',
't', 'o', 'r', '.', 'p', 'r', 'o', 't', 'o', '\022', '\017', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u',
'f', '\"', 'M', '\n', '\021', 'F', 'i', 'l', 'e', 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'o', 'r', 'S', 'e', 't', '\022', '8', '\n',
'\004', 'f', 'i', 'l', 'e', '\030', '\001', ' ', '\003', '(', '\013', '2', '$', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't',
@ -1150,38 +1150,50 @@ static const char descriptor[10687] = {'\n', ' ', 'g', 'o', 'o', 'g', 'l', 'e',
'\027', '\n', '\023', 'J', 'S', 'O', 'N', '_', 'F', 'O', 'R', 'M', 'A', 'T', '_', 'U', 'N', 'K', 'N', 'O', 'W', 'N', '\020', '\000', '\022',
'\t', '\n', '\005', 'A', 'L', 'L', 'O', 'W', '\020', '\001', '\022', '\026', '\n', '\022', 'L', 'E', 'G', 'A', 'C', 'Y', '_', 'B', 'E', 'S', 'T',
'_', 'E', 'F', 'F', 'O', 'R', 'T', '\020', '\002', '*', '\006', '\010', '\350', '\007', '\020', '\351', '\007', '*', '\006', '\010', '\351', '\007', '\020', '\352', '\007',
'*', '\006', '\010', '\213', 'N', '\020', '\220', 'N', 'J', '\004', '\010', '\004', '\020', '\005', 'J', '\006', '\010', '\347', '\007', '\020', '\350', '\007', '\"', '\247', '\002',
'\n', '\016', 'S', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '\022', 'D', '\n', '\010', 'l', 'o', 'c', 'a', 't',
'i', 'o', 'n', '\030', '\001', ' ', '\003', '(', '\013', '2', '(', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b',
'u', 'f', '.', 'S', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '.', 'L', 'o', 'c', 'a', 't', 'i', 'o',
'n', 'R', '\010', 'l', 'o', 'c', 'a', 't', 'i', 'o', 'n', '\032', '\316', '\001', '\n', '\010', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', '\022',
'\026', '\n', '\004', 'p', 'a', 't', 'h', '\030', '\001', ' ', '\003', '(', '\005', 'B', '\002', '\020', '\001', 'R', '\004', 'p', 'a', 't', 'h', '\022', '\026',
'\n', '\004', 's', 'p', 'a', 'n', '\030', '\002', ' ', '\003', '(', '\005', 'B', '\002', '\020', '\001', 'R', '\004', 's', 'p', 'a', 'n', '\022', ')', '\n',
'\020', 'l', 'e', 'a', 'd', 'i', 'n', 'g', '_', 'c', 'o', 'm', 'm', 'e', 'n', 't', 's', '\030', '\003', ' ', '\001', '(', '\t', 'R', '\017',
'l', 'e', 'a', 'd', 'i', 'n', 'g', 'C', 'o', 'm', 'm', 'e', 'n', 't', 's', '\022', '+', '\n', '\021', 't', 'r', 'a', 'i', 'l', 'i',
'n', 'g', '_', 'c', 'o', 'm', 'm', 'e', 'n', 't', 's', '\030', '\004', ' ', '\001', '(', '\t', 'R', '\020', 't', 'r', 'a', 'i', 'l', 'i',
'n', 'g', 'C', 'o', 'm', 'm', 'e', 'n', 't', 's', '\022', ':', '\n', '\031', 'l', 'e', 'a', 'd', 'i', 'n', 'g', '_', 'd', 'e', 't',
'a', 'c', 'h', 'e', 'd', '_', 'c', 'o', 'm', 'm', 'e', 'n', 't', 's', '\030', '\006', ' ', '\003', '(', '\t', 'R', '\027', 'l', 'e', 'a',
'd', 'i', 'n', 'g', 'D', 'e', 't', 'a', 'c', 'h', 'e', 'd', 'C', 'o', 'm', 'm', 'e', 'n', 't', 's', '\"', '\320', '\002', '\n', '\021',
'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '\022', 'M', '\n', '\n', 'a', 'n', 'n', 'o',
't', 'a', 't', 'i', 'o', 'n', '\030', '\001', ' ', '\003', '(', '\013', '2', '-', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o',
't', 'o', 'b', 'u', 'f', '.', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '.', 'A',
'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', 'R', '\n', 'a', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', '\032', '\353', '\001', '\n',
'\n', 'A', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', '\022', '\026', '\n', '\004', 'p', 'a', 't', 'h', '\030', '\001', ' ', '\003', '(', '\005',
'B', '\002', '\020', '\001', 'R', '\004', 'p', 'a', 't', 'h', '\022', '\037', '\n', '\013', 's', 'o', 'u', 'r', 'c', 'e', '_', 'f', 'i', 'l', 'e',
'\030', '\002', ' ', '\001', '(', '\t', 'R', '\n', 's', 'o', 'u', 'r', 'c', 'e', 'F', 'i', 'l', 'e', '\022', '\024', '\n', '\005', 'b', 'e', 'g',
'i', 'n', '\030', '\003', ' ', '\001', '(', '\005', 'R', '\005', 'b', 'e', 'g', 'i', 'n', '\022', '\020', '\n', '\003', 'e', 'n', 'd', '\030', '\004', ' ',
'\001', '(', '\005', 'R', '\003', 'e', 'n', 'd', '\022', 'R', '\n', '\010', 's', 'e', 'm', 'a', 'n', 't', 'i', 'c', '\030', '\005', ' ', '\001', '(',
'\016', '2', '6', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'G', 'e', 'n', 'e', 'r',
'a', 't', 'e', 'd', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '.', 'A', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', '.', 'S',
'e', 'm', 'a', 'n', 't', 'i', 'c', 'R', '\010', 's', 'e', 'm', 'a', 'n', 't', 'i', 'c', '\"', '(', '\n', '\010', 'S', 'e', 'm', 'a',
'n', 't', 'i', 'c', '\022', '\010', '\n', '\004', 'N', 'O', 'N', 'E', '\020', '\000', '\022', '\007', '\n', '\003', 'S', 'E', 'T', '\020', '\001', '\022', '\t',
'\n', '\005', 'A', 'L', 'I', 'A', 'S', '\020', '\002', 'B', '~', '\n', '\023', 'c', 'o', 'm', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p',
'r', 'o', 't', 'o', 'b', 'u', 'f', 'B', '\020', 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'o', 'r', 'P', 'r', 'o', 't', 'o', 's',
'H', '\001', 'Z', '-', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'g', 'o', 'l', 'a', 'n', 'g', '.', 'o', 'r', 'g', '/', 'p', 'r', 'o',
't', 'o', 'b', 'u', 'f', '/', 't', 'y', 'p', 'e', 's', '/', 'd', 'e', 's', 'c', 'r', 'i', 'p', 't', 'o', 'r', 'p', 'b', '\370',
'\001', '\001', '\242', '\002', '\003', 'G', 'P', 'B', '\252', '\002', '\032', 'G', 'o', 'o', 'g', 'l', 'e', '.', 'P', 'r', 'o', 't', 'o', 'b', 'u',
'f', '.', 'R', 'e', 'f', 'l', 'e', 'c', 't', 'i', 'o', 'n',
'*', '\006', '\010', '\213', 'N', '\020', '\220', 'N', 'J', '\004', '\010', '\004', '\020', '\005', 'J', '\006', '\010', '\347', '\007', '\020', '\350', '\007', '\"', '\257', '\002',
'\n', '\022', 'F', 'e', 'a', 't', 'u', 'r', 'e', 'S', 'e', 't', 'D', 'e', 'f', 'a', 'u', 'l', 't', 's', '\022', 'X', '\n', '\010', 'd',
'e', 'f', 'a', 'u', 'l', 't', 's', '\030', '\001', ' ', '\003', '(', '\013', '2', '<', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r',
'o', 't', 'o', 'b', 'u', 'f', '.', 'F', 'e', 'a', 't', 'u', 'r', 'e', 'S', 'e', 't', 'D', 'e', 'f', 'a', 'u', 'l', 't', 's',
'.', 'F', 'e', 'a', 't', 'u', 'r', 'e', 'S', 'e', 't', 'E', 'd', 'i', 't', 'i', 'o', 'n', 'D', 'e', 'f', 'a', 'u', 'l', 't',
'R', '\010', 'd', 'e', 'f', 'a', 'u', 'l', 't', 's', '\022', '\'', '\n', '\017', 'm', 'i', 'n', 'i', 'm', 'u', 'm', '_', 'e', 'd', 'i',
't', 'i', 'o', 'n', '\030', '\002', ' ', '\001', '(', '\t', 'R', '\016', 'm', 'i', 'n', 'i', 'm', 'u', 'm', 'E', 'd', 'i', 't', 'i', 'o',
'n', '\022', '\'', '\n', '\017', 'm', 'a', 'x', 'i', 'm', 'u', 'm', '_', 'e', 'd', 'i', 't', 'i', 'o', 'n', '\030', '\003', ' ', '\001', '(',
'\t', 'R', '\016', 'm', 'a', 'x', 'i', 'm', 'u', 'm', 'E', 'd', 'i', 't', 'i', 'o', 'n', '\032', 'm', '\n', '\030', 'F', 'e', 'a', 't',
'u', 'r', 'e', 'S', 'e', 't', 'E', 'd', 'i', 't', 'i', 'o', 'n', 'D', 'e', 'f', 'a', 'u', 'l', 't', '\022', '\030', '\n', '\007', 'e',
'd', 'i', 't', 'i', 'o', 'n', '\030', '\001', ' ', '\001', '(', '\t', 'R', '\007', 'e', 'd', 'i', 't', 'i', 'o', 'n', '\022', '7', '\n', '\010',
'f', 'e', 'a', 't', 'u', 'r', 'e', 's', '\030', '\002', ' ', '\001', '(', '\013', '2', '\033', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p',
'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'F', 'e', 'a', 't', 'u', 'r', 'e', 'S', 'e', 't', 'R', '\010', 'f', 'e', 'a', 't', 'u',
'r', 'e', 's', '\"', '\247', '\002', '\n', '\016', 'S', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '\022', 'D', '\n',
'\010', 'l', 'o', 'c', 'a', 't', 'i', 'o', 'n', '\030', '\001', ' ', '\003', '(', '\013', '2', '(', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.',
'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'S', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '.', 'L',
'o', 'c', 'a', 't', 'i', 'o', 'n', 'R', '\010', 'l', 'o', 'c', 'a', 't', 'i', 'o', 'n', '\032', '\316', '\001', '\n', '\010', 'L', 'o', 'c',
'a', 't', 'i', 'o', 'n', '\022', '\026', '\n', '\004', 'p', 'a', 't', 'h', '\030', '\001', ' ', '\003', '(', '\005', 'B', '\002', '\020', '\001', 'R', '\004',
'p', 'a', 't', 'h', '\022', '\026', '\n', '\004', 's', 'p', 'a', 'n', '\030', '\002', ' ', '\003', '(', '\005', 'B', '\002', '\020', '\001', 'R', '\004', 's',
'p', 'a', 'n', '\022', ')', '\n', '\020', 'l', 'e', 'a', 'd', 'i', 'n', 'g', '_', 'c', 'o', 'm', 'm', 'e', 'n', 't', 's', '\030', '\003',
' ', '\001', '(', '\t', 'R', '\017', 'l', 'e', 'a', 'd', 'i', 'n', 'g', 'C', 'o', 'm', 'm', 'e', 'n', 't', 's', '\022', '+', '\n', '\021',
't', 'r', 'a', 'i', 'l', 'i', 'n', 'g', '_', 'c', 'o', 'm', 'm', 'e', 'n', 't', 's', '\030', '\004', ' ', '\001', '(', '\t', 'R', '\020',
't', 'r', 'a', 'i', 'l', 'i', 'n', 'g', 'C', 'o', 'm', 'm', 'e', 'n', 't', 's', '\022', ':', '\n', '\031', 'l', 'e', 'a', 'd', 'i',
'n', 'g', '_', 'd', 'e', 't', 'a', 'c', 'h', 'e', 'd', '_', 'c', 'o', 'm', 'm', 'e', 'n', 't', 's', '\030', '\006', ' ', '\003', '(',
'\t', 'R', '\027', 'l', 'e', 'a', 'd', 'i', 'n', 'g', 'D', 'e', 't', 'a', 'c', 'h', 'e', 'd', 'C', 'o', 'm', 'm', 'e', 'n', 't',
's', '\"', '\320', '\002', '\n', '\021', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '\022', 'M',
'\n', '\n', 'a', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', '\030', '\001', ' ', '\003', '(', '\013', '2', '-', '.', 'g', 'o', 'o', 'g',
'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 'C', 'o', 'd', 'e',
'I', 'n', 'f', 'o', '.', 'A', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', 'R', '\n', 'a', 'n', 'n', 'o', 't', 'a', 't', 'i',
'o', 'n', '\032', '\353', '\001', '\n', '\n', 'A', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', '\022', '\026', '\n', '\004', 'p', 'a', 't', 'h',
'\030', '\001', ' ', '\003', '(', '\005', 'B', '\002', '\020', '\001', 'R', '\004', 'p', 'a', 't', 'h', '\022', '\037', '\n', '\013', 's', 'o', 'u', 'r', 'c',
'e', '_', 'f', 'i', 'l', 'e', '\030', '\002', ' ', '\001', '(', '\t', 'R', '\n', 's', 'o', 'u', 'r', 'c', 'e', 'F', 'i', 'l', 'e', '\022',
'\024', '\n', '\005', 'b', 'e', 'g', 'i', 'n', '\030', '\003', ' ', '\001', '(', '\005', 'R', '\005', 'b', 'e', 'g', 'i', 'n', '\022', '\020', '\n', '\003',
'e', 'n', 'd', '\030', '\004', ' ', '\001', '(', '\005', 'R', '\003', 'e', 'n', 'd', '\022', 'R', '\n', '\010', 's', 'e', 'm', 'a', 'n', 't', 'i',
'c', '\030', '\005', ' ', '\001', '(', '\016', '2', '6', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f',
'.', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 'C', 'o', 'd', 'e', 'I', 'n', 'f', 'o', '.', 'A', 'n', 'n', 'o', 't', 'a',
't', 'i', 'o', 'n', '.', 'S', 'e', 'm', 'a', 'n', 't', 'i', 'c', 'R', '\010', 's', 'e', 'm', 'a', 'n', 't', 'i', 'c', '\"', '(',
'\n', '\010', 'S', 'e', 'm', 'a', 'n', 't', 'i', 'c', '\022', '\010', '\n', '\004', 'N', 'O', 'N', 'E', '\020', '\000', '\022', '\007', '\n', '\003', 'S',
'E', 'T', '\020', '\001', '\022', '\t', '\n', '\005', 'A', 'L', 'I', 'A', 'S', '\020', '\002', 'B', '~', '\n', '\023', 'c', 'o', 'm', '.', 'g', 'o',
'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', 'B', '\020', 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'o', 'r',
'P', 'r', 'o', 't', 'o', 's', 'H', '\001', 'Z', '-', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'g', 'o', 'l', 'a', 'n', 'g', '.', 'o',
'r', 'g', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 't', 'y', 'p', 'e', 's', '/', 'd', 'e', 's', 'c', 'r', 'i', 'p',
't', 'o', 'r', 'p', 'b', '\370', '\001', '\001', '\242', '\002', '\003', 'G', 'P', 'B', '\252', '\002', '\032', 'G', 'o', 'o', 'g', 'l', 'e', '.', 'P',
'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'R', 'e', 'f', 'l', 'e', 'c', 't', 'i', 'o', 'n',
};
static _upb_DefPool_Init *deps[1] = {
@ -1192,7 +1204,7 @@ _upb_DefPool_Init google_protobuf_descriptor_proto_upbdefinit = {
deps,
&google_protobuf_descriptor_proto_upb_file_layout,
"google/protobuf/descriptor.proto",
UPB_STRINGVIEW_INIT(descriptor, 10687)
UPB_STRINGVIEW_INIT(descriptor, 10993)
};
/* This file was generated by upbc (the upb compiler) from the input
* file:
@ -2185,6 +2197,49 @@ const upb_MiniTable google_protobuf_FeatureSet_msg_init = {
24, 5, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(255), 0,
};
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_submsgs[1] = {
{.submsg = &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init},
};
static const upb_MiniTableField google_protobuf_FeatureSetDefaults__fields[3] = {
{1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
{2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
{3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
};
const upb_MiniTable google_protobuf_FeatureSetDefaults_msg_init = {
&google_protobuf_FeatureSetDefaults_submsgs[0],
&google_protobuf_FeatureSetDefaults__fields[0],
UPB_SIZE(24, 48), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(24), 0,
UPB_FASTTABLE_INIT({
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
{0x000800003f00000a, &upb_prm_1bt_max64b},
{0x0010000001000012, &upb_pss_1bt},
{0x002000000200001a, &upb_pss_1bt},
})
};
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[1] = {
{.submsg = &google_protobuf_FeatureSet_msg_init},
};
static const upb_MiniTableField google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[2] = {
{1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
{2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
};
const upb_MiniTable google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init = {
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[0],
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[0],
UPB_SIZE(16, 32), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(24), 0,
UPB_FASTTABLE_INIT({
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
{0x000800000100000a, &upb_pss_1bt},
{0x0018000002000012, &upb_psm_1bt_max64b},
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
})
};
static const upb_MiniTableSub google_protobuf_SourceCodeInfo_submsgs[1] = {
{.submsg = &google_protobuf_SourceCodeInfo_Location_msg_init},
};
@ -2273,7 +2328,7 @@ const upb_MiniTable google_protobuf_GeneratedCodeInfo_Annotation_msg_init = {
})
};
static const upb_MiniTable *messages_layout[30] = {
static const upb_MiniTable *messages_layout[32] = {
&google_protobuf_FileDescriptorSet_msg_init,
&google_protobuf_FileDescriptorProto_msg_init,
&google_protobuf_DescriptorProto_msg_init,
@ -2300,6 +2355,8 @@ static const upb_MiniTable *messages_layout[30] = {
&google_protobuf_UninterpretedOption_msg_init,
&google_protobuf_UninterpretedOption_NamePart_msg_init,
&google_protobuf_FeatureSet_msg_init,
&google_protobuf_FeatureSetDefaults_msg_init,
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init,
&google_protobuf_SourceCodeInfo_msg_init,
&google_protobuf_SourceCodeInfo_Location_msg_init,
&google_protobuf_GeneratedCodeInfo_msg_init,
@ -2463,7 +2520,7 @@ const upb_MiniTableFile google_protobuf_descriptor_proto_upb_file_layout = {
messages_layout,
enums_layout,
NULL,
30,
32,
15,
0,
};

235
php/ext/google/protobuf/php-upb.h
Unescape View File

@ -3764,6 +3764,8 @@ typedef struct google_protobuf_MethodOptions google_protobuf_MethodOptions;
typedef struct google_protobuf_UninterpretedOption google_protobuf_UninterpretedOption;
typedef struct google_protobuf_UninterpretedOption_NamePart google_protobuf_UninterpretedOption_NamePart;
typedef struct google_protobuf_FeatureSet google_protobuf_FeatureSet;
typedef struct google_protobuf_FeatureSetDefaults google_protobuf_FeatureSetDefaults;
typedef struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault;
typedef struct google_protobuf_SourceCodeInfo google_protobuf_SourceCodeInfo;
typedef struct google_protobuf_SourceCodeInfo_Location google_protobuf_SourceCodeInfo_Location;
typedef struct google_protobuf_GeneratedCodeInfo google_protobuf_GeneratedCodeInfo;
@ -3794,6 +3796,8 @@ extern const upb_MiniTable google_protobuf_MethodOptions_msg_init;
extern const upb_MiniTable google_protobuf_UninterpretedOption_msg_init;
extern const upb_MiniTable google_protobuf_UninterpretedOption_NamePart_msg_init;
extern const upb_MiniTable google_protobuf_FeatureSet_msg_init;
extern const upb_MiniTable google_protobuf_FeatureSetDefaults_msg_init;
extern const upb_MiniTable google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init;
extern const upb_MiniTable google_protobuf_SourceCodeInfo_msg_init;
extern const upb_MiniTable google_protobuf_SourceCodeInfo_Location_msg_init;
extern const upb_MiniTable google_protobuf_GeneratedCodeInfo_msg_init;
@ -9256,6 +9260,227 @@ UPB_INLINE void google_protobuf_FeatureSet_set_json_format(google_protobuf_Featu
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
/* google.protobuf.FeatureSetDefaults */
UPB_INLINE google_protobuf_FeatureSetDefaults* google_protobuf_FeatureSetDefaults_new(upb_Arena* arena) {
return (google_protobuf_FeatureSetDefaults*)_upb_Message_New(&google_protobuf_FeatureSetDefaults_msg_init, arena);
}
UPB_INLINE google_protobuf_FeatureSetDefaults* google_protobuf_FeatureSetDefaults_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults* ret = google_protobuf_FeatureSetDefaults_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE google_protobuf_FeatureSetDefaults* google_protobuf_FeatureSetDefaults_parse_ex(const char* buf, size_t size,
const upb_ExtensionRegistry* extreg,
int options, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults* ret = google_protobuf_FeatureSetDefaults_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_serialize(const google_protobuf_FeatureSetDefaults* msg, upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_msg_init, 0, arena, &ptr, len);
return ptr;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_serialize_ex(const google_protobuf_FeatureSetDefaults* msg, int options,
upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_msg_init, options, arena, &ptr, len);
return ptr;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_defaults(google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* const* google_protobuf_FeatureSetDefaults_defaults(const google_protobuf_FeatureSetDefaults* msg, size_t* size) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
const upb_Array* arr = upb_Message_GetArray(msg, &field);
if (arr) {
if (size) *size = arr->size;
return (const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* const*)_upb_array_constptr(arr);
} else {
if (size) *size = 0;
return NULL;
}
}
UPB_INLINE const upb_Array* _google_protobuf_FeatureSetDefaults_defaults_upb_array(const google_protobuf_FeatureSetDefaults* msg, size_t* size) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
const upb_Array* arr = upb_Message_GetArray(msg, &field);
if (size) {
*size = arr ? arr->size : 0;
}
return arr;
}
UPB_INLINE upb_Array* _google_protobuf_FeatureSetDefaults_defaults_mutable_upb_array(const google_protobuf_FeatureSetDefaults* msg, size_t* size, upb_Arena* arena) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
upb_Array* arr = upb_Message_GetOrCreateMutableArray(
(upb_Message*)msg, &field, arena);
if (size) {
*size = arr ? arr->size : 0;
}
return arr;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_defaults(const google_protobuf_FeatureSetDefaults* msg) {
size_t size;
google_protobuf_FeatureSetDefaults_defaults(msg, &size);
return size != 0;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_minimum_edition(google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE upb_StringView google_protobuf_FeatureSetDefaults_minimum_edition(const google_protobuf_FeatureSetDefaults* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_minimum_edition(const google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_maximum_edition(google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE upb_StringView google_protobuf_FeatureSetDefaults_maximum_edition(const google_protobuf_FeatureSetDefaults* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_maximum_edition(const google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault** google_protobuf_FeatureSetDefaults_mutable_defaults(google_protobuf_FeatureSetDefaults* msg, size_t* size) {
upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
upb_Array* arr = upb_Message_GetMutableArray(msg, &field);
if (arr) {
if (size) *size = arr->size;
return (google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault**)_upb_array_ptr(arr);
} else {
if (size) *size = 0;
return NULL;
}
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault** google_protobuf_FeatureSetDefaults_resize_defaults(google_protobuf_FeatureSetDefaults* msg, size_t size, upb_Arena* arena) {
upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
return (google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault**)upb_Message_ResizeArrayUninitialized(msg, &field, size, arena);
}
UPB_INLINE struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_add_defaults(google_protobuf_FeatureSetDefaults* msg, upb_Arena* arena) {
upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, &field, arena);
if (!arr || !_upb_Array_ResizeUninitialized(arr, arr->size + 1, arena)) {
return NULL;
}
struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* sub = (struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault*)_upb_Message_New(&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, arena);
if (!arr || !sub) return NULL;
_upb_Array_Set(arr, arr->size - 1, &sub, sizeof(sub));
return sub;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_set_minimum_edition(google_protobuf_FeatureSetDefaults *msg, upb_StringView value) {
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_set_maximum_edition(google_protobuf_FeatureSetDefaults *msg, upb_StringView value) {
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
/* google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault */
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_new(upb_Arena* arena) {
return (google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault*)_upb_Message_New(&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, arena);
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* ret = google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_parse_ex(const char* buf, size_t size,
const upb_ExtensionRegistry* extreg,
int options, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* ret = google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_serialize(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, 0, arena, &ptr, len);
return ptr;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_serialize_ex(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, int options,
upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, options, arena, &ptr, len);
return ptr;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_clear_edition(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE upb_StringView google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_edition(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_has_edition(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_clear_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_features(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const google_protobuf_FeatureSet* default_val = NULL;
const google_protobuf_FeatureSet* ret;
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_has_features(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_edition(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault *msg, upb_StringView value) {
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault *msg, google_protobuf_FeatureSet* value) {
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_mutable_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, upb_Arena* arena) {
struct google_protobuf_FeatureSet* sub = (struct google_protobuf_FeatureSet*)google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_features(msg);
if (sub == NULL) {
sub = (struct google_protobuf_FeatureSet*)_upb_Message_New(&google_protobuf_FeatureSet_msg_init, arena);
if (sub) google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_features(msg, sub);
}
return sub;
}
/* google.protobuf.SourceCodeInfo */
UPB_INLINE google_protobuf_SourceCodeInfo* google_protobuf_SourceCodeInfo_new(upb_Arena* arena) {
@ -10702,6 +10927,16 @@ UPB_INLINE const upb_MessageDef *google_protobuf_FeatureSet_getmsgdef(upb_DefPoo
return upb_DefPool_FindMessageByName(s, "google.protobuf.FeatureSet");
}
UPB_INLINE const upb_MessageDef *google_protobuf_FeatureSetDefaults_getmsgdef(upb_DefPool *s) {
_upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_DefPool_FindMessageByName(s, "google.protobuf.FeatureSetDefaults");
}
UPB_INLINE const upb_MessageDef *google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_getmsgdef(upb_DefPool *s) {
_upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_DefPool_FindMessageByName(s, "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault");
}
UPB_INLINE const upb_MessageDef *google_protobuf_SourceCodeInfo_getmsgdef(upb_DefPool *s) {
_upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
return upb_DefPool_FindMessageByName(s, "google.protobuf.SourceCodeInfo");

49
ruby/ext/google/protobuf_c/ruby-upb.c
Unescape View File

@ -1736,6 +1736,49 @@ const upb_MiniTable google_protobuf_FeatureSet_msg_init = {
24, 5, kUpb_ExtMode_Extendable, 3, UPB_FASTTABLE_MASK(255), 0,
};
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_submsgs[1] = {
{.submsg = &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init},
};
static const upb_MiniTableField google_protobuf_FeatureSetDefaults__fields[3] = {
{1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
{2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
{3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
};
const upb_MiniTable google_protobuf_FeatureSetDefaults_msg_init = {
&google_protobuf_FeatureSetDefaults_submsgs[0],
&google_protobuf_FeatureSetDefaults__fields[0],
UPB_SIZE(24, 48), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(24), 0,
UPB_FASTTABLE_INIT({
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
{0x000800003f00000a, &upb_prm_1bt_max64b},
{0x0010000001000012, &upb_pss_1bt},
{0x002000000200001a, &upb_pss_1bt},
})
};
static const upb_MiniTableSub google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[1] = {
{.submsg = &google_protobuf_FeatureSet_msg_init},
};
static const upb_MiniTableField google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[2] = {
{1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
{2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
};
const upb_MiniTable google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init = {
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_submsgs[0],
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault__fields[0],
UPB_SIZE(16, 32), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(24), 0,
UPB_FASTTABLE_INIT({
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
{0x000800000100000a, &upb_pss_1bt},
{0x0018000002000012, &upb_psm_1bt_max64b},
{0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
})
};
static const upb_MiniTableSub google_protobuf_SourceCodeInfo_submsgs[1] = {
{.submsg = &google_protobuf_SourceCodeInfo_Location_msg_init},
};
@ -1824,7 +1867,7 @@ const upb_MiniTable google_protobuf_GeneratedCodeInfo_Annotation_msg_init = {
})
};
static const upb_MiniTable *messages_layout[30] = {
static const upb_MiniTable *messages_layout[32] = {
&google_protobuf_FileDescriptorSet_msg_init,
&google_protobuf_FileDescriptorProto_msg_init,
&google_protobuf_DescriptorProto_msg_init,
@ -1851,6 +1894,8 @@ static const upb_MiniTable *messages_layout[30] = {
&google_protobuf_UninterpretedOption_msg_init,
&google_protobuf_UninterpretedOption_NamePart_msg_init,
&google_protobuf_FeatureSet_msg_init,
&google_protobuf_FeatureSetDefaults_msg_init,
&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init,
&google_protobuf_SourceCodeInfo_msg_init,
&google_protobuf_SourceCodeInfo_Location_msg_init,
&google_protobuf_GeneratedCodeInfo_msg_init,
@ -2014,7 +2059,7 @@ const upb_MiniTableFile google_protobuf_descriptor_proto_upb_file_layout = {
messages_layout,
enums_layout,
NULL,
30,
32,
15,
0,
};

225
ruby/ext/google/protobuf_c/ruby-upb.h
Unescape View File

@ -3739,6 +3739,8 @@ typedef struct google_protobuf_MethodOptions google_protobuf_MethodOptions;
typedef struct google_protobuf_UninterpretedOption google_protobuf_UninterpretedOption;
typedef struct google_protobuf_UninterpretedOption_NamePart google_protobuf_UninterpretedOption_NamePart;
typedef struct google_protobuf_FeatureSet google_protobuf_FeatureSet;
typedef struct google_protobuf_FeatureSetDefaults google_protobuf_FeatureSetDefaults;
typedef struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault;
typedef struct google_protobuf_SourceCodeInfo google_protobuf_SourceCodeInfo;
typedef struct google_protobuf_SourceCodeInfo_Location google_protobuf_SourceCodeInfo_Location;
typedef struct google_protobuf_GeneratedCodeInfo google_protobuf_GeneratedCodeInfo;
@ -3769,6 +3771,8 @@ extern const upb_MiniTable google_protobuf_MethodOptions_msg_init;
extern const upb_MiniTable google_protobuf_UninterpretedOption_msg_init;
extern const upb_MiniTable google_protobuf_UninterpretedOption_NamePart_msg_init;
extern const upb_MiniTable google_protobuf_FeatureSet_msg_init;
extern const upb_MiniTable google_protobuf_FeatureSetDefaults_msg_init;
extern const upb_MiniTable google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init;
extern const upb_MiniTable google_protobuf_SourceCodeInfo_msg_init;
extern const upb_MiniTable google_protobuf_SourceCodeInfo_Location_msg_init;
extern const upb_MiniTable google_protobuf_GeneratedCodeInfo_msg_init;
@ -9231,6 +9235,227 @@ UPB_INLINE void google_protobuf_FeatureSet_set_json_format(google_protobuf_Featu
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
/* google.protobuf.FeatureSetDefaults */
UPB_INLINE google_protobuf_FeatureSetDefaults* google_protobuf_FeatureSetDefaults_new(upb_Arena* arena) {
return (google_protobuf_FeatureSetDefaults*)_upb_Message_New(&google_protobuf_FeatureSetDefaults_msg_init, arena);
}
UPB_INLINE google_protobuf_FeatureSetDefaults* google_protobuf_FeatureSetDefaults_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults* ret = google_protobuf_FeatureSetDefaults_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE google_protobuf_FeatureSetDefaults* google_protobuf_FeatureSetDefaults_parse_ex(const char* buf, size_t size,
const upb_ExtensionRegistry* extreg,
int options, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults* ret = google_protobuf_FeatureSetDefaults_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_serialize(const google_protobuf_FeatureSetDefaults* msg, upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_msg_init, 0, arena, &ptr, len);
return ptr;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_serialize_ex(const google_protobuf_FeatureSetDefaults* msg, int options,
upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_msg_init, options, arena, &ptr, len);
return ptr;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_defaults(google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* const* google_protobuf_FeatureSetDefaults_defaults(const google_protobuf_FeatureSetDefaults* msg, size_t* size) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
const upb_Array* arr = upb_Message_GetArray(msg, &field);
if (arr) {
if (size) *size = arr->size;
return (const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* const*)_upb_array_constptr(arr);
} else {
if (size) *size = 0;
return NULL;
}
}
UPB_INLINE const upb_Array* _google_protobuf_FeatureSetDefaults_defaults_upb_array(const google_protobuf_FeatureSetDefaults* msg, size_t* size) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
const upb_Array* arr = upb_Message_GetArray(msg, &field);
if (size) {
*size = arr ? arr->size : 0;
}
return arr;
}
UPB_INLINE upb_Array* _google_protobuf_FeatureSetDefaults_defaults_mutable_upb_array(const google_protobuf_FeatureSetDefaults* msg, size_t* size, upb_Arena* arena) {
const upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
upb_Array* arr = upb_Message_GetOrCreateMutableArray(
(upb_Message*)msg, &field, arena);
if (size) {
*size = arr ? arr->size : 0;
}
return arr;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_defaults(const google_protobuf_FeatureSetDefaults* msg) {
size_t size;
google_protobuf_FeatureSetDefaults_defaults(msg, &size);
return size != 0;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_minimum_edition(google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE upb_StringView google_protobuf_FeatureSetDefaults_minimum_edition(const google_protobuf_FeatureSetDefaults* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_minimum_edition(const google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_clear_maximum_edition(google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE upb_StringView google_protobuf_FeatureSetDefaults_maximum_edition(const google_protobuf_FeatureSetDefaults* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_has_maximum_edition(const google_protobuf_FeatureSetDefaults* msg) {
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault** google_protobuf_FeatureSetDefaults_mutable_defaults(google_protobuf_FeatureSetDefaults* msg, size_t* size) {
upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
upb_Array* arr = upb_Message_GetMutableArray(msg, &field);
if (arr) {
if (size) *size = arr->size;
return (google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault**)_upb_array_ptr(arr);
} else {
if (size) *size = 0;
return NULL;
}
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault** google_protobuf_FeatureSetDefaults_resize_defaults(google_protobuf_FeatureSetDefaults* msg, size_t size, upb_Arena* arena) {
upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
return (google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault**)upb_Message_ResizeArrayUninitialized(msg, &field, size, arena);
}
UPB_INLINE struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_add_defaults(google_protobuf_FeatureSetDefaults* msg, upb_Arena* arena) {
upb_MiniTableField field = {1, UPB_SIZE(4, 8), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, &field, arena);
if (!arr || !_upb_Array_ResizeUninitialized(arr, arr->size + 1, arena)) {
return NULL;
}
struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* sub = (struct google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault*)_upb_Message_New(&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, arena);
if (!arr || !sub) return NULL;
_upb_Array_Set(arr, arr->size - 1, &sub, sizeof(sub));
return sub;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_set_minimum_edition(google_protobuf_FeatureSetDefaults *msg, upb_StringView value) {
const upb_MiniTableField field = {2, UPB_SIZE(8, 16), 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_set_maximum_edition(google_protobuf_FeatureSetDefaults *msg, upb_StringView value) {
const upb_MiniTableField field = {3, UPB_SIZE(16, 32), 2, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
/* google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault */
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_new(upb_Arena* arena) {
return (google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault*)_upb_Message_New(&google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, arena);
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_parse(const char* buf, size_t size, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* ret = google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_parse_ex(const char* buf, size_t size,
const upb_ExtensionRegistry* extreg,
int options, upb_Arena* arena) {
google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* ret = google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_new(arena);
if (!ret) return NULL;
if (upb_Decode(buf, size, ret, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, extreg, options, arena) !=
kUpb_DecodeStatus_Ok) {
return NULL;
}
return ret;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_serialize(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, 0, arena, &ptr, len);
return ptr;
}
UPB_INLINE char* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_serialize_ex(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, int options,
upb_Arena* arena, size_t* len) {
char* ptr;
(void)upb_Encode(msg, &google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_msg_init, options, arena, &ptr, len);
return ptr;
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_clear_edition(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE upb_StringView google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_edition(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_has_edition(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_clear_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_ClearNonExtensionField(msg, &field);
}
UPB_INLINE const google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_features(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const google_protobuf_FeatureSet* default_val = NULL;
const google_protobuf_FeatureSet* ret;
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
return ret;
}
UPB_INLINE bool google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_has_features(const google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg) {
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
return _upb_Message_HasNonExtensionField(msg, &field);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_edition(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault *msg, upb_StringView value) {
const upb_MiniTableField field = {1, 8, 1, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
UPB_INLINE void google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault *msg, google_protobuf_FeatureSet* value) {
const upb_MiniTableField field = {2, UPB_SIZE(4, 24), 2, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
_upb_Message_SetNonExtensionField(msg, &field, &value);
}
UPB_INLINE struct google_protobuf_FeatureSet* google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_mutable_features(google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault* msg, upb_Arena* arena) {
struct google_protobuf_FeatureSet* sub = (struct google_protobuf_FeatureSet*)google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_features(msg);
if (sub == NULL) {
sub = (struct google_protobuf_FeatureSet*)_upb_Message_New(&google_protobuf_FeatureSet_msg_init, arena);
if (sub) google_protobuf_FeatureSetDefaults_FeatureSetEditionDefault_set_features(msg, sub);
}
return sub;
}
/* google.protobuf.SourceCodeInfo */
UPB_INLINE google_protobuf_SourceCodeInfo* google_protobuf_SourceCodeInfo_new(upb_Arena* arena) {

697
src/google/protobuf/descriptor.pb.cc
Unescape View File

@ -326,6 +326,32 @@ struct GeneratedCodeInfoDefaultTypeInternal {
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FeatureSetDefaults_FeatureSetEditionDefault::FeatureSetDefaults_FeatureSetEditionDefault(::_pbi::ConstantInitialized)
: _impl_{
/*decltype(_impl_._has_bits_)*/ {},
/*decltype(_impl_._cached_size_)*/ {},
/*decltype(_impl_.edition_)*/ {
&::_pbi::fixed_address_empty_string,
::_pbi::ConstantInitialized{},
},
/*decltype(_impl_.features_)*/ nullptr,
} {}
struct FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal {
#if defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
constexpr FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
#else // defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal() {}
void Init() { ::new (&_instance) FeatureSetDefaults_FeatureSetEditionDefault(); };
#endif // defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
~FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal() {}
union {
FeatureSetDefaults_FeatureSetEditionDefault _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal _FeatureSetDefaults_FeatureSetEditionDefault_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR ServiceOptions::ServiceOptions(::_pbi::ConstantInitialized)
: _impl_{
/*decltype(_impl_._extensions_)*/ {},
@ -539,6 +565,36 @@ struct FieldOptionsDefaultTypeInternal {
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FeatureSetDefaults::FeatureSetDefaults(::_pbi::ConstantInitialized)
: _impl_{
/*decltype(_impl_._has_bits_)*/ {},
/*decltype(_impl_._cached_size_)*/ {},
/*decltype(_impl_.defaults_)*/ {},
/*decltype(_impl_.minimum_edition_)*/ {
&::_pbi::fixed_address_empty_string,
::_pbi::ConstantInitialized{},
},
/*decltype(_impl_.maximum_edition_)*/ {
&::_pbi::fixed_address_empty_string,
::_pbi::ConstantInitialized{},
},
} {}
struct FeatureSetDefaultsDefaultTypeInternal {
#if defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
constexpr FeatureSetDefaultsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
#else // defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
FeatureSetDefaultsDefaultTypeInternal() {}
void Init() { ::new (&_instance) FeatureSetDefaults(); };
#endif // defined(PROTOBUF_CONSTINIT_DEFAULT_INSTANCES)
~FeatureSetDefaultsDefaultTypeInternal() {}
union {
FeatureSetDefaults _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureSetDefaultsDefaultTypeInternal _FeatureSetDefaults_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR ExtensionRangeOptions::ExtensionRangeOptions(::_pbi::ConstantInitialized)
: _impl_{
/*decltype(_impl_._extensions_)*/ {},
@ -936,7 +992,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
} // namespace protobuf
} // namespace google
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[30];
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[32];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fdescriptor_2eproto[15];
static constexpr const ::_pb::ServiceDescriptor**
file_level_service_descriptors_google_2fprotobuf_2fdescriptor_2eproto = nullptr;
@ -1441,6 +1497,32 @@ const ::uint32_t TableStruct_google_2fprotobuf_2fdescriptor_2eproto::offsets[] P
2,
3,
4,
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault, _impl_._has_bits_),
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
~0u, // no _split_
~0u, // no sizeof(Split)
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault, _impl_.edition_),
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault, _impl_.features_),
0,
1,
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults, _impl_._has_bits_),
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
~0u, // no _split_
~0u, // no sizeof(Split)
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults, _impl_.defaults_),
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults, _impl_.minimum_edition_),
PROTOBUF_FIELD_OFFSET(::google::protobuf::FeatureSetDefaults, _impl_.maximum_edition_),
~0u,
0,
1,
PROTOBUF_FIELD_OFFSET(::google::protobuf::SourceCodeInfo_Location, _impl_._has_bits_),
PROTOBUF_FIELD_OFFSET(::google::protobuf::SourceCodeInfo_Location, _internal_metadata_),
~0u, // no _extensions_
@ -1525,10 +1607,12 @@ static const ::_pbi::MigrationSchema
{447, 457, -1, sizeof(::google::protobuf::UninterpretedOption_NamePart)},
{459, 474, -1, sizeof(::google::protobuf::UninterpretedOption)},
{481, 494, -1, sizeof(::google::protobuf::FeatureSet)},
{499, 512, -1, sizeof(::google::protobuf::SourceCodeInfo_Location)},
{517, -1, -1, sizeof(::google::protobuf::SourceCodeInfo)},
{526, 539, -1, sizeof(::google::protobuf::GeneratedCodeInfo_Annotation)},
{544, -1, -1, sizeof(::google::protobuf::GeneratedCodeInfo)},
{499, 509, -1, sizeof(::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault)},
{511, 522, -1, sizeof(::google::protobuf::FeatureSetDefaults)},
{525, 538, -1, sizeof(::google::protobuf::SourceCodeInfo_Location)},
{543, -1, -1, sizeof(::google::protobuf::SourceCodeInfo)},
{552, 565, -1, sizeof(::google::protobuf::GeneratedCodeInfo_Annotation)},
{570, -1, -1, sizeof(::google::protobuf::GeneratedCodeInfo)},
};
static const ::_pb::Message* const file_default_instances[] = {
@ -1558,6 +1642,8 @@ static const ::_pb::Message* const file_default_instances[] = {
&::google::protobuf::_UninterpretedOption_NamePart_default_instance_._instance,
&::google::protobuf::_UninterpretedOption_default_instance_._instance,
&::google::protobuf::_FeatureSet_default_instance_._instance,
&::google::protobuf::_FeatureSetDefaults_FeatureSetEditionDefault_default_instance_._instance,
&::google::protobuf::_FeatureSetDefaults_default_instance_._instance,
&::google::protobuf::_SourceCodeInfo_Location_default_instance_._instance,
&::google::protobuf::_SourceCodeInfo_default_instance_._instance,
&::google::protobuf::_GeneratedCodeInfo_Annotation_default_instance_._instance,
@ -1765,35 +1851,41 @@ const char descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto[] PR
"H_PREFIXED\020\001\022\r\n\tDELIMITED\020\002\"H\n\nJsonForma"
"t\022\027\n\023JSON_FORMAT_UNKNOWN\020\000\022\t\n\005ALLOW\020\001\022\026\n"
"\022LEGACY_BEST_EFFORT\020\002*\006\010\350\007\020\351\007*\006\010\351\007\020\352\007*\006\010"
"\213N\020\220NJ\004\010\004\020\005J\006\010\347\007\020\350\007\"\325\001\n\016SourceCodeInfo\022:"
"\n\010location\030\001 \003(\0132(.google.protobuf.Sourc"
"eCodeInfo.Location\032\206\001\n\010Location\022\020\n\004path\030"
"\001 \003(\005B\002\020\001\022\020\n\004span\030\002 \003(\005B\002\020\001\022\030\n\020leading_c"
"omments\030\003 \001(\t\022\031\n\021trailing_comments\030\004 \001(\t"
"\022!\n\031leading_detached_comments\030\006 \003(\t\"\234\002\n\021"
"GeneratedCodeInfo\022A\n\nannotation\030\001 \003(\0132-."
"google.protobuf.GeneratedCodeInfo.Annota"
"tion\032\303\001\n\nAnnotation\022\020\n\004path\030\001 \003(\005B\002\020\001\022\023\n"
"\013source_file\030\002 \001(\t\022\r\n\005begin\030\003 \001(\005\022\013\n\003end"
"\030\004 \001(\005\022H\n\010semantic\030\005 \001(\01626.google.protob"
"uf.GeneratedCodeInfo.Annotation.Semantic"
"\"(\n\010Semantic\022\010\n\004NONE\020\000\022\007\n\003SET\020\001\022\t\n\005ALIAS"
"\020\002B~\n\023com.google.protobufB\020DescriptorPro"
"tosH\001Z-google.golang.org/protobuf/types/"
"descriptorpb\370\001\001\242\002\003GPB\252\002\032Google.Protobuf."
"Reflection"
"\213N\020\220NJ\004\010\004\020\005J\006\010\347\007\020\350\007\"\362\001\n\022FeatureSetDefaul"
"ts\022N\n\010defaults\030\001 \003(\0132<.google.protobuf.F"
"eatureSetDefaults.FeatureSetEditionDefau"
"lt\022\027\n\017minimum_edition\030\002 \001(\t\022\027\n\017maximum_e"
"dition\030\003 \001(\t\032Z\n\030FeatureSetEditionDefault"
"\022\017\n\007edition\030\001 \001(\t\022-\n\010features\030\002 \001(\0132\033.go"
"ogle.protobuf.FeatureSet\"\325\001\n\016SourceCodeI"
"nfo\022:\n\010location\030\001 \003(\0132(.google.protobuf."
"SourceCodeInfo.Location\032\206\001\n\010Location\022\020\n\004"
"path\030\001 \003(\005B\002\020\001\022\020\n\004span\030\002 \003(\005B\002\020\001\022\030\n\020lead"
"ing_comments\030\003 \001(\t\022\031\n\021trailing_comments\030"
"\004 \001(\t\022!\n\031leading_detached_comments\030\006 \003(\t"
"\"\234\002\n\021GeneratedCodeInfo\022A\n\nannotation\030\001 \003"
"(\0132-.google.protobuf.GeneratedCodeInfo.A"
"nnotation\032\303\001\n\nAnnotation\022\020\n\004path\030\001 \003(\005B\002"
"\020\001\022\023\n\013source_file\030\002 \001(\t\022\r\n\005begin\030\003 \001(\005\022\013"
"\n\003end\030\004 \001(\005\022H\n\010semantic\030\005 \001(\01626.google.p"
"rotobuf.GeneratedCodeInfo.Annotation.Sem"
"antic\"(\n\010Semantic\022\010\n\004NONE\020\000\022\007\n\003SET\020\001\022\t\n\005"
"ALIAS\020\002B~\n\023com.google.protobufB\020Descript"
"orProtosH\001Z-google.golang.org/protobuf/t"
"ypes/descriptorpb\370\001\001\242\002\003GPB\252\002\032Google.Prot"
"obuf.Reflection"
};
static ::absl::once_flag descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto = {
false,
false,
8690,
8935,
descriptor_table_protodef_google_2fprotobuf_2fdescriptor_2eproto,
"google/protobuf/descriptor.proto",
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
nullptr,
0,
30,
32,
schemas,
file_default_instances,
TableStruct_google_2fprotobuf_2fdescriptor_2eproto::offsets,
@ -1847,6 +1939,8 @@ _MethodOptions_default_instance_.Init();
_UninterpretedOption_NamePart_default_instance_.Init();
_UninterpretedOption_default_instance_.Init();
_FeatureSet_default_instance_.Init();
_FeatureSetDefaults_FeatureSetEditionDefault_default_instance_.Init();
_FeatureSetDefaults_default_instance_.Init();
_SourceCodeInfo_Location_default_instance_.Init();
_SourceCodeInfo_default_instance_.Init();
_GeneratedCodeInfo_Annotation_default_instance_.Init();
@ -12012,6 +12106,553 @@ void FeatureSet::InternalSwap(FeatureSet* other) {
}
// ===================================================================
class FeatureSetDefaults_FeatureSetEditionDefault::_Internal {
public:
using HasBits = decltype(std::declval<FeatureSetDefaults_FeatureSetEditionDefault>()._impl_._has_bits_);
static constexpr ::int32_t kHasBitsOffset =
8 * PROTOBUF_FIELD_OFFSET(FeatureSetDefaults_FeatureSetEditionDefault, _impl_._has_bits_);
static void set_has_edition(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static const ::google::protobuf::FeatureSet& features(const FeatureSetDefaults_FeatureSetEditionDefault* msg);
static void set_has_features(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
const ::google::protobuf::FeatureSet& FeatureSetDefaults_FeatureSetEditionDefault::_Internal::features(const FeatureSetDefaults_FeatureSetEditionDefault* msg) {
return *msg->_impl_.features_;
}
FeatureSetDefaults_FeatureSetEditionDefault::FeatureSetDefaults_FeatureSetEditionDefault(::google::protobuf::Arena* arena)
: ::google::protobuf::Message(arena) {
SharedCtor(arena);
// @@protoc_insertion_point(arena_constructor:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
}
FeatureSetDefaults_FeatureSetEditionDefault::FeatureSetDefaults_FeatureSetEditionDefault(const FeatureSetDefaults_FeatureSetEditionDefault& from) : ::google::protobuf::Message() {
FeatureSetDefaults_FeatureSetEditionDefault* const _this = this;
(void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_},
/*decltype(_impl_._cached_size_)*/ {},
decltype(_impl_.edition_){},
decltype(_impl_.features_){nullptr},
};
_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
from._internal_metadata_);
_impl_.edition_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
_this->_impl_.edition_.Set(from._internal_edition(), _this->GetArenaForAllocation());
}
if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
_this->_impl_.features_ = new ::google::protobuf::FeatureSet(*from._impl_.features_);
}
// @@protoc_insertion_point(copy_constructor:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::SharedCtor(::_pb::Arena* arena) {
(void)arena;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){},
/*decltype(_impl_._cached_size_)*/ {},
decltype(_impl_.edition_){},
decltype(_impl_.features_){nullptr},
};
_impl_.edition_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
FeatureSetDefaults_FeatureSetEditionDefault::~FeatureSetDefaults_FeatureSetEditionDefault() {
// @@protoc_insertion_point(destructor:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
_internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
SharedDtor();
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::SharedDtor() {
ABSL_DCHECK(GetArenaForAllocation() == nullptr);
_impl_.edition_.Destroy();
if (this != internal_default_instance()) delete _impl_.features_;
}
void FeatureSetDefaults_FeatureSetEditionDefault::SetCachedSize(int size) const {
_impl_._cached_size_.Set(size);
}
PROTOBUF_NOINLINE void FeatureSetDefaults_FeatureSetEditionDefault::Clear() {
// @@protoc_insertion_point(message_clear_start:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
::uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_impl_.edition_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
ABSL_DCHECK(_impl_.features_ != nullptr);
_impl_.features_->Clear();
}
}
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
const char* FeatureSetDefaults_FeatureSetEditionDefault::_InternalParse(
const char* ptr, ::_pbi::ParseContext* ctx) {
ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
return ptr;
}
constexpr ::_pbi::TcParseTable<1, 2, 1, 75, 2> FeatureSetDefaults_FeatureSetEditionDefault::_table_ = {
{
PROTOBUF_FIELD_OFFSET(FeatureSetDefaults_FeatureSetEditionDefault, _impl_._has_bits_),
0, // no _extensions_
2, 8, // max_field_number, fast_idx_mask
offsetof(decltype(_table_), field_lookup_table),
4294967292, // skipmap
offsetof(decltype(_table_), field_entries),
2, // num_field_entries
1, // num_aux_entries
offsetof(decltype(_table_), aux_entries),
&_FeatureSetDefaults_FeatureSetEditionDefault_default_instance_._instance,
::_pbi::TcParser::GenericFallback, // fallback
}, {{
// optional .google.protobuf.FeatureSet features = 2;
{::_pbi::TcParser::FastMtS1,
{18, 1, 0, PROTOBUF_FIELD_OFFSET(FeatureSetDefaults_FeatureSetEditionDefault, _impl_.features_)}},
// optional string edition = 1;
{::_pbi::TcParser::FastSS1,
{10, 0, 0, PROTOBUF_FIELD_OFFSET(FeatureSetDefaults_FeatureSetEditionDefault, _impl_.edition_)}},
}}, {{
65535, 65535
}}, {{
// optional string edition = 1;
{PROTOBUF_FIELD_OFFSET(FeatureSetDefaults_FeatureSetEditionDefault, _impl_.edition_), _Internal::kHasBitsOffset + 0, 0,
(0 | ::_fl::kFcOptional | ::_fl::kRawString | ::_fl::kRepAString)},
// optional .google.protobuf.FeatureSet features = 2;
{PROTOBUF_FIELD_OFFSET(FeatureSetDefaults_FeatureSetEditionDefault, _impl_.features_), _Internal::kHasBitsOffset + 1, 0,
(0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
}}, {{
{::_pbi::TcParser::GetTable<::google::protobuf::FeatureSet>()},
}}, {{
"\73\7\0\0\0\0\0\0"
"google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault"
"edition"
}},
};
::uint8_t* FeatureSetDefaults_FeatureSetEditionDefault::_InternalSerialize(
::uint8_t* target,
::google::protobuf::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
::uint32_t cached_has_bits = 0;
(void)cached_has_bits;
cached_has_bits = _impl_._has_bits_[0];
// optional string edition = 1;
if (cached_has_bits & 0x00000001u) {
const std::string& _s = this->_internal_edition();
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(_s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormat::SERIALIZE,
"google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition");
target = stream->WriteStringMaybeAliased(1, _s, target);
}
// optional .google.protobuf.FeatureSet features = 2;
if (cached_has_bits & 0x00000002u) {
target = ::google::protobuf::internal::WireFormatLite::
InternalWriteMessage(2, _Internal::features(this),
_Internal::features(this).GetCachedSize(), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target =
::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
return target;
}
::size_t FeatureSetDefaults_FeatureSetEditionDefault::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
::size_t total_size = 0;
::uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional string edition = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
this->_internal_edition());
}
// optional .google.protobuf.FeatureSet features = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::MessageSize(
*_impl_.features_);
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}
const ::google::protobuf::Message::ClassData FeatureSetDefaults_FeatureSetEditionDefault::_class_data_ = {
::google::protobuf::Message::CopyWithSourceCheck,
FeatureSetDefaults_FeatureSetEditionDefault::MergeImpl
};
const ::google::protobuf::Message::ClassData*FeatureSetDefaults_FeatureSetEditionDefault::GetClassData() const { return &_class_data_; }
void FeatureSetDefaults_FeatureSetEditionDefault::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
auto* const _this = static_cast<FeatureSetDefaults_FeatureSetEditionDefault*>(&to_msg);
auto& from = static_cast<const FeatureSetDefaults_FeatureSetEditionDefault&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
ABSL_DCHECK_NE(&from, _this);
::uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_this->_internal_set_edition(from._internal_edition());
}
if (cached_has_bits & 0x00000002u) {
_this->_internal_mutable_features()->::google::protobuf::FeatureSet::MergeFrom(
from._internal_features());
}
}
_this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}
void FeatureSetDefaults_FeatureSetEditionDefault::CopyFrom(const FeatureSetDefaults_FeatureSetEditionDefault& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
if (&from == this) return;
Clear();
MergeFrom(from);
}
PROTOBUF_NOINLINE bool FeatureSetDefaults_FeatureSetEditionDefault::IsInitialized() const {
if ((_impl_._has_bits_[0] & 0x00000002u) != 0) {
if (!_impl_.features_->IsInitialized()) return false;
}
return true;
}
void FeatureSetDefaults_FeatureSetEditionDefault::InternalSwap(FeatureSetDefaults_FeatureSetEditionDefault* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
::_pbi::ArenaStringPtr::InternalSwap(&_impl_.edition_, lhs_arena,
&other->_impl_.edition_, rhs_arena);
swap(_impl_.features_, other->_impl_.features_);
}
::google::protobuf::Metadata FeatureSetDefaults_FeatureSetEditionDefault::GetMetadata() const {
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[26]);
}
// ===================================================================
class FeatureSetDefaults::_Internal {
public:
using HasBits = decltype(std::declval<FeatureSetDefaults>()._impl_._has_bits_);
static constexpr ::int32_t kHasBitsOffset =
8 * PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_._has_bits_);
static void set_has_minimum_edition(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_maximum_edition(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
FeatureSetDefaults::FeatureSetDefaults(::google::protobuf::Arena* arena)
: ::google::protobuf::Message(arena) {
SharedCtor(arena);
// @@protoc_insertion_point(arena_constructor:google.protobuf.FeatureSetDefaults)
}
FeatureSetDefaults::FeatureSetDefaults(const FeatureSetDefaults& from) : ::google::protobuf::Message() {
FeatureSetDefaults* const _this = this;
(void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_},
/*decltype(_impl_._cached_size_)*/ {},
decltype(_impl_.defaults_){from._impl_.defaults_},
decltype(_impl_.minimum_edition_){},
decltype(_impl_.maximum_edition_){},
};
_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
from._internal_metadata_);
_impl_.minimum_edition_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.minimum_edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
_this->_impl_.minimum_edition_.Set(from._internal_minimum_edition(), _this->GetArenaForAllocation());
}
_impl_.maximum_edition_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.maximum_edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
_this->_impl_.maximum_edition_.Set(from._internal_maximum_edition(), _this->GetArenaForAllocation());
}
// @@protoc_insertion_point(copy_constructor:google.protobuf.FeatureSetDefaults)
}
inline void FeatureSetDefaults::SharedCtor(::_pb::Arena* arena) {
(void)arena;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){},
/*decltype(_impl_._cached_size_)*/ {},
decltype(_impl_.defaults_){arena},
decltype(_impl_.minimum_edition_){},
decltype(_impl_.maximum_edition_){},
};
_impl_.minimum_edition_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.minimum_edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.maximum_edition_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.maximum_edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
FeatureSetDefaults::~FeatureSetDefaults() {
// @@protoc_insertion_point(destructor:google.protobuf.FeatureSetDefaults)
_internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
SharedDtor();
}
inline void FeatureSetDefaults::SharedDtor() {
ABSL_DCHECK(GetArenaForAllocation() == nullptr);
_impl_.defaults_.~RepeatedPtrField();
_impl_.minimum_edition_.Destroy();
_impl_.maximum_edition_.Destroy();
}
void FeatureSetDefaults::SetCachedSize(int size) const {
_impl_._cached_size_.Set(size);
}
PROTOBUF_NOINLINE void FeatureSetDefaults::Clear() {
// @@protoc_insertion_point(message_clear_start:google.protobuf.FeatureSetDefaults)
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
::uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
_impl_.defaults_.Clear();
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_impl_.minimum_edition_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
_impl_.maximum_edition_.ClearNonDefaultToEmpty();
}
}
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
const char* FeatureSetDefaults::_InternalParse(
const char* ptr, ::_pbi::ParseContext* ctx) {
ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
return ptr;
}
constexpr ::_pbi::TcParseTable<2, 3, 1, 73, 2> FeatureSetDefaults::_table_ = {
{
PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_._has_bits_),
0, // no _extensions_
3, 24, // max_field_number, fast_idx_mask
offsetof(decltype(_table_), field_lookup_table),
4294967288, // skipmap
offsetof(decltype(_table_), field_entries),
3, // num_field_entries
1, // num_aux_entries
offsetof(decltype(_table_), aux_entries),
&_FeatureSetDefaults_default_instance_._instance,
::_pbi::TcParser::GenericFallback, // fallback
}, {{
{::_pbi::TcParser::MiniParse, {}},
// repeated .google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
{::_pbi::TcParser::FastMtR1,
{10, 63, 0, PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_.defaults_)}},
// optional string minimum_edition = 2;
{::_pbi::TcParser::FastSS1,
{18, 0, 0, PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_.minimum_edition_)}},
// optional string maximum_edition = 3;
{::_pbi::TcParser::FastSS1,
{26, 1, 0, PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_.maximum_edition_)}},
}}, {{
65535, 65535
}}, {{
// repeated .google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
{PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_.defaults_), -1, 0,
(0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
// optional string minimum_edition = 2;
{PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_.minimum_edition_), _Internal::kHasBitsOffset + 0, 0,
(0 | ::_fl::kFcOptional | ::_fl::kRawString | ::_fl::kRepAString)},
// optional string maximum_edition = 3;
{PROTOBUF_FIELD_OFFSET(FeatureSetDefaults, _impl_.maximum_edition_), _Internal::kHasBitsOffset + 1, 0,
(0 | ::_fl::kFcOptional | ::_fl::kRawString | ::_fl::kRepAString)},
}}, {{
{::_pbi::TcParser::GetTable<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>()},
}}, {{
"\42\0\17\17\0\0\0\0"
"google.protobuf.FeatureSetDefaults"
"minimum_edition"
"maximum_edition"
}},
};
::uint8_t* FeatureSetDefaults::_InternalSerialize(
::uint8_t* target,
::google::protobuf::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.FeatureSetDefaults)
::uint32_t cached_has_bits = 0;
(void)cached_has_bits;
// repeated .google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
for (unsigned i = 0,
n = static_cast<unsigned>(this->_internal_defaults_size()); i < n; i++) {
const auto& repfield = this->_internal_defaults().Get(i);
target = ::google::protobuf::internal::WireFormatLite::
InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
}
cached_has_bits = _impl_._has_bits_[0];
// optional string minimum_edition = 2;
if (cached_has_bits & 0x00000001u) {
const std::string& _s = this->_internal_minimum_edition();
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(_s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormat::SERIALIZE,
"google.protobuf.FeatureSetDefaults.minimum_edition");
target = stream->WriteStringMaybeAliased(2, _s, target);
}
// optional string maximum_edition = 3;
if (cached_has_bits & 0x00000002u) {
const std::string& _s = this->_internal_maximum_edition();
::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(_s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormat::SERIALIZE,
"google.protobuf.FeatureSetDefaults.maximum_edition");
target = stream->WriteStringMaybeAliased(3, _s, target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target =
::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:google.protobuf.FeatureSetDefaults)
return target;
}
::size_t FeatureSetDefaults::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FeatureSetDefaults)
::size_t total_size = 0;
::uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repeated .google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
total_size += 1UL * this->_internal_defaults_size();
for (const auto& msg : this->_internal_defaults()) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSize(msg);
}
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional string minimum_edition = 2;
if (cached_has_bits & 0x00000001u) {
total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
this->_internal_minimum_edition());
}
// optional string maximum_edition = 3;
if (cached_has_bits & 0x00000002u) {
total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
this->_internal_maximum_edition());
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}
const ::google::protobuf::Message::ClassData FeatureSetDefaults::_class_data_ = {
::google::protobuf::Message::CopyWithSourceCheck,
FeatureSetDefaults::MergeImpl
};
const ::google::protobuf::Message::ClassData*FeatureSetDefaults::GetClassData() const { return &_class_data_; }
void FeatureSetDefaults::MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg) {
auto* const _this = static_cast<FeatureSetDefaults*>(&to_msg);
auto& from = static_cast<const FeatureSetDefaults&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.FeatureSetDefaults)
ABSL_DCHECK_NE(&from, _this);
::uint32_t cached_has_bits = 0;
(void) cached_has_bits;
_this->_internal_mutable_defaults()->MergeFrom(
from._internal_defaults());
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_this->_internal_set_minimum_edition(from._internal_minimum_edition());
}
if (cached_has_bits & 0x00000002u) {
_this->_internal_set_maximum_edition(from._internal_maximum_edition());
}
}
_this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}
void FeatureSetDefaults::CopyFrom(const FeatureSetDefaults& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:google.protobuf.FeatureSetDefaults)
if (&from == this) return;
Clear();
MergeFrom(from);
}
PROTOBUF_NOINLINE bool FeatureSetDefaults::IsInitialized() const {
if (!::google::protobuf::internal::AllAreInitialized(_internal_defaults()))
return false;
return true;
}
void FeatureSetDefaults::InternalSwap(FeatureSetDefaults* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
_impl_.defaults_.InternalSwap(&other->_impl_.defaults_);
::_pbi::ArenaStringPtr::InternalSwap(&_impl_.minimum_edition_, lhs_arena,
&other->_impl_.minimum_edition_, rhs_arena);
::_pbi::ArenaStringPtr::InternalSwap(&_impl_.maximum_edition_, lhs_arena,
&other->_impl_.maximum_edition_, rhs_arena);
}
::google::protobuf::Metadata FeatureSetDefaults::GetMetadata() const {
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[27]);
}
// ===================================================================
class SourceCodeInfo_Location::_Internal {
public:
using HasBits = decltype(std::declval<SourceCodeInfo_Location>()._impl_._has_bits_);
@ -12369,7 +13010,7 @@ void SourceCodeInfo_Location::InternalSwap(SourceCodeInfo_Location* other) {
::google::protobuf::Metadata SourceCodeInfo_Location::GetMetadata() const {
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[26]);
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[28]);
}
// ===================================================================
@ -12542,7 +13183,7 @@ void SourceCodeInfo::InternalSwap(SourceCodeInfo* other) {
::google::protobuf::Metadata SourceCodeInfo::GetMetadata() const {
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[27]);
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[29]);
}
// ===================================================================
@ -12888,7 +13529,7 @@ void GeneratedCodeInfo_Annotation::InternalSwap(GeneratedCodeInfo_Annotation* ot
::google::protobuf::Metadata GeneratedCodeInfo_Annotation::GetMetadata() const {
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[28]);
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[30]);
}
// ===================================================================
@ -13061,7 +13702,7 @@ void GeneratedCodeInfo::InternalSwap(GeneratedCodeInfo* other) {
::google::protobuf::Metadata GeneratedCodeInfo::GetMetadata() const {
return ::_pbi::AssignDescriptors(
&descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_getter, &descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_once,
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[29]);
file_level_metadata_google_2fprotobuf_2fdescriptor_2eproto[31]);
}
// @@protoc_insertion_point(namespace_scope)
} // namespace protobuf

786
src/google/protobuf/descriptor.pb.h
Unescape View File

@ -89,6 +89,12 @@ PROTOBUF_EXPORT extern ExtensionRangeOptions_DeclarationDefaultTypeInternal _Ext
class FeatureSet;
struct FeatureSetDefaultTypeInternal;
PROTOBUF_EXPORT extern FeatureSetDefaultTypeInternal _FeatureSet_default_instance_;
class FeatureSetDefaults;
struct FeatureSetDefaultsDefaultTypeInternal;
PROTOBUF_EXPORT extern FeatureSetDefaultsDefaultTypeInternal _FeatureSetDefaults_default_instance_;
class FeatureSetDefaults_FeatureSetEditionDefault;
struct FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal;
PROTOBUF_EXPORT extern FeatureSetDefaults_FeatureSetEditionDefaultDefaultTypeInternal _FeatureSetDefaults_FeatureSetEditionDefault_default_instance_;
class FieldDescriptorProto;
struct FieldDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
@ -869,7 +875,7 @@ class PROTOBUF_EXPORT SourceCodeInfo_Location final :
&_SourceCodeInfo_Location_default_instance_);
}
static constexpr int kIndexInFileMessages =
26;
28;
friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b) {
a.Swap(&b);
@ -1135,7 +1141,7 @@ class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation final :
&_GeneratedCodeInfo_Annotation_default_instance_);
}
static constexpr int kIndexInFileMessages =
28;
30;
friend void swap(GeneratedCodeInfo_Annotation& a, GeneratedCodeInfo_Annotation& b) {
a.Swap(&b);
@ -2936,7 +2942,7 @@ class PROTOBUF_EXPORT SourceCodeInfo final :
&_SourceCodeInfo_default_instance_);
}
static constexpr int kIndexInFileMessages =
27;
29;
friend void swap(SourceCodeInfo& a, SourceCodeInfo& b) {
a.Swap(&b);
@ -3113,7 +3119,7 @@ class PROTOBUF_EXPORT GeneratedCodeInfo final :
&_GeneratedCodeInfo_default_instance_);
}
static constexpr int kIndexInFileMessages =
29;
31;
friend void swap(GeneratedCodeInfo& a, GeneratedCodeInfo& b) {
a.Swap(&b);
@ -3228,6 +3234,198 @@ class PROTOBUF_EXPORT GeneratedCodeInfo final :
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};// -------------------------------------------------------------------
class PROTOBUF_EXPORT FeatureSetDefaults_FeatureSetEditionDefault final :
public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault) */ {
public:
inline FeatureSetDefaults_FeatureSetEditionDefault() : FeatureSetDefaults_FeatureSetEditionDefault(nullptr) {}
~FeatureSetDefaults_FeatureSetEditionDefault() override;
template<typename = void>
explicit PROTOBUF_CONSTEXPR FeatureSetDefaults_FeatureSetEditionDefault(::google::protobuf::internal::ConstantInitialized);
FeatureSetDefaults_FeatureSetEditionDefault(const FeatureSetDefaults_FeatureSetEditionDefault& from);
FeatureSetDefaults_FeatureSetEditionDefault(FeatureSetDefaults_FeatureSetEditionDefault&& from) noexcept
: FeatureSetDefaults_FeatureSetEditionDefault() {
*this = ::std::move(from);
}
inline FeatureSetDefaults_FeatureSetEditionDefault(::google::protobuf::Arena* arena, const FeatureSetDefaults_FeatureSetEditionDefault& from)
: FeatureSetDefaults_FeatureSetEditionDefault(arena) {
MergeFrom(from);
}
inline FeatureSetDefaults_FeatureSetEditionDefault& operator=(const FeatureSetDefaults_FeatureSetEditionDefault& from) {
CopyFrom(from);
return *this;
}
inline FeatureSetDefaults_FeatureSetEditionDefault& operator=(FeatureSetDefaults_FeatureSetEditionDefault&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
}
static const ::google::protobuf::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::google::protobuf::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::google::protobuf::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FeatureSetDefaults_FeatureSetEditionDefault& default_instance() {
return *internal_default_instance();
}
static inline const FeatureSetDefaults_FeatureSetEditionDefault* internal_default_instance() {
return reinterpret_cast<const FeatureSetDefaults_FeatureSetEditionDefault*>(
&_FeatureSetDefaults_FeatureSetEditionDefault_default_instance_);
}
static constexpr int kIndexInFileMessages =
26;
friend void swap(FeatureSetDefaults_FeatureSetEditionDefault& a, FeatureSetDefaults_FeatureSetEditionDefault& b) {
a.Swap(&b);
}
inline void Swap(FeatureSetDefaults_FeatureSetEditionDefault* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::google::protobuf::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FeatureSetDefaults_FeatureSetEditionDefault* other) {
if (other == this) return;
ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FeatureSetDefaults_FeatureSetEditionDefault* New(::google::protobuf::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FeatureSetDefaults_FeatureSetEditionDefault>(arena);
}
using ::google::protobuf::Message::CopyFrom;
void CopyFrom(const FeatureSetDefaults_FeatureSetEditionDefault& from);
using ::google::protobuf::Message::MergeFrom;
void MergeFrom( const FeatureSetDefaults_FeatureSetEditionDefault& from) {
FeatureSetDefaults_FeatureSetEditionDefault::MergeImpl(*this, from);
}
private:
static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
::size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
::uint8_t* _InternalSerialize(
::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::google::protobuf::Arena* arena);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FeatureSetDefaults_FeatureSetEditionDefault* other);
private:
friend class ::google::protobuf::internal::AnyMetadata;
static ::absl::string_view FullMessageName() {
return "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
}
protected:
explicit FeatureSetDefaults_FeatureSetEditionDefault(::google::protobuf::Arena* arena);
public:
static const ClassData _class_data_;
const ::google::protobuf::Message::ClassData*GetClassData() const final;
::google::protobuf::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kEditionFieldNumber = 1,
kFeaturesFieldNumber = 2,
};
// optional string edition = 1;
bool has_edition() const;
void clear_edition() ;
const std::string& edition() const;
template <typename Arg_ = const std::string&, typename... Args_>
void set_edition(Arg_&& arg, Args_... args);
std::string* mutable_edition();
PROTOBUF_NODISCARD std::string* release_edition();
void set_allocated_edition(std::string* ptr);
private:
const std::string& _internal_edition() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_edition(
const std::string& value);
std::string* _internal_mutable_edition();
public:
// optional .google.protobuf.FeatureSet features = 2;
bool has_features() const;
void clear_features() ;
const ::google::protobuf::FeatureSet& features() const;
PROTOBUF_NODISCARD ::google::protobuf::FeatureSet* release_features();
::google::protobuf::FeatureSet* mutable_features();
void set_allocated_features(::google::protobuf::FeatureSet* value);
void unsafe_arena_set_allocated_features(::google::protobuf::FeatureSet* value);
::google::protobuf::FeatureSet* unsafe_arena_release_features();
private:
const ::google::protobuf::FeatureSet& _internal_features() const;
::google::protobuf::FeatureSet* _internal_mutable_features();
public:
// @@protoc_insertion_point(class_scope:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault)
private:
class _Internal;
friend class ::google::protobuf::internal::TcParser;
static const ::google::protobuf::internal::TcParseTable<
1, 2, 1,
75, 2>
_table_;
template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable ::google::protobuf::internal::CachedSize _cached_size_;
::google::protobuf::internal::ArenaStringPtr edition_;
::google::protobuf::FeatureSet* features_;
PROTOBUF_TSAN_DECLARE_MEMBER;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};// -------------------------------------------------------------------
class PROTOBUF_EXPORT ServiceOptions final :
public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ {
public:
@ -6021,6 +6219,222 @@ class PROTOBUF_EXPORT FieldOptions final :
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};// -------------------------------------------------------------------
class PROTOBUF_EXPORT FeatureSetDefaults final :
public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FeatureSetDefaults) */ {
public:
inline FeatureSetDefaults() : FeatureSetDefaults(nullptr) {}
~FeatureSetDefaults() override;
template<typename = void>
explicit PROTOBUF_CONSTEXPR FeatureSetDefaults(::google::protobuf::internal::ConstantInitialized);
FeatureSetDefaults(const FeatureSetDefaults& from);
FeatureSetDefaults(FeatureSetDefaults&& from) noexcept
: FeatureSetDefaults() {
*this = ::std::move(from);
}
inline FeatureSetDefaults(::google::protobuf::Arena* arena, const FeatureSetDefaults& from)
: FeatureSetDefaults(arena) {
MergeFrom(from);
}
inline FeatureSetDefaults& operator=(const FeatureSetDefaults& from) {
CopyFrom(from);
return *this;
}
inline FeatureSetDefaults& operator=(FeatureSetDefaults&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
ABSL_ATTRIBUTE_LIFETIME_BOUND {
return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
}
static const ::google::protobuf::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::google::protobuf::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::google::protobuf::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FeatureSetDefaults& default_instance() {
return *internal_default_instance();
}
static inline const FeatureSetDefaults* internal_default_instance() {
return reinterpret_cast<const FeatureSetDefaults*>(
&_FeatureSetDefaults_default_instance_);
}
static constexpr int kIndexInFileMessages =
27;
friend void swap(FeatureSetDefaults& a, FeatureSetDefaults& b) {
a.Swap(&b);
}
inline void Swap(FeatureSetDefaults* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::google::protobuf::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FeatureSetDefaults* other) {
if (other == this) return;
ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FeatureSetDefaults* New(::google::protobuf::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FeatureSetDefaults>(arena);
}
using ::google::protobuf::Message::CopyFrom;
void CopyFrom(const FeatureSetDefaults& from);
using ::google::protobuf::Message::MergeFrom;
void MergeFrom( const FeatureSetDefaults& from) {
FeatureSetDefaults::MergeImpl(*this, from);
}
private:
static void MergeImpl(::google::protobuf::Message& to_msg, const ::google::protobuf::Message& from_msg);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
::size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
::uint8_t* _InternalSerialize(
::uint8_t* target, ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
private:
void SharedCtor(::google::protobuf::Arena* arena);
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FeatureSetDefaults* other);
private:
friend class ::google::protobuf::internal::AnyMetadata;
static ::absl::string_view FullMessageName() {
return "google.protobuf.FeatureSetDefaults";
}
protected:
explicit FeatureSetDefaults(::google::protobuf::Arena* arena);
public:
static const ClassData _class_data_;
const ::google::protobuf::Message::ClassData*GetClassData() const final;
::google::protobuf::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
typedef FeatureSetDefaults_FeatureSetEditionDefault FeatureSetEditionDefault;
// accessors -------------------------------------------------------
enum : int {
kDefaultsFieldNumber = 1,
kMinimumEditionFieldNumber = 2,
kMaximumEditionFieldNumber = 3,
};
// repeated .google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
int defaults_size() const;
private:
int _internal_defaults_size() const;
public:
void clear_defaults() ;
::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault* mutable_defaults(int index);
::google::protobuf::RepeatedPtrField< ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault >*
mutable_defaults();
private:
const ::google::protobuf::RepeatedPtrField<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>& _internal_defaults() const;
::google::protobuf::RepeatedPtrField<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>* _internal_mutable_defaults();
public:
const ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault& defaults(int index) const;
::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault* add_defaults();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault >&
defaults() const;
// optional string minimum_edition = 2;
bool has_minimum_edition() const;
void clear_minimum_edition() ;
const std::string& minimum_edition() const;
template <typename Arg_ = const std::string&, typename... Args_>
void set_minimum_edition(Arg_&& arg, Args_... args);
std::string* mutable_minimum_edition();
PROTOBUF_NODISCARD std::string* release_minimum_edition();
void set_allocated_minimum_edition(std::string* ptr);
private:
const std::string& _internal_minimum_edition() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_minimum_edition(
const std::string& value);
std::string* _internal_mutable_minimum_edition();
public:
// optional string maximum_edition = 3;
bool has_maximum_edition() const;
void clear_maximum_edition() ;
const std::string& maximum_edition() const;
template <typename Arg_ = const std::string&, typename... Args_>
void set_maximum_edition(Arg_&& arg, Args_... args);
std::string* mutable_maximum_edition();
PROTOBUF_NODISCARD std::string* release_maximum_edition();
void set_allocated_maximum_edition(std::string* ptr);
private:
const std::string& _internal_maximum_edition() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_maximum_edition(
const std::string& value);
std::string* _internal_mutable_maximum_edition();
public:
// @@protoc_insertion_point(class_scope:google.protobuf.FeatureSetDefaults)
private:
class _Internal;
friend class ::google::protobuf::internal::TcParser;
static const ::google::protobuf::internal::TcParseTable<
2, 3, 1,
73, 2>
_table_;
template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
struct Impl_ {
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable ::google::protobuf::internal::CachedSize _cached_size_;
::google::protobuf::RepeatedPtrField< ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault > defaults_;
::google::protobuf::internal::ArenaStringPtr minimum_edition_;
::google::protobuf::internal::ArenaStringPtr maximum_edition_;
PROTOBUF_TSAN_DECLARE_MEMBER;
};
union { Impl_ _impl_; };
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};// -------------------------------------------------------------------
class PROTOBUF_EXPORT ExtensionRangeOptions final :
public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ {
public:
@ -17673,6 +18087,370 @@ inline void FeatureSet::_internal_set_json_format(::google::protobuf::FeatureSet
// -------------------------------------------------------------------
// FeatureSetDefaults_FeatureSetEditionDefault
// optional string edition = 1;
inline bool FeatureSetDefaults_FeatureSetEditionDefault::has_edition() const {
bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::clear_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_.edition_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FeatureSetDefaults_FeatureSetEditionDefault::edition() const {
// @@protoc_insertion_point(field_get:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition)
return _internal_edition();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void FeatureSetDefaults_FeatureSetEditionDefault::set_edition(Arg_&& arg,
Args_... args) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.edition_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition)
}
inline std::string* FeatureSetDefaults_FeatureSetEditionDefault::mutable_edition() {
std::string* _s = _internal_mutable_edition();
// @@protoc_insertion_point(field_mutable:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition)
return _s;
}
inline const std::string& FeatureSetDefaults_FeatureSetEditionDefault::_internal_edition() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return _impl_.edition_.Get();
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::_internal_set_edition(const std::string& value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.edition_.Set(value, GetArenaForAllocation());
}
inline std::string* FeatureSetDefaults_FeatureSetEditionDefault::_internal_mutable_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000001u;
return _impl_.edition_.Mutable( GetArenaForAllocation());
}
inline std::string* FeatureSetDefaults_FeatureSetEditionDefault::release_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
// @@protoc_insertion_point(field_release:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition)
if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
return nullptr;
}
_impl_._has_bits_[0] &= ~0x00000001u;
auto* released = _impl_.edition_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return released;
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::set_allocated_edition(std::string* value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
if (value != nullptr) {
_impl_._has_bits_[0] |= 0x00000001u;
} else {
_impl_._has_bits_[0] &= ~0x00000001u;
}
_impl_.edition_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.edition_.IsDefault()) {
_impl_.edition_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition)
}
// optional .google.protobuf.FeatureSet features = 2;
inline bool FeatureSetDefaults_FeatureSetEditionDefault::has_features() const {
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || _impl_.features_ != nullptr);
return value;
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::clear_features() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
if (_impl_.features_ != nullptr) _impl_.features_->Clear();
_impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::google::protobuf::FeatureSet& FeatureSetDefaults_FeatureSetEditionDefault::_internal_features() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
const ::google::protobuf::FeatureSet* p = _impl_.features_;
return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::FeatureSet&>(::google::protobuf::_FeatureSet_default_instance_);
}
inline const ::google::protobuf::FeatureSet& FeatureSetDefaults_FeatureSetEditionDefault::features() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
// @@protoc_insertion_point(field_get:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features)
return _internal_features();
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::unsafe_arena_set_allocated_features(::google::protobuf::FeatureSet* value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.features_);
}
_impl_.features_ = reinterpret_cast<::google::protobuf::FeatureSet*>(value);
if (value != nullptr) {
_impl_._has_bits_[0] |= 0x00000002u;
} else {
_impl_._has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features)
}
inline ::google::protobuf::FeatureSet* FeatureSetDefaults_FeatureSetEditionDefault::release_features() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] &= ~0x00000002u;
::google::protobuf::FeatureSet* released = _impl_.features_;
_impl_.features_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
released = ::google::protobuf::internal::DuplicateIfNonNull(released);
if (GetArenaForAllocation() == nullptr) {
delete old;
}
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
released = ::google::protobuf::internal::DuplicateIfNonNull(released);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return released;
}
inline ::google::protobuf::FeatureSet* FeatureSetDefaults_FeatureSetEditionDefault::unsafe_arena_release_features() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
// @@protoc_insertion_point(field_release:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features)
_impl_._has_bits_[0] &= ~0x00000002u;
::google::protobuf::FeatureSet* temp = _impl_.features_;
_impl_.features_ = nullptr;
return temp;
}
inline ::google::protobuf::FeatureSet* FeatureSetDefaults_FeatureSetEditionDefault::_internal_mutable_features() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000002u;
if (_impl_.features_ == nullptr) {
auto* p = CreateMaybeMessage<::google::protobuf::FeatureSet>(GetArenaForAllocation());
_impl_.features_ = reinterpret_cast<::google::protobuf::FeatureSet*>(p);
}
return _impl_.features_;
}
inline ::google::protobuf::FeatureSet* FeatureSetDefaults_FeatureSetEditionDefault::mutable_features() ABSL_ATTRIBUTE_LIFETIME_BOUND {
::google::protobuf::FeatureSet* _msg = _internal_mutable_features();
// @@protoc_insertion_point(field_mutable:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features)
return _msg;
}
inline void FeatureSetDefaults_FeatureSetEditionDefault::set_allocated_features(::google::protobuf::FeatureSet* value) {
::google::protobuf::Arena* message_arena = GetArenaForAllocation();
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
if (message_arena == nullptr) {
delete reinterpret_cast<::google::protobuf::FeatureSet*>(_impl_.features_);
}
if (value != nullptr) {
::google::protobuf::Arena* submessage_arena =
::google::protobuf::Arena::InternalGetOwningArena(reinterpret_cast<::google::protobuf::FeatureSet*>(value));
if (message_arena != submessage_arena) {
value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
}
_impl_._has_bits_[0] |= 0x00000002u;
} else {
_impl_._has_bits_[0] &= ~0x00000002u;
}
_impl_.features_ = reinterpret_cast<::google::protobuf::FeatureSet*>(value);
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features)
}
// -------------------------------------------------------------------
// FeatureSetDefaults
// repeated .google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
inline int FeatureSetDefaults::_internal_defaults_size() const {
return _internal_defaults().size();
}
inline int FeatureSetDefaults::defaults_size() const {
return _internal_defaults_size();
}
inline void FeatureSetDefaults::clear_defaults() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_.defaults_.Clear();
}
inline ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault* FeatureSetDefaults::mutable_defaults(int index)
ABSL_ATTRIBUTE_LIFETIME_BOUND {
// @@protoc_insertion_point(field_mutable:google.protobuf.FeatureSetDefaults.defaults)
return _internal_mutable_defaults()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>* FeatureSetDefaults::mutable_defaults()
ABSL_ATTRIBUTE_LIFETIME_BOUND {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FeatureSetDefaults.defaults)
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
return _internal_mutable_defaults();
}
inline const ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault& FeatureSetDefaults::defaults(int index) const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
// @@protoc_insertion_point(field_get:google.protobuf.FeatureSetDefaults.defaults)
return _internal_defaults().Get(index);
}
inline ::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault* FeatureSetDefaults::add_defaults() ABSL_ATTRIBUTE_LIFETIME_BOUND {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault* _add = _internal_mutable_defaults()->Add();
// @@protoc_insertion_point(field_add:google.protobuf.FeatureSetDefaults.defaults)
return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>& FeatureSetDefaults::defaults() const
ABSL_ATTRIBUTE_LIFETIME_BOUND {
// @@protoc_insertion_point(field_list:google.protobuf.FeatureSetDefaults.defaults)
return _internal_defaults();
}
inline const ::google::protobuf::RepeatedPtrField<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>&
FeatureSetDefaults::_internal_defaults() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return _impl_.defaults_;
}
inline ::google::protobuf::RepeatedPtrField<::google::protobuf::FeatureSetDefaults_FeatureSetEditionDefault>*
FeatureSetDefaults::_internal_mutable_defaults() {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return &_impl_.defaults_;
}
// optional string minimum_edition = 2;
inline bool FeatureSetDefaults::has_minimum_edition() const {
bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline void FeatureSetDefaults::clear_minimum_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_.minimum_edition_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FeatureSetDefaults::minimum_edition() const {
// @@protoc_insertion_point(field_get:google.protobuf.FeatureSetDefaults.minimum_edition)
return _internal_minimum_edition();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void FeatureSetDefaults::set_minimum_edition(Arg_&& arg,
Args_... args) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.minimum_edition_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.FeatureSetDefaults.minimum_edition)
}
inline std::string* FeatureSetDefaults::mutable_minimum_edition() {
std::string* _s = _internal_mutable_minimum_edition();
// @@protoc_insertion_point(field_mutable:google.protobuf.FeatureSetDefaults.minimum_edition)
return _s;
}
inline const std::string& FeatureSetDefaults::_internal_minimum_edition() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return _impl_.minimum_edition_.Get();
}
inline void FeatureSetDefaults::_internal_set_minimum_edition(const std::string& value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000001u;
_impl_.minimum_edition_.Set(value, GetArenaForAllocation());
}
inline std::string* FeatureSetDefaults::_internal_mutable_minimum_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000001u;
return _impl_.minimum_edition_.Mutable( GetArenaForAllocation());
}
inline std::string* FeatureSetDefaults::release_minimum_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
// @@protoc_insertion_point(field_release:google.protobuf.FeatureSetDefaults.minimum_edition)
if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
return nullptr;
}
_impl_._has_bits_[0] &= ~0x00000001u;
auto* released = _impl_.minimum_edition_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.minimum_edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return released;
}
inline void FeatureSetDefaults::set_allocated_minimum_edition(std::string* value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
if (value != nullptr) {
_impl_._has_bits_[0] |= 0x00000001u;
} else {
_impl_._has_bits_[0] &= ~0x00000001u;
}
_impl_.minimum_edition_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.minimum_edition_.IsDefault()) {
_impl_.minimum_edition_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FeatureSetDefaults.minimum_edition)
}
// optional string maximum_edition = 3;
inline bool FeatureSetDefaults::has_maximum_edition() const {
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline void FeatureSetDefaults::clear_maximum_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_.maximum_edition_.ClearToEmpty();
_impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& FeatureSetDefaults::maximum_edition() const {
// @@protoc_insertion_point(field_get:google.protobuf.FeatureSetDefaults.maximum_edition)
return _internal_maximum_edition();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void FeatureSetDefaults::set_maximum_edition(Arg_&& arg,
Args_... args) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.maximum_edition_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:google.protobuf.FeatureSetDefaults.maximum_edition)
}
inline std::string* FeatureSetDefaults::mutable_maximum_edition() {
std::string* _s = _internal_mutable_maximum_edition();
// @@protoc_insertion_point(field_mutable:google.protobuf.FeatureSetDefaults.maximum_edition)
return _s;
}
inline const std::string& FeatureSetDefaults::_internal_maximum_edition() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return _impl_.maximum_edition_.Get();
}
inline void FeatureSetDefaults::_internal_set_maximum_edition(const std::string& value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.maximum_edition_.Set(value, GetArenaForAllocation());
}
inline std::string* FeatureSetDefaults::_internal_mutable_maximum_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_._has_bits_[0] |= 0x00000002u;
return _impl_.maximum_edition_.Mutable( GetArenaForAllocation());
}
inline std::string* FeatureSetDefaults::release_maximum_edition() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
// @@protoc_insertion_point(field_release:google.protobuf.FeatureSetDefaults.maximum_edition)
if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
return nullptr;
}
_impl_._has_bits_[0] &= ~0x00000002u;
auto* released = _impl_.maximum_edition_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.maximum_edition_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return released;
}
inline void FeatureSetDefaults::set_allocated_maximum_edition(std::string* value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
if (value != nullptr) {
_impl_._has_bits_[0] |= 0x00000002u;
} else {
_impl_._has_bits_[0] &= ~0x00000002u;
}
_impl_.maximum_edition_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (_impl_.maximum_edition_.IsDefault()) {
_impl_.maximum_edition_.Set("", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FeatureSetDefaults.maximum_edition)
}
// -------------------------------------------------------------------
// SourceCodeInfo_Location
// repeated int32 path = 1 [packed = true];

24
src/google/protobuf/descriptor.proto
Unescape View File

@ -969,6 +969,30 @@ message FeatureSet {
extensions 9995 to 9999; // For internal testing
}
// A compiled specification for the defaults of a set of features. These
// messages are generated from FeatureSet extensions and can be used to seed
// feature resolution. The resolution with this object becomes a simple search
// for the closest matching edition, followed by proto merges.
message FeatureSetDefaults {
// A map from every known edition with a unique set of defaults to its
// defaults. Not all editions may be contained here. For a given edition,
// the defaults at the closest matching edition ordered at or before it should
// be used. This field must be in strict ascending order by edition.
message FeatureSetEditionDefault {
optional string edition = 1;
optional FeatureSet features = 2;
}
repeated FeatureSetEditionDefault defaults = 1;
// The minimum supported edition (inclusive) when this was constructed.
// Editions before this will not have defaults.
optional string minimum_edition = 2;
// The maximum known edition (inclusive) when this was constructed. Editions
// after this will not have reliable defaults.
optional string maximum_edition = 3;
}
// ===================================================================
// Optional source code info

36
src/google/protobuf/descriptor_unittest.cc
Unescape View File

@ -3490,16 +3490,18 @@ TEST(CustomOptions, OptionsFromOtherFile) {
// Test that to use a custom option, we only need to import the file
// defining the option; we do not also have to import descriptor.proto.
DescriptorPool pool;
{
FileDescriptorProto file_proto;
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
}
{
// We have to import the Any dependency.
FileDescriptorProto any_proto;
google::protobuf::Any::descriptor()->file()->CopyTo(&any_proto);
ASSERT_TRUE(pool.BuildFile(any_proto) != nullptr);
}
FileDescriptorProto file_proto;
protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
@ -3554,14 +3556,17 @@ TEST(CustomOptions, MessageOptionThreeFieldsSet) {
// you want to know more.
DescriptorPool pool;
{
FileDescriptorProto file_proto;
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
}
{
FileDescriptorProto any_proto;
google::protobuf::Any::descriptor()->file()->CopyTo(&any_proto);
ASSERT_TRUE(pool.BuildFile(any_proto) != nullptr);
}
FileDescriptorProto file_proto;
protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
@ -3635,14 +3640,17 @@ TEST(CustomOptions, MessageOptionRepeatedLeafFieldSet) {
// when they are merged into the final option value.
DescriptorPool pool;
{
FileDescriptorProto file_proto;
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
}
{
FileDescriptorProto any_proto;
google::protobuf::Any::descriptor()->file()->CopyTo(&any_proto);
ASSERT_TRUE(pool.BuildFile(any_proto) != nullptr);
}
FileDescriptorProto file_proto;
protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
@ -3719,14 +3727,17 @@ TEST(CustomOptions, MessageOptionRepeatedMsgFieldSet) {
// when they are merged into the final option value.
DescriptorPool pool;
{
FileDescriptorProto file_proto;
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
}
{
FileDescriptorProto any_proto;
google::protobuf::Any::descriptor()->file()->CopyTo(&any_proto);
ASSERT_TRUE(pool.BuildFile(any_proto) != nullptr);
}
FileDescriptorProto file_proto;
protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
@ -3849,14 +3860,17 @@ TEST(CustomOptions, AggregateOptions) {
TEST(CustomOptions, UnusedImportError) {
DescriptorPool pool;
{
FileDescriptorProto file_proto;
FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);
}
{
FileDescriptorProto any_proto;
google::protobuf::Any::descriptor()->file()->CopyTo(&any_proto);
ASSERT_TRUE(pool.BuildFile(any_proto) != nullptr);
}
FileDescriptorProto file_proto;
protobuf_unittest::TestMessageWithCustomOptions::descriptor()->file()->CopyTo(
&file_proto);
ASSERT_TRUE(pool.BuildFile(file_proto) != nullptr);

Write Preview
Loading…
Cancel
Save