← Back to branch summary

~ubuntu-branches/ubuntu/trusty/protobuf/trusty-proposed

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2011-05-31 14:41:47 UTC
  • mfrom: (2.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20110531144147-s41g5fozgvyo462l
Tags: 2.4.0a-2ubuntu1
* Merge with Debian; remaining changes:
  - Fix linking with -lpthread.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/compiler/java/java_message_field.cc
51
51
// TODO(kenton):  Factor out a "SetCommonFieldVariables()" to get rid of
52
52
//   repeat code between this and the other field types.
53
53
void SetMessageVariables(const FieldDescriptor* descriptor,
 
54
                         int messageBitIndex,
 
55
                         int builderBitIndex,
54
56
                         map<string, string>* variables) {
55
57
  (*variables)["name"] =
56
58
    UnderscoresToCamelCase(descriptor);
57
59
  (*variables)["capitalized_name"] =
58
60
    UnderscoresToCapitalizedCamelCase(descriptor);
 
61
  (*variables)["constant_name"] = FieldConstantName(descriptor);
59
62
  (*variables)["number"] = SimpleItoa(descriptor->number());
60
63
  (*variables)["type"] = ClassName(descriptor->message_type());
61
64
  (*variables)["group_or_message"] =
62
65
    (GetType(descriptor) == FieldDescriptor::TYPE_GROUP) ?
63
66
    "Group" : "Message";
 
67
  // TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
 
68
  // by the proto compiler
 
69
  (*variables)["deprecation"] = descriptor->options().deprecated()
 
70
      ? "@java.lang.Deprecated " : "";
 
71
  (*variables)["on_changed"] =
 
72
      HasDescriptorMethods(descriptor->containing_type()) ? "onChanged();" : "";
 
73
 
 
74
  // For singular messages and builders, one bit is used for the hasField bit.
 
75
  (*variables)["get_has_field_bit_message"] = GenerateGetBit(messageBitIndex);
 
76
 
 
77
  (*variables)["get_has_field_bit_builder"] = GenerateGetBit(builderBitIndex);
 
78
  (*variables)["set_has_field_bit_builder"] = GenerateSetBit(builderBitIndex);
 
79
  (*variables)["clear_has_field_bit_builder"] =
 
80
      GenerateClearBit(builderBitIndex);
 
81
 
 
82
  // For repated builders, one bit is used for whether the array is immutable.
 
83
  (*variables)["get_mutable_bit_builder"] = GenerateGetBit(builderBitIndex);
 
84
  (*variables)["set_mutable_bit_builder"] = GenerateSetBit(builderBitIndex);
 
85
  (*variables)["clear_mutable_bit_builder"] = GenerateClearBit(builderBitIndex);
 
86
 
 
87
  (*variables)["get_has_field_bit_from_local"] =
 
88
      GenerateGetBitFromLocal(builderBitIndex);
 
89
  (*variables)["set_has_field_bit_to_local"] =
 
90
      GenerateSetBitToLocal(messageBitIndex);
64
91
}
65
92
 
66
93
}  // namespace
68
95
// ===================================================================
69
96
 
70
97
MessageFieldGenerator::
71
 
MessageFieldGenerator(const FieldDescriptor* descriptor)
72
 
  : descriptor_(descriptor) {
73
 
  SetMessageVariables(descriptor, &variables_);
 
98
MessageFieldGenerator(const FieldDescriptor* descriptor,
 
99
                      int messageBitIndex,
 
100
                      int builderBitIndex)
 
101
  : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
 
102
    builderBitIndex_(builderBitIndex) {
 
103
  SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
 
104
                      &variables_);
74
105
}
75
106
 
76
107
MessageFieldGenerator::~MessageFieldGenerator() {}
77
108
 
 
109
int MessageFieldGenerator::GetNumBitsForMessage() const {
 
110
  return 1;
 
111
}
 
112
 
 
113
int MessageFieldGenerator::GetNumBitsForBuilder() const {
 
114
  return 1;
 
115
}
 
116
 
 
117
void MessageFieldGenerator::
 
118
GenerateInterfaceMembers(io::Printer* printer) const {
 
119
  // TODO(jonp): In the future, consider having a method specific to the
 
120
  // interface so that builders can choose dynamically to either return a
 
121
  // message or a nested builder, so that asking for the interface doesn't
 
122
  // cause a message to ever be built.
 
123
  printer->Print(variables_,
 
124
    "$deprecation$boolean has$capitalized_name$();\n"
 
125
    "$deprecation$$type$ get$capitalized_name$();\n");
 
126
 
 
127
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
128
    printer->Print(variables_,
 
129
      "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder();\n");
 
130
  }
 
131
}
 
132
 
78
133
void MessageFieldGenerator::
79
134
GenerateMembers(io::Printer* printer) const {
80
135
  printer->Print(variables_,
81
 
    "private boolean has$capitalized_name$;\n"
82
136
    "private $type$ $name$_;\n"
83
 
    "public boolean has$capitalized_name$() { return has$capitalized_name$; }\n"
84
 
    "public $type$ get$capitalized_name$() { return $name$_; }\n");
 
137
    "$deprecation$public boolean has$capitalized_name$() {\n"
 
138
    "  return $get_has_field_bit_message$;\n"
 
139
    "}\n"
 
140
    "$deprecation$public $type$ get$capitalized_name$() {\n"
 
141
    "  return $name$_;\n"
 
142
    "}\n");
 
