~ubuntu-branches/debian/stretch/protobuf/stretch

« back to all changes in this revision

Viewing changes to src/google/protobuf/compiler/java/java_enum_field.cc

  • Committer: Package Import Robot
  • Author(s): Robert S. Edmonds
  • Date: 2014-09-11 22:50:10 UTC
  • mfrom: (10.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20140911225010-wt4yo9dpc1fzuq5g
Tags: 2.6.0-3
Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
35
35
#include <map>
36
36
#include <string>
37
37
 
 
38
#include <google/protobuf/stubs/common.h>
 
39
#include <google/protobuf/compiler/java/java_context.h>
 
40
#include <google/protobuf/compiler/java/java_doc_comment.h>
38
41
#include <google/protobuf/compiler/java/java_enum_field.h>
39
 
#include <google/protobuf/compiler/java/java_doc_comment.h>
40
 
#include <google/protobuf/stubs/common.h>
41
42
#include <google/protobuf/compiler/java/java_helpers.h>
 
43
#include <google/protobuf/compiler/java/java_name_resolver.h>
42
44
#include <google/protobuf/io/printer.h>
43
45
#include <google/protobuf/wire_format.h>
44
46
#include <google/protobuf/stubs/strutil.h>
50
52
 
51
53
namespace {
52
54
 
53
 
// TODO(kenton):  Factor out a "SetCommonFieldVariables()" to get rid of
54
 
//   repeat code between this and the other field types.
55
55
void SetEnumVariables(const FieldDescriptor* descriptor,
56
56
                      int messageBitIndex,
57
57
                      int builderBitIndex,
 
58
                      const FieldGeneratorInfo* info,
 
59
                      ClassNameResolver* name_resolver,
58
60
                      map<string, string>* variables) {
59
 
  (*variables)["name"] =
60
 
    UnderscoresToCamelCase(descriptor);
61
 
  (*variables)["capitalized_name"] =
62
 
    UnderscoresToCapitalizedCamelCase(descriptor);
63
 
  (*variables)["constant_name"] = FieldConstantName(descriptor);
64
 
  (*variables)["number"] = SimpleItoa(descriptor->number());
65
 
  (*variables)["type"] = ClassName(descriptor->enum_type());
66
 
  (*variables)["default"] = DefaultValue(descriptor);
 
61
  SetCommonFieldVariables(descriptor, info, variables);
 
62
 
 
63
  (*variables)["type"] =
 
64
      name_resolver->GetImmutableClassName(descriptor->enum_type());
 
65
  (*variables)["mutable_type"] =
 
66
      name_resolver->GetMutableClassName(descriptor->enum_type());
 
67
  (*variables)["default"] = ImmutableDefaultValue(descriptor, name_resolver);
67
68
  (*variables)["tag"] = SimpleItoa(internal::WireFormat::MakeTag(descriptor));
68
69
  (*variables)["tag_size"] = SimpleItoa(
69
70
      internal::WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
74
75
  (*variables)["on_changed"] =
75
76
      HasDescriptorMethods(descriptor->containing_type()) ? "onChanged();" : "";
76
77
 
77
 
  // For singular messages and builders, one bit is used for the hasField bit.
78
 
  (*variables)["get_has_field_bit_message"] = GenerateGetBit(messageBitIndex);
79
 
  (*variables)["set_has_field_bit_message"] = GenerateSetBit(messageBitIndex);
80
 
 
81
 
  (*variables)["get_has_field_bit_builder"] = GenerateGetBit(builderBitIndex);
82
 
  (*variables)["set_has_field_bit_builder"] = GenerateSetBit(builderBitIndex);
83
 
  (*variables)["clear_has_field_bit_builder"] =
84
 
      GenerateClearBit(builderBitIndex);
 
78
  if (SupportFieldPresence(descriptor->file())) {
 
79
    // For singular messages and builders, one bit is used for the hasField bit.
 
80
    (*variables)["get_has_field_bit_message"] = GenerateGetBit(messageBitIndex);
 
81
    (*variables)["get_has_field_bit_builder"] = GenerateGetBit(builderBitIndex);
 
82
 
 
83
    // Note that these have a trailing ";".
 
84
    (*variables)["set_has_field_bit_message"] =
 
85
        GenerateSetBit(messageBitIndex) + ";";
 
86
    (*variables)["set_has_field_bit_builder"] =
 
87
        GenerateSetBit(builderBitIndex) + ";";
 
88
    (*variables)["clear_has_field_bit_builder"] =
 
89
        GenerateClearBit(builderBitIndex) + ";";
 
90
 
 
91
    (*variables)["is_field_present_message"] = GenerateGetBit(messageBitIndex);
 
92
  } else {
 
93
    (*variables)["set_has_field_bit_message"] = "";
 
94
    (*variables)["set_has_field_bit_builder"] = "";
 
95
    (*variables)["clear_has_field_bit_builder"] = "";
 
96
 
 
97
    (*variables)["is_field_present_message"] =
 
98
          (*variables)["name"] + "_ != " + (*variables)["default"];
 
99
  }
85
100
 
86
101
  // For repated builders, one bit is used for whether the array is immutable.
87
102
  (*variables)["get_mutable_bit_builder"] = GenerateGetBit(builderBitIndex);
105
120
 
106
121
// ===================================================================
107
122
 
108
 
EnumFieldGenerator::
109
 
EnumFieldGenerator(const FieldDescriptor* descriptor,
110
 
                      int messageBitIndex,
111
 
                      int builderBitIndex)
 
123
ImmutableEnumFieldGenerator::
 
124
ImmutableEnumFieldGenerator(const FieldDescriptor* descriptor,
 
125
                            int messageBitIndex,
 
126
                            int builderBitIndex,
 
127
                            Context* context)
112
128
  : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
113
 
    builderBitIndex_(builderBitIndex) {
114
 
  SetEnumVariables(descriptor, messageBitIndex, builderBitIndex, &variables_);
115
 
}
116
 
 
117
 
EnumFieldGenerator::~EnumFieldGenerator() {}
118
 
 
119
 
int EnumFieldGenerator::GetNumBitsForMessage() const {
120
 
  return 1;
121
 
}
122
 
 
123
 
int EnumFieldGenerator::GetNumBitsForBuilder() const {
124
 
  return 1;
125
 
}
126
 
 
127
 
void EnumFieldGenerator::
 
129
    builderBitIndex_(builderBitIndex),
 
130
    name_resolver_(context->GetNameResolver()) {
 
131
  SetEnumVariables(descriptor, messageBitIndex, builderBitIndex,
 
132
                   context->GetFieldGeneratorInfo(descriptor),
 
133
                   name_resolver_, &variables_);
 
134
}
 
135
 
 
136
ImmutableEnumFieldGenerator::~ImmutableEnumFieldGenerator() {}
 
137
 
 
138
int ImmutableEnumFieldGenerator::GetNumBitsForMessage() const {
 
139
  return 1;
 
140
}
 
141
 
 
142
int ImmutableEnumFieldGenerator::GetNumBitsForBuilder() const {
 
143
  return 1;
 
144
}
 
145
 
 
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");
 
152
  }
132
153
  WriteFieldDocComment(printer, descriptor_);
133
154
  printer->Print(variables_,
134
155
    "$deprecation$$type$ get$capitalized_name$();\n");
135
156
}
136
157
 
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"
145
 
    "}\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"
 
168
      "}\n");
 
169
  }
