106
121
// ===================================================================
109
EnumFieldGenerator(const FieldDescriptor* descriptor,
123
ImmutableEnumFieldGenerator::
124
ImmutableEnumFieldGenerator(const FieldDescriptor* descriptor,
112
128
: descriptor_(descriptor), messageBitIndex_(messageBitIndex),
113
builderBitIndex_(builderBitIndex) {
114
SetEnumVariables(descriptor, messageBitIndex, builderBitIndex, &variables_);
117
EnumFieldGenerator::~EnumFieldGenerator() {}
119
int EnumFieldGenerator::GetNumBitsForMessage() const {
123
int EnumFieldGenerator::GetNumBitsForBuilder() const {
127
void EnumFieldGenerator::
129
builderBitIndex_(builderBitIndex),
130
name_resolver_(context->GetNameResolver()) {
131
SetEnumVariables(descriptor, messageBitIndex, builderBitIndex,
132
context->GetFieldGeneratorInfo(descriptor),
133
name_resolver_, &variables_);
136
ImmutableEnumFieldGenerator::~ImmutableEnumFieldGenerator() {}
138
int ImmutableEnumFieldGenerator::GetNumBitsForMessage() const {
142
int ImmutableEnumFieldGenerator::GetNumBitsForBuilder() const {
146
void ImmutableEnumFieldGenerator::
128
147
GenerateInterfaceMembers(io::Printer* printer) const {
129
WriteFieldDocComment(printer, descriptor_);
130
printer->Print(variables_,
131
"$deprecation$boolean has$capitalized_name$();\n");
148
if (SupportFieldPresence(descriptor_->file())) {
149
WriteFieldDocComment(printer, descriptor_);
150
printer->Print(variables_,
151
"$deprecation$boolean has$capitalized_name$();\n");
132
153
WriteFieldDocComment(printer, descriptor_);
133
154
printer->Print(variables_,
134
155
"$deprecation$$type$ get$capitalized_name$();\n");
137
void EnumFieldGenerator::
158
void ImmutableEnumFieldGenerator::
138
159
GenerateMembers(io::Printer* printer) const {
139
160
printer->Print(variables_,
140
161
"private $type$ $name$_;\n");
141
WriteFieldDocComment(printer, descriptor_);
142
printer->Print(variables_,
143
"$deprecation$public boolean has$capitalized_name$() {\n"
144
" return $get_has_field_bit_message$;\n"
162
PrintExtraFieldInfo(variables_, printer);
163
if (SupportFieldPresence(descriptor_->file())) {
164
WriteFieldDocComment(printer, descriptor_);
165
printer->Print(variables_,
166
"$deprecation$public boolean has$capitalized_name$() {\n"
167
" return $get_has_field_bit_message$;\n"
146
170
WriteFieldDocComment(printer, descriptor_);
147
171
printer->Print(variables_,
148
172
"$deprecation$public $type$ get$capitalized_name$() {\n"
178
204
WriteFieldDocComment(printer, descriptor_);
179
205
printer->Print(variables_,
180
206
"$deprecation$public Builder clear$capitalized_name$() {\n"
181
" $clear_has_field_bit_builder$;\n"
207
" $clear_has_field_bit_builder$\n"
182
208
" $name$_ = $default$;\n"
183
209
" $on_changed$\n"
184
210
" return this;\n"
188
void EnumFieldGenerator::
214
void ImmutableEnumFieldGenerator::
189
215
GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
190
216
// noop for enums
193
void EnumFieldGenerator::
219
void ImmutableEnumFieldGenerator::
194
220
GenerateInitializationCode(io::Printer* printer) const {
195
221
printer->Print(variables_, "$name$_ = $default$;\n");
198
void EnumFieldGenerator::
224
void ImmutableEnumFieldGenerator::
199
225
GenerateBuilderClearCode(io::Printer* printer) const {
200
226
printer->Print(variables_,
201
"$name$_ = $default$;\n"
202
"$clear_has_field_bit_builder$;\n");
227
"$name$_ = $default$;\n"
228
"$clear_has_field_bit_builder$\n");
205
void EnumFieldGenerator::
231
void ImmutableEnumFieldGenerator::
206
232
GenerateMergingCode(io::Printer* printer) const {
207
printer->Print(variables_,
208
"if (other.has$capitalized_name$()) {\n"
209
" set$capitalized_name$(other.get$capitalized_name$());\n"
233
if (SupportFieldPresence(descriptor_->file())) {
234
printer->Print(variables_,
235
"if (other.has$capitalized_name$()) {\n"
236
" set$capitalized_name$(other.get$capitalized_name$());\n"
239
printer->Print(variables_,
240
"if (other.get$capitalized_name$() != $default$) {\n"
241
" set$capitalized_name$(other.get$capitalized_name$());\n"
213
void EnumFieldGenerator::
246
void ImmutableEnumFieldGenerator::
214
247
GenerateBuildingCode(io::Printer* printer) const {
248
if (SupportFieldPresence(descriptor_->file())) {
249
printer->Print(variables_,
250
"if ($get_has_field_bit_from_local$) {\n"
251
" $set_has_field_bit_to_local$;\n"
215
254
printer->Print(variables_,
216
"if ($get_has_field_bit_from_local$) {\n"
217
" $set_has_field_bit_to_local$;\n"
219
255
"result.$name$_ = $name$_;\n");
222
void EnumFieldGenerator::
258
void ImmutableEnumFieldGenerator::
223
259
GenerateParsingCode(io::Printer* printer) const {
224
260
printer->Print(variables_,
225
261
"int rawValue = input.readEnum();\n"
226
"$type$ value = $type$.valueOf(rawValue);\n");
227
if (HasUnknownFields(descriptor_->containing_type())) {
262
"$type$ value = $type$.valueOf(rawValue);\n"
263
"if (value == null) {\n");
264
if (UseUnknownFieldSet(descriptor_->containing_type())) {
228
265
printer->Print(variables_,
229
"if (value == null) {\n"
230
" unknownFields.mergeVarintField($number$, rawValue);\n"
266
" unknownFields.mergeVarintField($number$, rawValue);\n");
233
268
printer->Print(variables_,
234
"if (value != null) {\n");
269
" unknownFieldsCodedOutput.writeRawVarint32(tag);\n"
270
" unknownFieldsCodedOutput.writeRawVarint32(rawValue);\n");
236
272
printer->Print(variables_,
237
" $set_has_field_bit_message$;\n"
274
" $set_has_field_bit_message$\n"
238
275
" $name$_ = value;\n"
242
void EnumFieldGenerator::
279
void ImmutableEnumFieldGenerator::
243
280
GenerateParsingDoneCode(io::Printer* printer) const {
244
281
// noop for enums
247
void EnumFieldGenerator::
284
void ImmutableEnumFieldGenerator::
248
285
GenerateSerializationCode(io::Printer* printer) const {
249
286
printer->Print(variables_,
250
"if ($get_has_field_bit_message$) {\n"
287
"if ($is_field_present_message$) {\n"
251
288
" output.writeEnum($number$, $name$_.getNumber());\n"
255
void EnumFieldGenerator::
292
void ImmutableEnumFieldGenerator::
256
293
GenerateSerializedSizeCode(io::Printer* printer) const {
257
294
printer->Print(variables_,
258
"if ($get_has_field_bit_message$) {\n"
295
"if ($is_field_present_message$) {\n"
259
296
" size += com.google.protobuf.CodedOutputStream\n"
260
297
" .computeEnumSize($number$, $name$_.getNumber());\n"
264
void EnumFieldGenerator::
301
void ImmutableEnumFieldGenerator::
265
302
GenerateEqualsCode(io::Printer* printer) const {
266
303
printer->Print(variables_,
267
304
"result = result &&\n"
268
305
" (get$capitalized_name$() == other.get$capitalized_name$());\n");
271
void EnumFieldGenerator::
308
void ImmutableEnumFieldGenerator::
272
309
GenerateHashCode(io::Printer* printer) const {
273
310
printer->Print(variables_,
274
311
"hash = (37 * hash) + $constant_name$;\n"
275
"hash = (53 * hash) + hashEnum(get$capitalized_name$());\n");
278
string EnumFieldGenerator::GetBoxedType() const {
279
return ClassName(descriptor_->enum_type());
282
// ===================================================================
284
RepeatedEnumFieldGenerator::
285
RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor,
312
"hash = (53 * hash) + com.google.protobuf.Internal.hashEnum(\n"
313
" get$capitalized_name$());\n");
316
string ImmutableEnumFieldGenerator::GetBoxedType() const {
317
return name_resolver_->GetImmutableClassName(descriptor_->enum_type());
320
// ===================================================================
322
ImmutableEnumOneofFieldGenerator::
323
ImmutableEnumOneofFieldGenerator(const FieldDescriptor* descriptor,
327
: ImmutableEnumFieldGenerator(
328
descriptor, messageBitIndex, builderBitIndex, context) {
329
const OneofGeneratorInfo* info =
330
context->GetOneofGeneratorInfo(descriptor->containing_oneof());
331
SetCommonOneofVariables(descriptor, info, &variables_);
334
ImmutableEnumOneofFieldGenerator::
335
~ImmutableEnumOneofFieldGenerator() {}
337
void ImmutableEnumOneofFieldGenerator::
338
GenerateMembers(io::Printer* printer) const {
339
PrintExtraFieldInfo(variables_, printer);
340
if (SupportFieldPresence(descriptor_->file())) {
341
WriteFieldDocComment(printer, descriptor_);
342
printer->Print(variables_,
343
"$deprecation$public boolean has$capitalized_name$() {\n"
344
" return $has_oneof_case_message$;\n"
347
WriteFieldDocComment(printer, descriptor_);
348
printer->Print(variables_,
349
"$deprecation$public $type$ get$capitalized_name$() {\n"
350
" if ($has_oneof_case_message$) {\n"
351
" return ($type$) $oneof_name$_;\n"
353
" return $default$;\n"
357
void ImmutableEnumOneofFieldGenerator::
358
GenerateBuilderMembers(io::Printer* printer) const {
359
if (SupportFieldPresence(descriptor_->file())) {
360
WriteFieldDocComment(printer, descriptor_);
361
printer->Print(variables_,
362
"$deprecation$public boolean has$capitalized_name$() {\n"
363
" return $has_oneof_case_message$;\n"
366
WriteFieldDocComment(printer, descriptor_);
367
printer->Print(variables_,
368
"$deprecation$public $type$ get$capitalized_name$() {\n"
369
" if ($has_oneof_case_message$) {\n"
370
" return ($type$) $oneof_name$_;\n"
372
" return $default$;\n"
374
WriteFieldDocComment(printer, descriptor_);
375
printer->Print(variables_,
376
"$deprecation$public Builder set$capitalized_name$($type$ value) {\n"
377
" if (value == null) {\n"
378
" throw new NullPointerException();\n"
380
" $set_oneof_case_message$;\n"
381
" $oneof_name$_ = value;\n"
385
WriteFieldDocComment(printer, descriptor_);
386
printer->Print(variables_,
387
"$deprecation$public Builder clear$capitalized_name$() {\n"
388
" if ($has_oneof_case_message$) {\n"
389
" $clear_oneof_case_message$;\n"
390
" $oneof_name$_ = null;\n"
397
void ImmutableEnumOneofFieldGenerator::
398
GenerateBuildingCode(io::Printer* printer) const {
399
printer->Print(variables_,
400
"if ($has_oneof_case_message$) {\n"
401
" result.$oneof_name$_ = $oneof_name$_;\n"
405
void ImmutableEnumOneofFieldGenerator::
406
GenerateMergingCode(io::Printer* printer) const {
407
printer->Print(variables_,
408
"set$capitalized_name$(other.get$capitalized_name$());\n");
411
void ImmutableEnumOneofFieldGenerator::
412
GenerateParsingCode(io::Printer* printer) const {
413
printer->Print(variables_,
414
"int rawValue = input.readEnum();\n"
415
"$type$ value = $type$.valueOf(rawValue);\n"
416
"if (value == null) {\n");
417
if (UseUnknownFieldSet(descriptor_->containing_type())) {
418
printer->Print(variables_,
419
" unknownFields.mergeVarintField($number$, rawValue);\n");
421
printer->Print(variables_,
422
" unknownFieldsCodedOutput.writeRawVarint32(tag);\n"
423
" unknownFieldsCodedOutput.writeRawVarint32(rawValue);\n");
425
printer->Print(variables_,
427
" $set_oneof_case_message$;\n"
428
" $oneof_name$_ = value;\n"
432
void ImmutableEnumOneofFieldGenerator::
433
GenerateSerializationCode(io::Printer* printer) const {
434
printer->Print(variables_,
435
"if ($has_oneof_case_message$) {\n"
436
" output.writeEnum($number$, (($type$) $oneof_name$_).getNumber());\n"
440
void ImmutableEnumOneofFieldGenerator::
441
GenerateSerializedSizeCode(io::Printer* printer) const {
442
printer->Print(variables_,
443
"if ($has_oneof_case_message$) {\n"
444
" size += com.google.protobuf.CodedOutputStream\n"
445
" .computeEnumSize($number$, (($type$) $oneof_name$_).getNumber());\n"
449
// ===================================================================
451
RepeatedImmutableEnumFieldGenerator::
452
RepeatedImmutableEnumFieldGenerator(const FieldDescriptor* descriptor,
288
456
: descriptor_(descriptor), messageBitIndex_(messageBitIndex),
289
builderBitIndex_(builderBitIndex) {
290
SetEnumVariables(descriptor, messageBitIndex, builderBitIndex, &variables_);
457
builderBitIndex_(builderBitIndex), context_(context),
458
name_resolver_(context->GetNameResolver()) {
459
SetEnumVariables(descriptor, messageBitIndex, builderBitIndex,
460
context->GetFieldGeneratorInfo(descriptor),
461
name_resolver_, &variables_);
293
RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {}
464
RepeatedImmutableEnumFieldGenerator::~RepeatedImmutableEnumFieldGenerator() {}
295
int RepeatedEnumFieldGenerator::GetNumBitsForMessage() const {
466
int RepeatedImmutableEnumFieldGenerator::GetNumBitsForMessage() const {
299
int RepeatedEnumFieldGenerator::GetNumBitsForBuilder() const {
470
int RepeatedImmutableEnumFieldGenerator::GetNumBitsForBuilder() const {
303
void RepeatedEnumFieldGenerator::
474
void RepeatedImmutableEnumFieldGenerator::
304
475
GenerateInterfaceMembers(io::Printer* printer) const {
305
476
WriteFieldDocComment(printer, descriptor_);
306
477
printer->Print(variables_,