143
 
 
144
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
145
    printer->Print(variables_,
 
146
      "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
 
147
      "  return $name$_;\n"
 
148
      "}\n");
 
149
  }
 
150
}
 
151
 
 
152
void MessageFieldGenerator::PrintNestedBuilderCondition(
 
153
    io::Printer* printer,
 
154
    const char* regular_case,
 
155
    const char* nested_builder_case) const {
 
156
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
157
     printer->Print(variables_, "if ($name$Builder_ == null) {\n");
 
158
     printer->Indent();
 
159
     printer->Print(variables_, regular_case);
 
160
     printer->Outdent();
 
161
     printer->Print("} else {\n");
 
162
     printer->Indent();
 
163
     printer->Print(variables_, nested_builder_case);
 
164
     printer->Outdent();
 
165
     printer->Print("}\n");
 
166
   } else {
 
167
     printer->Print(variables_, regular_case);
 
168
   }
 
169
}
 
170
 
 
171
void MessageFieldGenerator::PrintNestedBuilderFunction(
 
172
    io::Printer* printer,
 
173
    const char* method_prototype,
 
174
    const char* regular_case,
 
175
    const char* nested_builder_case,
 
176
    const char* trailing_code) const {
 
177
  printer->Print(variables_, method_prototype);
 
178
  printer->Print(" {\n");
 
179
  printer->Indent();
 
180
  PrintNestedBuilderCondition(printer, regular_case, nested_builder_case);
 
181
  if (trailing_code != NULL) {
 
182
    printer->Print(variables_, trailing_code);
 
183
  }
 
184
  printer->Outdent();
 
185
  printer->Print("}\n");
85
186
}
86
187
 
87
188
void MessageFieldGenerator::
88
189
GenerateBuilderMembers(io::Printer* printer) const {
89
 
  printer->Print(variables_,
90
 
    "public boolean has$capitalized_name$() {\n"
91
 
    "  return result.has$capitalized_name$();\n"
92
 
    "}\n"
93
 
    "public $type$ get$capitalized_name$() {\n"
94
 
    "  return result.get$capitalized_name$();\n"
95
 
    "}\n"
96
 
    "public Builder set$capitalized_name$($type$ value) {\n"
97
 
    "  if (value == null) {\n"
98
 
    "    throw new NullPointerException();\n"
99
 
    "  }\n"
100
 
    "  result.has$capitalized_name$ = true;\n"
101
 
    "  result.$name$_ = value;\n"
102
 
    "  return this;\n"
103
 
    "}\n"
104
 
    "public Builder set$capitalized_name$($type$.Builder builderForValue) {\n"
105
 
    "  result.has$capitalized_name$ = true;\n"
106
 
    "  result.$name$_ = builderForValue.build();\n"
107
 
    "  return this;\n"
108
 
    "}\n"
109
 
    "public Builder merge$capitalized_name$($type$ value) {\n"
110
 
    "  if (result.has$capitalized_name$() &&\n"
111
 
    "      result.$name$_ != $type$.getDefaultInstance()) {\n"
112
 
    "    result.$name$_ =\n"
113
 
    "      $type$.newBuilder(result.$name$_).mergeFrom(value).buildPartial();\n"
114
 
    "  } else {\n"
115
 
    "    result.$name$_ = value;\n"
116
 
    "  }\n"
117
 
    "  result.has$capitalized_name$ = true;\n"
118
 
    "  return this;\n"
119
 
    "}\n"
120
 
    "public Builder clear$capitalized_name$() {\n"
121
 
    "  result.has$capitalized_name$ = false;\n"
122
 
    "  result.$name$_ = $type$.getDefaultInstance();\n"
123
 
    "  return this;\n"
 
190
  // When using nested-builders, the code initially works just like the
 
191
  // non-nested builder case. It only creates a nested builder lazily on
 
192
  // demand and then forever delegates to it after creation.
 
193
 
 
194
  printer->Print(variables_,
 
195
    // Used when the builder is null.
 
196
    "private $type$ $name$_ = $type$.getDefaultInstance();\n");
 
197
 
 
198
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
199
    printer->Print(variables_,
 
200
      // If this builder is non-null, it is used and the other fields are
 
201
      // ignored.
 
202
      "private com.google.protobuf.SingleFieldBuilder<\n"
 
203
      "    $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
 
204
      "\n");
 
205
  }
 
206
 
 
207
  // The comments above the methods below are based on a hypothetical
 
208
  // field of type "Field" called "Field".
 
209
 
 
210
  // boolean hasField()
 
211
  printer->Print(variables_,
 
212
    "$deprecation$public boolean has$capitalized_name$() {\n"
 
213
    "  return $get_has_field_bit_builder$;\n"
124
214
    "}\n");
125
 
}
 
215
 
 
216
  // Field getField()
 
217
  PrintNestedBuilderFunction(printer,
 
218
    "$deprecation$public $type$ get$capitalized_name$()",
 
219
 
 
220
    "return $name$_;\n",
 
221
 
 
222
    "return $name$Builder_.getMessage();\n",
 
223
 
 
224
    NULL);
 
225
 
 
226
  // Field.Builder setField(Field value)
 
227
  PrintNestedBuilderFunction(printer,
 
228
    "$deprecation$public Builder set$capitalized_name$($type$ value)",
 
229
 
 
230
    "if (value == null) {\n"
 
231
    "  throw new NullPointerException();\n"
 
232
    "}\n"
 
233
    "$name$_ = value;\n"
 
234
    "$on_changed$\n",
 
235
 
 
236
    "$name$Builder_.setMessage(value);\n",
 
237
 
 
238
    "$set_has_field_bit_builder$;\n"
 
239
    "return this;\n");
 