146
170
  WriteFieldDocComment(printer, descriptor_);
147
171
  printer->Print(variables_,
148
172
    "$deprecation$public $type$ get$capitalized_name$() {\n"
150
174
    "}\n");
151
175
}
152
176
 
153
 
void EnumFieldGenerator::
 
177
void ImmutableEnumFieldGenerator::
154
178
GenerateBuilderMembers(io::Printer* printer) const {
155
179
  printer->Print(variables_,
156
180
    "private $type$ $name$_ = $default$;\n");
157
 
  WriteFieldDocComment(printer, descriptor_);
158
 
  printer->Print(variables_,
159
 
    "$deprecation$public boolean has$capitalized_name$() {\n"
160
 
    "  return $get_has_field_bit_builder$;\n"
161
 
    "}\n");
 
181
  if (SupportFieldPresence(descriptor_->file())) {
 
182
    WriteFieldDocComment(printer, descriptor_);
 
183
    printer->Print(variables_,
 
184
      "$deprecation$public boolean has$capitalized_name$() {\n"
 
185
      "  return $get_has_field_bit_builder$;\n"
 
186
      "}\n");
 
187
  }
162
188
  WriteFieldDocComment(printer, descriptor_);
163
189
  printer->Print(variables_,
164
190
    "$deprecation$public $type$ get$capitalized_name$() {\n"
170
196
    "  if (value == null) {\n"
171
197
    "    throw new NullPointerException();\n"
172
198
    "  }\n"
173
 
    "  $set_has_field_bit_builder$;\n"
 
199
    "  $set_has_field_bit_builder$\n"
174
200
    "  $name$_ = value;\n"
175
201
    "  $on_changed$\n"
176
202
    "  return this;\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"
185
211
    "}\n");
186
212
}
187
213
 