240
 
 
241
  // Field.Builder setField(Field.Builder builderForValue)
 
242
  PrintNestedBuilderFunction(printer,
 
243
    "$deprecation$public Builder set$capitalized_name$(\n"
 
244
    "    $type$.Builder builderForValue)",
 
245
 
 
246
    "$name$_ = builderForValue.build();\n"
 
247
    "$on_changed$\n",
 
248
 
 
249
    "$name$Builder_.setMessage(builderForValue.build());\n",
 
250
 
 
251
    "$set_has_field_bit_builder$;\n"
 
252
    "return this;\n");
 
253
 
 
254
  // Field.Builder mergeField(Field value)
 
255
  PrintNestedBuilderFunction(printer,
 
256
    "$deprecation$public Builder merge$capitalized_name$($type$ value)",
 
257
 
 
258
    "if ($get_has_field_bit_builder$ &&\n"
 
259
    "    $name$_ != $type$.getDefaultInstance()) {\n"
 
260
    "  $name$_ =\n"
 
261
    "    $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
 
262
    "} else {\n"
 
263
    "  $name$_ = value;\n"
 
264
    "}\n"
 
265
    "$on_changed$\n",
 
266
 
 
267
    "$name$Builder_.mergeFrom(value);\n",
 
268
 
 
269
    "$set_has_field_bit_builder$;\n"
 
270
    "return this;\n");
 
271
 
 
272
  // Field.Builder clearField()
 
273
  PrintNestedBuilderFunction(printer,
 
274
    "$deprecation$public Builder clear$capitalized_name$()",
 
275
 
 
276
    "$name$_ = $type$.getDefaultInstance();\n"
 
277
    "$on_changed$\n",
 
278
 
 
279
    "$name$Builder_.clear();\n",
 
280
 
 
281
    "$clear_has_field_bit_builder$;\n"
 
282
    "return this;\n");
 
283
 
 
284
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
285
    printer->Print(variables_,
 
286
      "$deprecation$public $type$.Builder get$capitalized_name$Builder() {\n"
 
287
      "  $set_has_field_bit_builder$;\n"
 
288
      "  $on_changed$\n"
 
289
      "  return get$capitalized_name$FieldBuilder().getBuilder();\n"
 
290
      "}\n"
 
291
      "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
 
292
      "  if ($name$Builder_ != null) {\n"
 
293
      "    return $name$Builder_.getMessageOrBuilder();\n"
 
294
      "  } else {\n"
 
295
      "    return $name$_;\n"
 
296
      "  }\n"
 
297
      "}\n"
 
298
      "private com.google.protobuf.SingleFieldBuilder<\n"
 
299
      "    $type$, $type$.Builder, $type$OrBuilder> \n"
 
300
      "    get$capitalized_name$FieldBuilder() {\n"
 
301
      "  if ($name$Builder_ == null) {\n"
 
302
      "    $name$Builder_ = new com.google.protobuf.SingleFieldBuilder<\n"
 
303
      "        $type$, $type$.Builder, $type$OrBuilder>(\n"
 
304
      "            $name$_,\n"
 
305
      "            getParentForChildren(),\n"
 
306
      "            isClean());\n"
 
307
      "    $name$_ = null;\n"
 
308
      "  }\n"
 
309
      "  return $name$Builder_;\n"
 
310
      "}\n");
 
311
  }
 
312
}
 
313
 
 
314
void MessageFieldGenerator::
 
315
GenerateFieldBuilderInitializationCode(io::Printer* printer)  const {
 
316
  printer->Print(variables_,
 
317
    "get$capitalized_name$FieldBuilder();\n");
 
318
}
 
319
 
126
320
 
127
321
void MessageFieldGenerator::
128
322
GenerateInitializationCode(io::Printer* printer) const {
130
324
}
131
325
 
132
326
void MessageFieldGenerator::
 
327
GenerateBuilderClearCode(io::Printer* printer) const {
 
328
  PrintNestedBuilderCondition(printer,
 
329
    "$name$_ = $type$.getDefaultInstance();\n",
 
330
 
 
331
    "$name$Builder_.clear();\n");
 
332
  printer->Print(variables_, "$clear_has_field_bit_builder$;\n");
 
333
}
 
334
 
 
335
void MessageFieldGenerator::
133
336
GenerateMergingCode(io::Printer* printer) const {
134
337
  printer->Print(variables_,
135
338
    "if (other.has$capitalized_name$()) {\n"
139
342
 
140
343
void MessageFieldGenerator::
141
344
GenerateBuildingCode(io::Printer* printer) const {
142
 
  // Nothing to do for singular fields.
 
345
 
 
346
  printer->Print(variables_,
 
347
      "if ($get_has_field_bit_from_local$) {\n"
 
348
      "  $set_has_field_bit_to_local$;\n"
 
349
      "}\n");
 
350
 
 
351
  PrintNestedBuilderCondition(printer,
 
352
    "result.$name$_ = $name$_;\n",
 
353
 
 
354
    "result.$name$_ = $name$Builder_.build();\n");
143
355
}
144
356
 
145
357
void MessageFieldGenerator::
165
377
void MessageFieldGenerator::
166
378
GenerateSerializationCode(io::Printer* printer) const {
167
379
  printer->Print(variables_,
168
 
    "if (has$capitalized_name$()) {\n"
169
 
    "  output.write$group_or_message$($number$, get$capitalized_name$());\n"
 
380
    "if ($get_has_field_bit_message$) {\n"
 
381
    "  output.write$group_or_message$($number$, $name$_);\n"
170
382
    "}\n");
171
383
}
172
384
 
173
385
void MessageFieldGenerator::
174
386
GenerateSerializedSizeCode(io::Printer* printer) const {
175
387
  printer->Print(variables_,
176
 
    "if (has$capitalized_name$()) {\n"
 
388
    "if ($get_has_field_bit_message$) {\n"
177
389
    "  size += com.google.protobuf.CodedOutputStream\n"
178
 
    "    .compute$group_or_message$Size($number$, get$capitalized_name$());\n"
 
390
    "    .compute$group_or_message$Size($number$, $name$_);\n"
179
391
    "}\n");
180
392
}
181
393
 
 
394
void MessageFieldGenerator::
 
395
GenerateEqualsCode(io::Printer* printer) const {
 
396
  printer->Print(variables_,
 
397
    "result = result && get$capitalized_name$()\n"
 
398
    "    .equals(other.get$capitalized_name$());\n");
 
399
}
 
400
 
 
401
void MessageFieldGenerator::
 
402
GenerateHashCode(io::Printer* printer) const {
 
403
  printer->Print(variables_,
 
404
    "hash = (37 * hash) + $constant_name$;\n"
 
405
    "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
 
406
}
 
407
 
182
408
string MessageFieldGenerator::GetBoxedType() const {
183
409
  return ClassName(descriptor_->message_type());
184
410
}
186
412
// ===================================================================
187
413
 
188
414
RepeatedMessageFieldGenerator::
189
 
RepeatedMessageFieldGenerator(const FieldDescriptor* descriptor)
190
 
  : descriptor_(descriptor) {
191
 
  SetMessageVariables(descriptor, &variables_);
 
415
RepeatedMessageFieldGenerator(const FieldDescriptor* descriptor,
 
416
                              int messageBitIndex,
 
417
                              int builderBitIndex)
 
418
  : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
 
419
    builderBitIndex_(builderBitIndex) {
 
420
  SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
 
421
                      &variables_);
192
422
}
193
423
 
194
424
RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {}
195
425
 
 
426
int RepeatedMessageFieldGenerator::GetNumBitsForMessage() const {
 
427
  return 0;
 
428
}
 
429
 
 
430
int RepeatedMessageFieldGenerator::GetNumBitsForBuilder() const {
 
431
  return 1;
 
432
}
 
433
 
 
434
void RepeatedMessageFieldGenerator::
 
435
GenerateInterfaceMembers(io::Printer* printer) const {
 
436
  // TODO(jonp): In the future, consider having methods specific to the
 
437
  // interface so that builders can choose dynamically to either return a
 
438
  // message or a nested builder, so that asking for the interface doesn't
 
439
  // cause a message to ever be built.
 
440
  printer->Print(variables_,
 
441
    "$deprecation$java.util.List<$type$> \n"
 
442
    "    get$capitalized_name$List();\n"
 
443
    "$deprecation$$type$ get$capitalized_name$(int index);\n"
 
444
    "$deprecation$int get$capitalized_name$Count();\n");
 
445
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
446
    printer->Print(variables_,
 
447
      "$deprecation$java.util.List<? extends $type$OrBuilder> \n"
 
448
      "    get$capitalized_name$OrBuilderList();\n"
 
449
      "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder(\n"
 
450
      "    int index);\n");
 
451
  }
 
452
}
 
453
 
196
454
void RepeatedMessageFieldGenerator::
197
455
GenerateMembers(io::Printer* printer) const {
198
456
  printer->Print(variables_,
 
457
    "private java.util.List<$type$> $name$_;\n"
 
458
    "$deprecation$public java.util.List<$type$> get$capitalized_name$List() {\n"
 
459
    "  return $name$_;\n"   // note:  unmodifiable list
 
460
    "}\n"
 
461
    "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
 
462
    "    get$capitalized_name$OrBuilderList() {\n"
 
463
    "  return $name$_;\n"
 
464
    "}\n"
 
465
    "$deprecation$public int get$capitalized_name$Count() {\n"
 
466
    "  return $name$_.size();\n"
 
467
    "}\n"
 
468
    "$deprecation$public $type$ get$capitalized_name$(int index) {\n"
 
469
    "  return $name$_.get(index);\n"
 
470
    "}\n"
 
471
    "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
 
472
    "    int index) {\n"
 
473
    "  return $name$_.get(index);\n"
 
474
    "}\n");
 
475
 
 
476
}
 
477
 
 
478
void RepeatedMessageFieldGenerator::PrintNestedBuilderCondition(
 
479
    io::Printer* printer,
 
480
    const char* regular_case,
 
481
    const char* nested_builder_case) const {
 
482
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
483
     printer->Print(variables_, "if ($name$Builder_ == null) {\n");
 
484
     printer->Indent();
 
485
     printer->Print(variables_, regular_case);
 
486
     printer->Outdent();
 
487
     printer->Print("} else {\n");
 
488
     printer->Indent();
 
489
     printer->Print(variables_, nested_builder_case);
 
490
     printer->Outdent();
 
491
     printer->Print("}\n");
 
492
   } else {
 
493
     printer->Print(variables_, regular_case);
 
494
   }
 
495
}
 
496
 
 
497
void RepeatedMessageFieldGenerator::PrintNestedBuilderFunction(
 
498
    io::Printer* printer,
 
499
    const char* method_prototype,
 
500
    const char* regular_case,
 
501
    const char* nested_builder_case,
 
502
    const char* trailing_code) const {
 
503
  printer->Print(variables_, method_prototype);
 
504
  printer->Print(" {\n");
 
505
  printer->Indent();
 
506
  PrintNestedBuilderCondition(printer, regular_case, nested_builder_case);
 
507
  if (trailing_code != NULL) {
 
508
    printer->Print(variables_, trailing_code);
 
509
  }
 
510
  printer->Outdent();
 
511
  printer->Print("}\n");
 
512
}
 
513
 
 
514
void RepeatedMessageFieldGenerator::
 
515
GenerateBuilderMembers(io::Printer* printer) const {
 
516
  // When using nested-builders, the code initially works just like the
 
517
  // non-nested builder case. It only creates a nested builder lazily on
 
518
  // demand and then forever delegates to it after creation.
 
519
 
 
520
  printer->Print(variables_,
 
521
    // Used when the builder is null.
 
522
    // One field is the list and the other field keeps track of whether the
 
523
    // list is immutable. If it's immutable, the invariant is that it must
 
524
    // either an instance of Collections.emptyList() or it's an ArrayList
 
525
    // wrapped in a Collections.unmodifiableList() wrapper and nobody else has
 
526
    // a refererence to the underlying ArrayList. This invariant allows us to
 
527
    // share instances of lists between protocol buffers avoiding expensive
 
528
    // memory allocations. Note, immutable is a strong guarantee here -- not
 
529
    // just that the list cannot be modified via the reference but that the
 
530
    // list can never be modified.
199
531
    "private java.util.List<$type$> $name$_ =\n"
200
532
    "  java.util.Collections.emptyList();\n"
201
 
    "public java.util.List<$type$> get$capitalized_name$List() {\n"
202
 
    "  return $name$_;\n"   // note:  unmodifiable list
203
 
    "}\n"
204
 
    "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
205
 
    "public $type$ get$capitalized_name$(int index) {\n"
206
 
    "  return $name$_.get(index);\n"
207
 
    "}\n");
 
533
 
 
534
    "private void ensure$capitalized_name$IsMutable() {\n"
 
535
    "  if (!$get_mutable_bit_builder$) {\n"
 
536
    "    $name$_ = new java.util.ArrayList<$type$>($name$_);\n"
 
537
    "    $set_mutable_bit_builder$;\n"
 
538
    "   }\n"
 
539
    "}\n"
 
540
    "\n");
 
541
 
 
542
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
543
    printer->Print(variables_,
 
544
      // If this builder is non-null, it is used and the other fields are
 
545
      // ignored.
 
546
      "private com.google.protobuf.RepeatedFieldBuilder<\n"
 
547
      "    $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;\n"
 
548
      "\n");
 
549
  }
 