188
 
void EnumFieldGenerator::
 
214
void ImmutableEnumFieldGenerator::
189
215
GenerateFieldBuilderInitializationCode(io::Printer* printer)  const {
190
216
  // noop for enums
191
217
}
192
218
 
193
 
void EnumFieldGenerator::
 
219
void ImmutableEnumFieldGenerator::
194
220
GenerateInitializationCode(io::Printer* printer) const {
195
221
  printer->Print(variables_, "$name$_ = $default$;\n");
196
222
}
197
223
 
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");
203
229
}
204
230
 
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"
210
 
    "}\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"
 
237
      "}\n");
 
238
  } else {
 
239
    printer->Print(variables_,
 
240
      "if (other.get$capitalized_name$() != $default$) {\n"
 
241
      "  set$capitalized_name$(other.get$capitalized_name$());\n"
 
242
      "}\n");
 
243
  }
211
244
}
212
245
 
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"
 
252
      "}\n");
 
253
  }
215
254
  printer->Print(variables_,
216
 
    "if ($get_has_field_bit_from_local$) {\n"
217
 
    "  $set_has_field_bit_to_local$;\n"
218
 
    "}\n"
219
255
    "result.$name$_ = $name$_;\n");
220
256
}
221
257
 
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"
231
 
      "} else {\n");
 
266
      "  unknownFields.mergeVarintField($number$, rawValue);\n");
232
267
  } else {
233
268
    printer->Print(variables_,
234
 
      "if (value != null) {\n");
 
269
      "  unknownFieldsCodedOutput.writeRawVarint32(tag);\n"
 
270
      "  unknownFieldsCodedOutput.writeRawVarint32(rawValue);\n");
235
271
  }
236
272
  printer->Print(variables_,
237
 
    "  $set_has_field_bit_message$;\n"
 
273
    "} else {\n"
 
274
    "  $set_has_field_bit_message$\n"
238
275
    "  $name$_ = value;\n"
239
276
    "}\n");
240
277
}
241
278
 
242
 
void EnumFieldGenerator::
 
279
void ImmutableEnumFieldGenerator::
243
280
GenerateParsingDoneCode(io::Printer* printer) const {
244
281
  // noop for enums
245
282
}
246
283
 
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"
252
289
    "}\n");
253
290
}
254
291
 
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"
261
298
    "}\n");
262
299
}
263
300
 
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");
269
306
}
270
307
 
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");
276
 
}
277
 
 
278
 
string EnumFieldGenerator::GetBoxedType() const {
279
 
  return ClassName(descriptor_->enum_type());
280
 
}
281
 
 
282
 
// ===================================================================
283
 
 
284
 
RepeatedEnumFieldGenerator::
285
 
RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor,
286
 
                           int messageBitIndex,
287
 
                           int builderBitIndex)
 