550
 
 
551
  // The comments above the methods below are based on a hypothetical
 
552
  // repeated field of type "Field" called "RepeatedField".
 
553
 
 
554
  // List<Field> getRepeatedFieldList()
 
555
  PrintNestedBuilderFunction(printer,
 
556
    "$deprecation$public java.util.List<$type$> get$capitalized_name$List()",
 
557
 
 
558
    "return java.util.Collections.unmodifiableList($name$_);\n",
 
559
    "return $name$Builder_.getMessageList();\n",
 
560
 
 
561
    NULL);
 
562
 
 
563
  // int getRepeatedFieldCount()
 
564
  PrintNestedBuilderFunction(printer,
 
565
    "$deprecation$public int get$capitalized_name$Count()",
 
566
 
 
567
    "return $name$_.size();\n",
 
568
    "return $name$Builder_.getCount();\n",
 
569
 
 
570
    NULL);
 
571
 
 
572
  // Field getRepeatedField(int index)
 
573
  PrintNestedBuilderFunction(printer,
 
574
    "$deprecation$public $type$ get$capitalized_name$(int index)",
 
575
 
 
576
    "return $name$_.get(index);\n",
 
577
 
 
578
    "return $name$Builder_.getMessage(index);\n",
 
579
 
 
580
    NULL);
 
581
 
 
582
  // Builder setRepeatedField(int index, Field value)
 
583
  PrintNestedBuilderFunction(printer,
 
584
    "$deprecation$public Builder set$capitalized_name$(\n"
 
585
    "    int index, $type$ value)",
 
586
    "if (value == null) {\n"
 
587
    "  throw new NullPointerException();\n"
 
588
    "}\n"
 
589
    "ensure$capitalized_name$IsMutable();\n"
 
590
    "$name$_.set(index, value);\n"
 
591
    "$on_changed$\n",
 
592
    "$name$Builder_.setMessage(index, value);\n",
 
593
    "return this;\n");
 
594
 
 
595
  // Builder setRepeatedField(int index, Field.Builder builderForValue)
 
596
  PrintNestedBuilderFunction(printer,
 
597
    "$deprecation$public Builder set$capitalized_name$(\n"
 
598
    "    int index, $type$.Builder builderForValue)",
 
599
 
 
600
    "ensure$capitalized_name$IsMutable();\n"
 
601
    "$name$_.set(index, builderForValue.build());\n"
 
602
    "$on_changed$\n",
 
603
 
 
604
    "$name$Builder_.setMessage(index, builderForValue.build());\n",
 
605
 
 
606
    "return this;\n");
 
607
 
 
608
  // Builder addRepeatedField(Field value)
 
609
  PrintNestedBuilderFunction(printer,
 
610
    "$deprecation$public Builder add$capitalized_name$($type$ value)",
 
611
 
 
612
    "if (value == null) {\n"
 
613
    "  throw new NullPointerException();\n"
 
614
    "}\n"
 
615
    "ensure$capitalized_name$IsMutable();\n"
 
616
    "$name$_.add(value);\n"
 
617
 
 
618
    "$on_changed$\n",
 
619
 
 
620
    "$name$Builder_.addMessage(value);\n",
 
621
 
 
622
    "return this;\n");
 
623
 
 
624
  // Builder addRepeatedField(int index, Field value)
 
625
  PrintNestedBuilderFunction(printer,
 
626
    "$deprecation$public Builder add$capitalized_name$(\n"
 
627
    "    int index, $type$ value)",
 
628
 
 
629
    "if (value == null) {\n"
 
630
    "  throw new NullPointerException();\n"
 
631
    "}\n"
 
632
    "ensure$capitalized_name$IsMutable();\n"
 
633
    "$name$_.add(index, value);\n"
 
634
    "$on_changed$\n",
 
635
 
 
636
    "$name$Builder_.addMessage(index, value);\n",
 
637
 
 
638
    "return this;\n");
 
639
 
 
640
  // Builder addRepeatedField(Field.Builder builderForValue)
 
641
  PrintNestedBuilderFunction(printer,
 
642
    "$deprecation$public Builder add$capitalized_name$(\n"
 
643
    "    $type$.Builder builderForValue)",
 
644
 
 
645
    "ensure$capitalized_name$IsMutable();\n"
 
646
    "$name$_.add(builderForValue.build());\n"
 
647
    "$on_changed$\n",
 
648
 
 
649
    "$name$Builder_.addMessage(builderForValue.build());\n",
 
650
 
 
651
    "return this;\n");
 
652
 
 
653
  // Builder addRepeatedField(int index, Field.Builder builderForValue)
 
654
  PrintNestedBuilderFunction(printer,
 
655
    "$deprecation$public Builder add$capitalized_name$(\n"
 
656
    "    int index, $type$.Builder builderForValue)",
 
657
 
 
658
    "ensure$capitalized_name$IsMutable();\n"
 
659
    "$name$_.add(index, builderForValue.build());\n"
 
660
    "$on_changed$\n",
 
661
 
 
662
    "$name$Builder_.addMessage(index, builderForValue.build());\n",
 
663
 
 
664
    "return this;\n");
 
665
 
 
666
  // Builder addAllRepeatedField(Iterable<Field> values)
 
667
  PrintNestedBuilderFunction(printer,
 
668
    "$deprecation$public Builder addAll$capitalized_name$(\n"
 
669
    "    java.lang.Iterable<? extends $type$> values)",
 
670
 
 
671
    "ensure$capitalized_name$IsMutable();\n"
 
672
    "super.addAll(values, $name$_);\n"
 
673
    "$on_changed$\n",
 
674
 
 
675
    "$name$Builder_.addAllMessages(values);\n",
 
676
 
 
677
    "return this;\n");
 
678
 
 
679
  // Builder clearAllRepeatedField()
 
680
  PrintNestedBuilderFunction(printer,
 
681
    "$deprecation$public Builder clear$capitalized_name$()",
 
682
 
 
683
    "$name$_ = java.util.Collections.emptyList();\n"
 
684
    "$clear_mutable_bit_builder$;\n"
 
685
    "$on_changed$\n",
 
686
 
 
687
    "$name$Builder_.clear();\n",
 
688
 
 
689
    "return this;\n");
 
690
 
 
691
  // Builder removeRepeatedField(int index)
 
692
  PrintNestedBuilderFunction(printer,
 
693
    "$deprecation$public Builder remove$capitalized_name$(int index)",
 
694
 
 
695
    "ensure$capitalized_name$IsMutable();\n"
 
696
    "$name$_.remove(index);\n"
 
697
    "$on_changed$\n",
 
698
 
 
699
    "$name$Builder_.remove(index);\n",
 
700
 
 
701
    "return this;\n");
 