312
    "hash = (53 * hash) + com.google.protobuf.Internal.hashEnum(\n"
 
313
    "    get$capitalized_name$());\n");
 
314
}
 
315
 
 
316
string ImmutableEnumFieldGenerator::GetBoxedType() const {
 
317
  return name_resolver_->GetImmutableClassName(descriptor_->enum_type());
 
318
}
 
319
 
 
320
// ===================================================================
 
321
 
 
322
ImmutableEnumOneofFieldGenerator::
 
323
ImmutableEnumOneofFieldGenerator(const FieldDescriptor* descriptor,
 
324
                                 int messageBitIndex,
 
325
                                 int builderBitIndex,
 
326
                                 Context* context)
 
327
    : ImmutableEnumFieldGenerator(
 
328
          descriptor, messageBitIndex, builderBitIndex, context) {
 
329
  const OneofGeneratorInfo* info =
 
330
      context->GetOneofGeneratorInfo(descriptor->containing_oneof());
 
331
  SetCommonOneofVariables(descriptor, info, &variables_);
 
332
}
 
333
 
 
334
ImmutableEnumOneofFieldGenerator::
 
335
~ImmutableEnumOneofFieldGenerator() {}
 
336
 
 
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"
 
345
      "}\n");
 
346
  }
 
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"
 
352
    "  }\n"
 
353
    "  return $default$;\n"
 
354
    "}\n");
 
355
}
 
356
 
 
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"
 
364
      "}\n");
 
365
  }
 
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"
 
371
    "  }\n"
 
372
    "  return $default$;\n"
 
373
    "}\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"
 
379
    "  }\n"
 
380
    "  $set_oneof_case_message$;\n"
 
381
    "  $oneof_name$_ = value;\n"
 
382
    "  $on_changed$\n"
 
383
    "  return this;\n"
 
384
    "}\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"
 
391
    "    $on_changed$\n"
 
392
    "  }\n"
 
393
    "  return this;\n"
 
394
    "}\n");
 
395
}
 
396
 
 
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"
 
402
    "}\n");
 
403
}
 
404
 
 
405
void ImmutableEnumOneofFieldGenerator::
 
406
GenerateMergingCode(io::Printer* printer) const {
 
407
  printer->Print(variables_,
 
408
    "set$capitalized_name$(other.get$capitalized_name$());\n");
 
409
}
 
410
 
 
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");
 
420
  } else {
 
421
    printer->Print(variables_,
 
422
      "  unknownFieldsCodedOutput.writeRawVarint32(tag);\n"
 
423
      "  unknownFieldsCodedOutput.writeRawVarint32(rawValue);\n");
 
424
  }
 
425
  printer->Print(variables_,
 
426
    "} else {\n"
 
427
    "  $set_oneof_case_message$;\n"
 
428
    "  $oneof_name$_ = value;\n"
 
429
    "}\n");
 
430
}
 
431
 
 
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"
 
437
    "}\n");
 
438
}
 
439
 
 
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"
 
446
    "}\n");
 
447
}
 
448
 
 
449
// ===================================================================
 
450
 
 
451
RepeatedImmutableEnumFieldGenerator::
 
452
RepeatedImmutableEnumFieldGenerator(const FieldDescriptor* descriptor,
 
453
                                    int messageBitIndex,
 
454
                                    int builderBitIndex,
 
455
                                    Context* context)
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_);
291
462
}
292
463
 
293
 
RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {}
 
464
RepeatedImmutableEnumFieldGenerator::~RepeatedImmutableEnumFieldGenerator() {}
294
465
 
295
 
int RepeatedEnumFieldGenerator::GetNumBitsForMessage() const {
 
466
int RepeatedImmutableEnumFieldGenerator::GetNumBitsForMessage() const {
296
467
  return 0;
297
468
}
298
469
 
299
 
int RepeatedEnumFieldGenerator::GetNumBitsForBuilder() const {
 
470
int RepeatedImmutableEnumFieldGenerator::GetNumBitsForBuilder() const {
300
471
  return 1;
301
472
}
302
473
 
303
 
void RepeatedEnumFieldGenerator::
 
474
void RepeatedImmutableEnumFieldGenerator::
304
475
GenerateInterfaceMembers(io::Printer* printer) const {
305
476
  WriteFieldDocComment(printer, descriptor_);
306
477
  printer->Print(variables_,
313
484
    "$deprecation$$type$ get$capitalized_name$(int index);\n");
314
485
}
315
486
 
316
 
void RepeatedEnumFieldGenerator::
 
487
void RepeatedImmutableEnumFieldGenerator::
317
488
GenerateMembers(io::Printer* printer) const {
318
489
  printer->Print(variables_,
319
490
    "private java.util.List<$type$> $name$_;\n");
 
491
  PrintExtraFieldInfo(variables_, printer);
320
492
  WriteFieldDocComment(printer, descriptor_);
321
493
  printer->Print(variables_,
322
494
    "$deprecation$public java.util.List<$type$> get$capitalized_name$List() {\n"
340
512
  }
341
513
}
342
514
 
343
 
void RepeatedEnumFieldGenerator::
 
515
void RepeatedImmutableEnumFieldGenerator::
344
516
GenerateBuilderMembers(io::Printer* printer) const {
345
517
  printer->Print(variables_,
346
518
    // One field is the list and the other field keeps track of whether the
409
581
    "$deprecation$public Builder addAll$capitalized_name$(\n"
410
582
    "    java.lang.Iterable<? extends $type$> values) {\n"
411
583
    "  ensure$capitalized_name$IsMutable();\n"
412
 
    "  super.addAll(values, $name$_);\n"
 
584
    "  com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
 
585
    "      values, $name$_);\n"
413
586
    "  $on_changed$\n"
414
587
    "  return this;\n"
415
588
    "}\n");
423
596
    "}\n");
424
597
}
425
598
 
426
 
void RepeatedEnumFieldGenerator::
 
599
void RepeatedImmutableEnumFieldGenerator::
427
600
GenerateFieldBuilderInitializationCode(io::Printer* printer)  const {
428
601
  // noop for enums
429
602
}
430
603
 
431
 
void RepeatedEnumFieldGenerator::
 
604
void RepeatedImmutableEnumFieldGenerator::
432
605
GenerateInitializationCode(io::Printer* printer) const {
433
606
  printer->Print(variables_, "$name$_ = java.util.Collections.emptyList();\n");
434
607
}
435
608
 
436
 
void RepeatedEnumFieldGenerator::
 
609
void RepeatedImmutableEnumFieldGenerator::
437
610
GenerateBuilderClearCode(io::Printer* printer) const {
438
611
  printer->Print(variables_,
439
612
    "$name$_ = java.util.Collections.emptyList();\n"
440
613
    "$clear_mutable_bit_builder$;\n");
441
614
}
442
615
 
443
 
void RepeatedEnumFieldGenerator::
 
616
void RepeatedImmutableEnumFieldGenerator::
444
617
GenerateMergingCode(io::Printer* printer) const {
445
618
  // The code below does two optimizations:
446
619
  //   1. If the other list is empty, there's nothing to do. This ensures we
460
633
    "}\n");
461
634
}
462
635
 
463
 
void RepeatedEnumFieldGenerator::
 
636
void RepeatedImmutableEnumFieldGenerator::
464
637
GenerateBuildingCode(io::Printer* printer) const {
465
638
  // The code below ensures that the result has an immutable list. If our
466
639
  // list is immutable, we can just reuse it. If not, we make it immutable.
472
645
    "result.$name$_ = $name$_;\n");
473
646
}
474
647
 
475
 
void RepeatedEnumFieldGenerator::
 