702
 
 
703
  if (HasNestedBuilders(descriptor_->containing_type())) {
 
704
    printer->Print(variables_,
 
705
      "$deprecation$public $type$.Builder get$capitalized_name$Builder(\n"
 
706
      "    int index) {\n"
 
707
      "  return get$capitalized_name$FieldBuilder().getBuilder(index);\n"
 
708
      "}\n"
 
709
 
 
710
      "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
 
711
      "    int index) {\n"
 
712
      "  if ($name$Builder_ == null) {\n"
 
713
      "    return $name$_.get(index);"
 
714
      "  } else {\n"
 
715
      "    return $name$Builder_.getMessageOrBuilder(index);\n"
 
716
      "  }\n"
 
717
      "}\n"
 
718
 
 
719
      "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
 
720
      "     get$capitalized_name$OrBuilderList() {\n"
 
721
      "  if ($name$Builder_ != null) {\n"
 
722
      "    return $name$Builder_.getMessageOrBuilderList();\n"
 
723
      "  } else {\n"
 
724
      "    return java.util.Collections.unmodifiableList($name$_);\n"
 
725
      "  }\n"
 
726
      "}\n"
 
727
 
 
728
      "$deprecation$public $type$.Builder add$capitalized_name$Builder() {\n"
 
729
      "  return get$capitalized_name$FieldBuilder().addBuilder(\n"
 
730
      "      $type$.getDefaultInstance());\n"
 
731
      "}\n"
 
732
      "$deprecation$public $type$.Builder add$capitalized_name$Builder(\n"
 
733
      "    int index) {\n"
 
734
      "  return get$capitalized_name$FieldBuilder().addBuilder(\n"
 
735
      "      index, $type$.getDefaultInstance());\n"
 
736
      "}\n"
 
737
      "$deprecation$public java.util.List<$type$.Builder> \n"
 
738
      "     get$capitalized_name$BuilderList() {\n"
 
739
      "  return get$capitalized_name$FieldBuilder().getBuilderList();\n"
 
740
      "}\n"
 
741
      "private com.google.protobuf.RepeatedFieldBuilder<\n"
 
742
      "    $type$, $type$.Builder, $type$OrBuilder> \n"
 
743
      "    get$capitalized_name$FieldBuilder() {\n"
 
744
      "  if ($name$Builder_ == null) {\n"
 
745
      "    $name$Builder_ = new com.google.protobuf.RepeatedFieldBuilder<\n"
 
746
      "        $type$, $type$.Builder, $type$OrBuilder>(\n"
 
747
      "            $name$_,\n"
 
748
      "            $get_mutable_bit_builder$,\n"
 
749
      "            getParentForChildren(),\n"
 
750
      "            isClean());\n"
 
751
      "    $name$_ = null;\n"
 
752
      "  }\n"
 
753
      "  return $name$Builder_;\n"
 
754
      "}\n");
 
755
  }
208
756
}
209
757
 
210
758
void RepeatedMessageFieldGenerator::
211
 
GenerateBuilderMembers(io::Printer* printer) const {
 
759
GenerateFieldBuilderInitializationCode(io::Printer* printer)  const {
212
760
  printer->Print(variables_,
213
 
    // Note:  We return an unmodifiable list because otherwise the caller
214
 
    //   could hold on to the returned list and modify it after the message
215
 
    //   has been built, thus mutating the message which is supposed to be
216
 
    //   immutable.
217
 
    "public java.util.List<$type$> get$capitalized_name$List() {\n"
218
 
    "  return java.util.Collections.unmodifiableList(result.$name$_);\n"
219
 
    "}\n"
220
 
    "public int get$capitalized_name$Count() {\n"
221
 
    "  return result.get$capitalized_name$Count();\n"
222
 
    "}\n"
223
 
    "public $type$ get$capitalized_name$(int index) {\n"
224
 
    "  return result.get$capitalized_name$(index);\n"
225
 
    "}\n"
226
 
    "public Builder set$capitalized_name$(int index, $type$ value) {\n"
227
 
    "  if (value == null) {\n"
228
 
    "    throw new NullPointerException();\n"
229
 
    "  }\n"
230
 
    "  result.$name$_.set(index, value);\n"
231
 
    "  return this;\n"
232
 
    "}\n"
233
 
    "public Builder set$capitalized_name$(int index, "
234
 
      "$type$.Builder builderForValue) {\n"
235
 
    "  result.$name$_.set(index, builderForValue.build());\n"
236
 
    "  return this;\n"
237
 
    "}\n"
238
 
    "public Builder add$capitalized_name$($type$ value) {\n"
239
 
    "  if (value == null) {\n"
240
 
    "    throw new NullPointerException();\n"
241
 
    "  }\n"
242
 
    "  if (result.$name$_.isEmpty()) {\n"
243
 
    "    result.$name$_ = new java.util.ArrayList<$type$>();\n"
244
 
    "  }\n"
245
 
    "  result.$name$_.add(value);\n"
246
 
    "  return this;\n"
247
 
    "}\n"
248
 
    "public Builder add$capitalized_name$($type$.Builder builderForValue) {\n"
249
 
    "  if (result.$name$_.isEmpty()) {\n"
250
 
    "    result.$name$_ = new java.util.ArrayList<$type$>();\n"
251
 
    "  }\n"
252
 
    "  result.$name$_.add(builderForValue.build());\n"
253
 
    "  return this;\n"
254
 
    "}\n"
255
 
    "public Builder addAll$capitalized_name$(\n"
256
 
    "    java.lang.Iterable<? extends $type$> values) {\n"
257
 
    "  if (result.$name$_.isEmpty()) {\n"
258
 
    "    result.$name$_ = new java.util.ArrayList<$type$>();\n"
259
 
    "  }\n"
260
 
    "  super.addAll(values, result.$name$_);\n"
261
 
    "  return this;\n"
262
 
    "}\n"
263
 
    "public Builder clear$capitalized_name$() {\n"
264
 
    "  result.$name$_ = java.util.Collections.emptyList();\n"
265
 
    "  return this;\n"
266
 
    "}\n");
 
761
    "get$capitalized_name$FieldBuilder();\n");
267
762
}
268
763
 
269
764
void RepeatedMessageFieldGenerator::
270
765
GenerateInitializationCode(io::Printer* printer) const {
271
 
  // Initialized inline.
 
766
  printer->Print(variables_, "$name$_ = java.util.Collections.emptyList();\n");
 
767
}
 
768
 
 
769
void RepeatedMessageFieldGenerator::
 