648
void RepeatedImmutableEnumFieldGenerator::
476
649
GenerateParsingCode(io::Printer* printer) const {
477
650
  // Read and store the enum
478
651
  printer->Print(variables_,
479
652
    "int rawValue = input.readEnum();\n"
480
 
    "$type$ value = $type$.valueOf(rawValue);\n");
481
 
  if (HasUnknownFields(descriptor_->containing_type())) {
 
653
    "$type$ value = $type$.valueOf(rawValue);\n"
 
654
    "if (value == null) {\n");
 
655
  if (UseUnknownFieldSet(descriptor_->containing_type())) {
482
656
    printer->Print(variables_,
483
 
      "if (value == null) {\n"
484
 
      "  unknownFields.mergeVarintField($number$, rawValue);\n"
485
 
      "} else {\n");
 
657
      "  unknownFields.mergeVarintField($number$, rawValue);\n");
486
658
  } else {
487
659
    printer->Print(variables_,
488
 
      "if (value != null) {\n");
 
660
      "  unknownFieldsCodedOutput.writeRawVarint32(tag);\n"
 
661
      "  unknownFieldsCodedOutput.writeRawVarint32(rawValue);\n");
489
662
  }
490
663
  printer->Print(variables_,
 
664
    "  } else {\n"
491
665
    "  if (!$get_mutable_bit_parser$) {\n"
492
666
    "    $name$_ = new java.util.ArrayList<$type$>();\n"
493
667
    "    $set_mutable_bit_parser$;\n"
496
670
    "}\n");
497
671
}
498
672
 
499
 
void RepeatedEnumFieldGenerator::
 
673
void RepeatedImmutableEnumFieldGenerator::
500
674
GenerateParsingCodeFromPacked(io::Printer* printer) const {
501
675
  // Wrap GenerateParsingCode's contents with a while loop.
502
676
 
514
688
    "input.popLimit(oldLimit);\n");
515
689
}
516
690
 
517
 
void RepeatedEnumFieldGenerator::
 
691
void RepeatedImmutableEnumFieldGenerator::
518
692
GenerateParsingDoneCode(io::Printer* printer) const {
519
693
  printer->Print(variables_,
520
694
    "if ($get_mutable_bit_parser$) {\n"
522
696
    "}\n");
523
697
}
524
698
 
525
 
void RepeatedEnumFieldGenerator::
 
699
void RepeatedImmutableEnumFieldGenerator::
526
700
GenerateSerializationCode(io::Printer* printer) const {
527
701
  if (descriptor_->options().packed()) {
528
702
    printer->Print(variables_,
541
715
  }
542
716
}
543
717
 
544
 
void RepeatedEnumFieldGenerator::
 
718
void RepeatedImmutableEnumFieldGenerator::
545
719
GenerateSerializedSizeCode(io::Printer* printer) const {
546
720
  printer->Print(variables_,
547
721
    "{\n"
577
751
  printer->Print("}\n");
578
752
}
579
753
 
580
 
void RepeatedEnumFieldGenerator::
 
754
void RepeatedImmutableEnumFieldGenerator::
581
755
GenerateEqualsCode(io::Printer* printer) const {
582
756
  printer->Print(variables_,
583
757
    "result = result && get$capitalized_name$List()\n"
584
758
    "    .equals(other.get$capitalized_name$List());\n");
585
759
}
586
760
 
587
 
void RepeatedEnumFieldGenerator::
 
761
void RepeatedImmutableEnumFieldGenerator::
588
762
GenerateHashCode(io::Printer* printer) const {
589
763
  printer->Print(variables_,
590
764
    "if (get$capitalized_name$Count() > 0) {\n"
591
765
    "  hash = (37 * hash) + $constant_name$;\n"
592
 
    "  hash = (53 * hash) + hashEnumList(get$capitalized_name$List());\n"
 
766
    "  hash = (53 * hash) + com.google.protobuf.Internal.hashEnumList(\n"
 
767
    "      get$capitalized_name$List());\n"
593
768
    "}\n");
594
769
}
595
770
 
596
 
string RepeatedEnumFieldGenerator::GetBoxedType() const {
597
 
  return ClassName(descriptor_->enum_type());
 
771
string RepeatedImmutableEnumFieldGenerator::GetBoxedType() const {
 
772
  return name_resolver_->GetImmutableClassName(descriptor_->enum_type());
598
773
}
599
774
 
600
775
}  // namespace java