770
GenerateBuilderClearCode(io::Printer* printer) const {
 
771
  PrintNestedBuilderCondition(printer,
 
772
    "$name$_ = java.util.Collections.emptyList();\n"
 
773
    "$clear_mutable_bit_builder$;\n",
 
774
 
 
775
    "$name$Builder_.clear();\n");
272
776
}
273
777
 
274
778
void RepeatedMessageFieldGenerator::
275
779
GenerateMergingCode(io::Printer* printer) const {
276
 
  printer->Print(variables_,
277
 
    "if (!other.$name$_.isEmpty()) {\n"
278
 
    "  if (result.$name$_.isEmpty()) {\n"
279
 
    "    result.$name$_ = new java.util.ArrayList<$type$>();\n"
280
 
    "  }\n"
281
 
    "  result.$name$_.addAll(other.$name$_);\n"
 
780
  // The code below does two optimizations (non-nested builder case):
 
781
  //   1. If the other list is empty, there's nothing to do. This ensures we
 
782
  //      don't allocate a new array if we already have an immutable one.
 
783
  //   2. If the other list is non-empty and our current list is empty, we can
 
784
  //      reuse the other list which is guaranteed to be immutable.
 
785
  PrintNestedBuilderCondition(printer,
 
786
    "if (!other.$name$_.isEmpty()) {\n"
 
787
    "  if ($name$_.isEmpty()) {\n"
 
788
    "    $name$_ = other.$name$_;\n"
 
789
    "    $clear_mutable_bit_builder$;\n"
 
790
    "  } else {\n"
 
791
    "    ensure$capitalized_name$IsMutable();\n"
 
792
    "    $name$_.addAll(other.$name$_);\n"
 
793
    "  }\n"
 
794
    "  $on_changed$\n"
 
795
    "}\n",
 
796
 
 
797
    "if (!other.$name$_.isEmpty()) {\n"
 
798
    "  if ($name$Builder_.isEmpty()) {\n"
 
799
    "    $name$Builder_.dispose();\n"
 
800
    "    $name$Builder_ = null;\n"
 
801
    "    $name$_ = other.$name$_;\n"
 
802
    "    $clear_mutable_bit_builder$;\n"
 
803
    "    $name$Builder_ = \n"
 
804
    "      com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?\n"
 
805
    "         get$capitalized_name$FieldBuilder() : null;\n"
 
806
    "  } else {\n"
 
807
    "    $name$Builder_.addAllMessages(other.$name$_);\n"
 
808
    "  }\n"
282
809
    "}\n");
283
810
}
284
811
 
285
812
void RepeatedMessageFieldGenerator::
286
813
GenerateBuildingCode(io::Printer* printer) const {
287
 
  printer->Print(variables_,
288
 
    "if (result.$name$_ != java.util.Collections.EMPTY_LIST) {\n"
289
 
    "  result.$name$_ =\n"
290
 
    "    java.util.Collections.unmodifiableList(result.$name$_);\n"
291
 
    "}\n");
 
814
  // The code below (non-nested builder case) ensures that the result has an
 
815
  // immutable list. If our list is immutable, we can just reuse it. If not,
 
816
  // we make it immutable.
 
817
  PrintNestedBuilderCondition(printer,
 
818
    "if ($get_mutable_bit_builder$) {\n"
 
819
    "  $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
 
820
    "  $clear_mutable_bit_builder$;\n"
 
821
    "}\n"
 
822
    "result.$name$_ = $name$_;\n",
 
823
 
 
824
    "result.$name$_ = $name$Builder_.build();\n");
292
825
}
293
826
 
294
827
void RepeatedMessageFieldGenerator::
311
844
void RepeatedMessageFieldGenerator::
312
845
GenerateSerializationCode(io::Printer* printer) const {
313
846
  printer->Print(variables_,
314
 
    "for ($type$ element : get$capitalized_name$List()) {\n"
315
 
    "  output.write$group_or_message$($number$, element);\n"
 
847
    "for (int i = 0; i < $name$_.size(); i++) {\n"
 
848
    "  output.write$group_or_message$($number$, $name$_.get(i));\n"
316
849
    "}\n");
317
850
}
318
851
 
319
852
void RepeatedMessageFieldGenerator::
320
853
GenerateSerializedSizeCode(io::Printer* printer) const {
321
854
  printer->Print(variables_,
322
 
    "for ($type$ element : get$capitalized_name$List()) {\n"
 
855
    "for (int i = 0; i < $name$_.size(); i++) {\n"
323
856
    "  size += com.google.protobuf.CodedOutputStream\n"
324
 
    "    .compute$group_or_message$Size($number$, element);\n"
 
857
    "    .compute$group_or_message$Size($number$, $name$_.get(i));\n"
 
858
    "}\n");
 
859
}
 
860
 
 
861
void RepeatedMessageFieldGenerator::
 
862
GenerateEqualsCode(io::Printer* printer) const {
 
863
  printer->Print(variables_,
 
864
    "result = result && get$capitalized_name$List()\n"
 
865
    "    .equals(other.get$capitalized_name$List());\n");
 
866
}
 
867
 
 
868
void RepeatedMessageFieldGenerator::
 
869
GenerateHashCode(io::Printer* printer) const {
 
870
  printer->Print(variables_,
 
871
    "if (get$capitalized_name$Count() > 0) {\n"
 
872
    "  hash = (37 * hash) + $constant_name$;\n"
 
873
    "  hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
325
874
    "}\n");
326
875
}
327
876