1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3// https://developers.google.com/protocol-buffers/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9//     * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11//     * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15//     * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31// Author: niwasaki@google.com (Naoki Iwasaki)
32//  Based on original Protocol Buffers design by
33//  Sanjay Ghemawat, Jeff Dean, and others.
34
35#include <google/protobuf/compiler/java/java_context.h>
36#include <google/protobuf/compiler/java/java_lazy_message_field.h>
37#include <google/protobuf/compiler/java/java_doc_comment.h>
38#include <google/protobuf/compiler/java/java_helpers.h>
39#include <google/protobuf/io/printer.h>
40
41namespace google {
42namespace protobuf {
43namespace compiler {
44namespace java {
45
46ImmutableLazyMessageFieldGenerator::
47ImmutableLazyMessageFieldGenerator(
48    const FieldDescriptor* descriptor,
49    int messageBitIndex,
50    int builderBitIndex,
51    Context* context)
52    : ImmutableMessageFieldGenerator(
53          descriptor, messageBitIndex, builderBitIndex, context) {
54}
55
56ImmutableLazyMessageFieldGenerator::~ImmutableLazyMessageFieldGenerator() {}
57
58void ImmutableLazyMessageFieldGenerator::
59GenerateMembers(io::Printer* printer) const {
60  printer->Print(variables_,
61    "private com.google.protobuf.LazyFieldLite $name$_ =\n"
62    "    new com.google.protobuf.LazyFieldLite();\n");
63
64  PrintExtraFieldInfo(variables_, printer);
65  WriteFieldDocComment(printer, descriptor_);
66  printer->Print(variables_,
67    "$deprecation$public boolean has$capitalized_name$() {\n"
68    "  return $get_has_field_bit_message$;\n"
69    "}\n");
70  WriteFieldDocComment(printer, descriptor_);
71
72  printer->Print(variables_,
73    "$deprecation$public $type$ get$capitalized_name$() {\n"
74    "  return ($type$) $name$_.getValue($type$.getDefaultInstance());\n"
75   "}\n");
76  if (HasNestedBuilders(descriptor_->containing_type())) {
77    WriteFieldDocComment(printer, descriptor_);
78    printer->Print(variables_,
79      "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
80      "  return $name$_;\n"
81      "}\n");
82  }
83}
84
85void ImmutableLazyMessageFieldGenerator::
86GenerateBuilderMembers(io::Printer* printer) const {
87  // When using nested-builders, the code initially works just like the
88  // non-nested builder case. It only creates a nested builder lazily on
89  // demand and then forever delegates to it after creation.
90
91  printer->Print(variables_,
92    "private com.google.protobuf.LazyFieldLite $name$_ =\n"
93    "    new com.google.protobuf.LazyFieldLite();\n");
94
95  if (HasNestedBuilders(descriptor_->containing_type())) {
96    printer->Print(variables_,
97      // If this builder is non-null, it is used and the other fields are
98      // ignored.
99      "private com.google.protobuf.SingleFieldBuilder<\n"
100      "    $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
101      "\n");
102  }
103
104  // The comments above the methods below are based on a hypothetical
105  // field of type "Field" called "Field".
106
107  // boolean hasField()
108  WriteFieldDocComment(printer, descriptor_);
109  printer->Print(variables_,
110    "$deprecation$public boolean has$capitalized_name$() {\n"
111    "  return $get_has_field_bit_builder$;\n"
112    "}\n");
113
114    printer->Print(variables_,
115      "$deprecation$public $type$ get$capitalized_name$() {\n"
116      "  return ($type$) $name$_.getValue($type$.getDefaultInstance());\n"
117      "}\n");
118
119  // Field.Builder setField(Field value)
120  WriteFieldDocComment(printer, descriptor_);
121  PrintNestedBuilderFunction(printer,
122    "$deprecation$public Builder set$capitalized_name$($type$ value)",
123
124    "if (value == null) {\n"
125    "  throw new NullPointerException();\n"
126    "}\n"
127    "$name$_.setValue(value);\n"
128    "$on_changed$\n",
129
130     NULL,  // Lazy fields are supported only for lite-runtime.
131
132    "$set_has_field_bit_builder$;\n"
133    "return this;\n");
134
135  // Field.Builder setField(Field.Builder builderForValue)
136  WriteFieldDocComment(printer, descriptor_);
137  PrintNestedBuilderFunction(printer,
138    "$deprecation$public Builder set$capitalized_name$(\n"
139    "    $type$.Builder builderForValue)",
140
141    "$name$_.setValue(builderForValue.build());\n"
142    "$on_changed$\n",
143
144    NULL,
145
146    "$set_has_field_bit_builder$;\n"
147    "return this;\n");
148
149  // Field.Builder mergeField(Field value)
150  WriteFieldDocComment(printer, descriptor_);
151  PrintNestedBuilderFunction(printer,
152    "$deprecation$public Builder merge$capitalized_name$($type$ value)",
153
154    "if ($get_has_field_bit_builder$ &&\n"
155    "    !$name$_.containsDefaultInstance()) {\n"
156    "  $name$_.setValue(\n"
157    "    $type$.newBuilder(\n"
158    "        get$capitalized_name$()).mergeFrom(value).buildPartial());\n"
159    "} else {\n"
160    "  $name$_.setValue(value);\n"
161    "}\n"
162    "$on_changed$\n",
163
164    NULL,
165
166    "$set_has_field_bit_builder$;\n"
167    "return this;\n");
168
169  // Field.Builder clearField()
170  WriteFieldDocComment(printer, descriptor_);
171  PrintNestedBuilderFunction(printer,
172    "$deprecation$public Builder clear$capitalized_name$()",
173
174    "$name$_.clear();\n"
175    "$on_changed$\n",
176
177    NULL,
178
179    "$clear_has_field_bit_builder$;\n"
180    "return this;\n");
181
182  if (HasNestedBuilders(descriptor_->containing_type())) {
183    WriteFieldDocComment(printer, descriptor_);
184    printer->Print(variables_,
185      "$deprecation$public $type$.Builder get$capitalized_name$Builder() {\n"
186      "  $set_has_field_bit_builder$;\n"
187      "  $on_changed$\n"
188      "  return get$capitalized_name$FieldBuilder().getBuilder();\n"
189      "}\n");
190    WriteFieldDocComment(printer, descriptor_);
191    printer->Print(variables_,
192      "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
193      "  if ($name$Builder_ != null) {\n"
194      "    return $name$Builder_.getMessageOrBuilder();\n"
195      "  } else {\n"
196      "    return $name$_;\n"
197      "  }\n"
198      "}\n");
199    WriteFieldDocComment(printer, descriptor_);
200    printer->Print(variables_,
201      "private com.google.protobuf.SingleFieldBuilder<\n"
202      "    $type$, $type$.Builder, $type$OrBuilder> \n"
203      "    get$capitalized_name$FieldBuilder() {\n"
204      "  if ($name$Builder_ == null) {\n"
205      "    $name$Builder_ = new com.google.protobuf.SingleFieldBuilder<\n"
206      "        $type$, $type$.Builder, $type$OrBuilder>(\n"
207      "            $name$_,\n"
208      "            getParentForChildren(),\n"
209      "            isClean());\n"
210      "    $name$_ = null;\n"
211      "  }\n"
212      "  return $name$Builder_;\n"
213      "}\n");
214  }
215}
216
217
218void ImmutableLazyMessageFieldGenerator::
219GenerateInitializationCode(io::Printer* printer) const {
220  printer->Print(variables_, "$name$_.clear();\n");
221}
222
223void ImmutableLazyMessageFieldGenerator::
224GenerateBuilderClearCode(io::Printer* printer) const {
225  printer->Print(variables_, "$name$_.clear();\n");
226  printer->Print(variables_, "$clear_has_field_bit_builder$;\n");
227}
228
229void ImmutableLazyMessageFieldGenerator::
230GenerateMergingCode(io::Printer* printer) const {
231  printer->Print(variables_,
232    "if (other.has$capitalized_name$()) {\n"
233    "  $name$_.merge(other.$name$_);\n"
234    "  $set_has_field_bit_builder$;\n"
235    "}\n");
236}
237
238void ImmutableLazyMessageFieldGenerator::
239GenerateBuildingCode(io::Printer* printer) const {
240  printer->Print(variables_,
241      "if ($get_has_field_bit_from_local$) {\n"
242      "  $set_has_field_bit_to_local$;\n"
243      "}\n");
244
245  printer->Print(variables_,
246      "result.$name$_.setByteString(\n"
247      "    $name$_.toByteString(),\n"
248      "    $name$_.getExtensionRegistry());\n");
249}
250
251void ImmutableLazyMessageFieldGenerator::
252GenerateParsingCode(io::Printer* printer) const {
253  printer->Print(variables_,
254    "$name$_.setByteString(input.readBytes(), extensionRegistry);\n");
255  printer->Print(variables_,
256    "$set_has_field_bit_message$;\n");
257}
258
259void ImmutableLazyMessageFieldGenerator::
260GenerateSerializationCode(io::Printer* printer) const {
261  // Do not de-serialize lazy fields.
262  printer->Print(variables_,
263    "if ($get_has_field_bit_message$) {\n"
264    "  output.writeBytes($number$, $name$_.toByteString());\n"
265    "}\n");
266}
267
268void ImmutableLazyMessageFieldGenerator::
269GenerateSerializedSizeCode(io::Printer* printer) const {
270  printer->Print(variables_,
271    "if ($get_has_field_bit_message$) {\n"
272    "  size += com.google.protobuf.CodedOutputStream\n"
273    "    .computeLazyFieldSize($number$, $name$_);\n"
274    "}\n");
275}
276
277// ===================================================================
278
279ImmutableLazyMessageOneofFieldGenerator::
280ImmutableLazyMessageOneofFieldGenerator(const FieldDescriptor* descriptor,
281                                        int messageBitIndex,
282                                        int builderBitIndex,
283                                        Context* context)
284    : ImmutableLazyMessageFieldGenerator(
285          descriptor, messageBitIndex, builderBitIndex, context) {
286  const OneofGeneratorInfo* info =
287      context->GetOneofGeneratorInfo(descriptor->containing_oneof());
288  SetCommonOneofVariables(descriptor, info, &variables_);
289  variables_["lazy_type"] = "com.google.protobuf.LazyFieldLite";
290}
291
292ImmutableLazyMessageOneofFieldGenerator::
293~ImmutableLazyMessageOneofFieldGenerator() {}
294
295void ImmutableLazyMessageOneofFieldGenerator::
296GenerateMembers(io::Printer* printer) const {
297  PrintExtraFieldInfo(variables_, printer);
298  WriteFieldDocComment(printer, descriptor_);
299
300  printer->Print(variables_,
301    "$deprecation$public boolean has$capitalized_name$() {\n"
302    "  return $has_oneof_case_message$;\n"
303    "}\n");
304  WriteFieldDocComment(printer, descriptor_);
305
306  printer->Print(variables_,
307    "$deprecation$public $type$ get$capitalized_name$() {\n"
308    "  if ($has_oneof_case_message$) {\n"
309    "    return ($type$) (($lazy_type$) $oneof_name$_).getValue(\n"
310    "        $type$.getDefaultInstance());\n"
311    "  }\n"
312    "  return $type$.getDefaultInstance();\n"
313    "}\n");
314}
315
316void ImmutableLazyMessageOneofFieldGenerator::
317GenerateBuilderMembers(io::Printer* printer) const {
318  // boolean hasField()
319  WriteFieldDocComment(printer, descriptor_);
320  printer->Print(variables_,
321    "$deprecation$public boolean has$capitalized_name$() {\n"
322    "  return $has_oneof_case_message$;\n"
323    "}\n");
324
325  printer->Print(variables_,
326    "$deprecation$public $type$ get$capitalized_name$() {\n"
327    "  if ($has_oneof_case_message$) {\n"
328    "    return ($type$) (($lazy_type$) $oneof_name$_).getValue(\n"
329    "        $type$.getDefaultInstance());\n"
330    "  }\n"
331    "  return $type$.getDefaultInstance();\n"
332    "}\n");
333
334  // Field.Builder setField(Field value)
335  WriteFieldDocComment(printer, descriptor_);
336  PrintNestedBuilderFunction(printer,
337    "$deprecation$public Builder set$capitalized_name$($type$ value)",
338
339    "if (value == null) {\n"
340    "  throw new NullPointerException();\n"
341    "}\n"
342    "if (!($has_oneof_case_message$)) {\n"
343    "  $oneof_name$_ = new $lazy_type$();\n"
344    "  $set_oneof_case_message$;\n"
345    "}\n"
346    "(($lazy_type$) $oneof_name$_).setValue(value);\n"
347    "$on_changed$\n",
348
349     NULL,  // Lazy fields are supported only for lite-runtime.
350
351    "return this;\n");
352
353  // Field.Builder setField(Field.Builder builderForValue)
354  WriteFieldDocComment(printer, descriptor_);
355  PrintNestedBuilderFunction(printer,
356    "$deprecation$public Builder set$capitalized_name$(\n"
357    "    $type$.Builder builderForValue)",
358
359    "if (!($has_oneof_case_message$)) {\n"
360    "  $oneof_name$_ = new $lazy_type$();\n"
361    "  $set_oneof_case_message$;\n"
362    "}\n"
363    "(($lazy_type$) $oneof_name$_).setValue(builderForValue.build());\n"
364    "$on_changed$\n",
365
366    NULL,
367
368    "return this;\n");
369
370  // Field.Builder mergeField(Field value)
371  WriteFieldDocComment(printer, descriptor_);
372  PrintNestedBuilderFunction(printer,
373    "$deprecation$public Builder merge$capitalized_name$($type$ value)",
374
375    "if ($has_oneof_case_message$ &&\n"
376    "    !(($lazy_type$) $oneof_name$_).containsDefaultInstance()) {\n"
377    "  (($lazy_type$) $oneof_name$_).setValue(\n"
378    "    $type$.newBuilder(\n"
379    "        get$capitalized_name$()).mergeFrom(value).buildPartial());\n"
380    "} else {\n"
381    "  if (!($has_oneof_case_message$)) {\n"
382    "    $oneof_name$_ = new $lazy_type$();\n"
383    "    $set_oneof_case_message$;\n"
384    "  }\n"
385    "  (($lazy_type$) $oneof_name$_).setValue(value);\n"
386    "}\n"
387    "$on_changed$\n",
388
389    NULL,
390
391    "return this;\n");
392
393  // Field.Builder clearField()
394  WriteFieldDocComment(printer, descriptor_);
395  PrintNestedBuilderFunction(printer,
396    "$deprecation$public Builder clear$capitalized_name$()",
397
398    "if ($has_oneof_case_message$) {\n"
399    "  $clear_oneof_case_message$;\n"
400    "  $oneof_name$_ = null;\n"
401    "  $on_changed$\n"
402    "}\n",
403
404    NULL,
405
406    "return this;\n");
407}
408
409void ImmutableLazyMessageOneofFieldGenerator::
410GenerateMergingCode(io::Printer* printer) const {
411  printer->Print(variables_,
412    "if (!($has_oneof_case_message$)) {\n"
413    "  $oneof_name$_ = new $lazy_type$();\n"
414    "}\n"
415    "(($lazy_type$) $oneof_name$_).merge(\n"
416    "    ($lazy_type$) other.$oneof_name$_);\n"
417    "$set_oneof_case_message$;\n");
418}
419
420void ImmutableLazyMessageOneofFieldGenerator::
421GenerateBuildingCode(io::Printer* printer) const {
422  printer->Print(variables_,
423                 "if ($has_oneof_case_message$) {\n");
424  printer->Indent();
425
426  printer->Print(variables_,
427      "result.$oneof_name$_ = new $lazy_type$();\n"
428      "(($lazy_type$) result.$oneof_name$_).setByteString(\n"
429      "    (($lazy_type$) $oneof_name$_).toByteString(),\n"
430      "    (($lazy_type$) $oneof_name$_).getExtensionRegistry());\n");
431  printer->Outdent();
432  printer->Print("}\n");
433}
434
435void ImmutableLazyMessageOneofFieldGenerator::
436GenerateParsingCode(io::Printer* printer) const {
437  printer->Print(variables_,
438    "if (!($has_oneof_case_message$)) {\n"
439    "  $oneof_name$_ = new $lazy_type$();\n"
440    "}\n"
441    "(($lazy_type$) $oneof_name$_).setByteString(\n"
442    "    input.readBytes(), extensionRegistry);\n"
443    "$set_oneof_case_message$;\n");
444}
445
446void ImmutableLazyMessageOneofFieldGenerator::
447GenerateSerializationCode(io::Printer* printer) const {
448  // Do not de-serialize lazy fields.
449  printer->Print(variables_,
450    "if ($has_oneof_case_message$) {\n"
451    "  output.writeBytes(\n"
452    "      $number$, (($lazy_type$) $oneof_name$_).toByteString());\n"
453    "}\n");
454}
455
456void ImmutableLazyMessageOneofFieldGenerator::
457GenerateSerializedSizeCode(io::Printer* printer) const {
458  printer->Print(variables_,
459    "if ($has_oneof_case_message$) {\n"
460    "  size += com.google.protobuf.CodedOutputStream\n"
461    "    .computeLazyFieldSize($number$, ($lazy_type$) $oneof_name$_);\n"
462    "}\n");
463}
464
465// ===================================================================
466
467RepeatedImmutableLazyMessageFieldGenerator::
468RepeatedImmutableLazyMessageFieldGenerator(
469    const FieldDescriptor* descriptor,
470    int messageBitIndex,
471    int builderBitIndex,
472    Context* context)
473    : RepeatedImmutableMessageFieldGenerator(
474          descriptor, messageBitIndex, builderBitIndex, context) {
475}
476
477
478RepeatedImmutableLazyMessageFieldGenerator::
479~RepeatedImmutableLazyMessageFieldGenerator() {}
480
481void RepeatedImmutableLazyMessageFieldGenerator::
482GenerateMembers(io::Printer* printer) const {
483  printer->Print(variables_,
484    "private java.util.List<com.google.protobuf.LazyFieldLite> $name$_;\n");
485  PrintExtraFieldInfo(variables_, printer);
486  WriteFieldDocComment(printer, descriptor_);
487  printer->Print(variables_,
488    "$deprecation$public java.util.List<$type$>\n"
489    "    get$capitalized_name$List() {\n"
490    "  java.util.List<$type$> list =\n"
491    "      new java.util.ArrayList<$type$>($name$_.size());\n"
492    "  for (com.google.protobuf.LazyFieldLite lf : $name$_) {\n"
493    "    list.add(($type$) lf.getValue($type$.getDefaultInstance()));\n"
494    "  }\n"
495    "  return list;\n"
496    "}\n");
497  WriteFieldDocComment(printer, descriptor_);
498  printer->Print(variables_,
499    "$deprecation$public java.util.List<? extends $type$OrBuilder>\n"
500    "    get$capitalized_name$OrBuilderList() {\n"
501    "  return get$capitalized_name$List();\n"
502    "}\n");
503  WriteFieldDocComment(printer, descriptor_);
504  printer->Print(variables_,
505    "$deprecation$public int get$capitalized_name$Count() {\n"
506    "  return $name$_.size();\n"
507    "}\n");
508  WriteFieldDocComment(printer, descriptor_);
509  printer->Print(variables_,
510    "$deprecation$public $type$ get$capitalized_name$(int index) {\n"
511    "  return ($type$)\n"
512    "      $name$_.get(index).getValue($type$.getDefaultInstance());\n"
513    "}\n");
514  WriteFieldDocComment(printer, descriptor_);
515  printer->Print(variables_,
516    "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
517    "    int index) {\n"
518    "  return ($type$OrBuilder)\n"
519    "      $name$_.get(index).getValue($type$.getDefaultInstance());\n"
520    "}\n");
521}
522
523void RepeatedImmutableLazyMessageFieldGenerator::
524GenerateBuilderMembers(io::Printer* printer) const {
525  // When using nested-builders, the code initially works just like the
526  // non-nested builder case. It only creates a nested builder lazily on
527  // demand and then forever delegates to it after creation.
528
529  printer->Print(variables_,
530    "private java.util.List<com.google.protobuf.LazyFieldLite> $name$_ =\n"
531    "  java.util.Collections.emptyList();\n"
532
533    "private void ensure$capitalized_name$IsMutable() {\n"
534    "  if (!$get_mutable_bit_builder$) {\n"
535    "    $name$_ =\n"
536    "        new java.util.ArrayList<com.google.protobuf.LazyFieldLite>(\n"
537    "            $name$_);\n"
538    "    $set_mutable_bit_builder$;\n"
539    "   }\n"
540    "}\n"
541    "\n");
542
543  if (HasNestedBuilders(descriptor_->containing_type())) {
544    printer->Print(variables_,
545      // If this builder is non-null, it is used and the other fields are
546      // ignored.
547      "private com.google.protobuf.RepeatedFieldBuilder<\n"
548      "    $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;\n"
549      "\n");
550  }
551
552  // The comments above the methods below are based on a hypothetical
553  // repeated field of type "Field" called "RepeatedField".
554
555  // List<Field> getRepeatedFieldList()
556  WriteFieldDocComment(printer, descriptor_);
557  PrintNestedBuilderFunction(printer,
558    "$deprecation$public java.util.List<$type$> get$capitalized_name$List()",
559
560    "java.util.List<$type$> list =\n"
561    "    new java.util.ArrayList<$type$>($name$_.size());\n"
562    "for (com.google.protobuf.LazyFieldLite lf : $name$_) {\n"
563    "  list.add(($type$) lf.getValue($type$.getDefaultInstance()));\n"
564    "}\n"
565    "return java.util.Collections.unmodifiableList(list);\n",
566
567    "return $name$Builder_.getMessageList();\n",
568
569    NULL);
570
571  // int getRepeatedFieldCount()
572  WriteFieldDocComment(printer, descriptor_);
573  PrintNestedBuilderFunction(printer,
574    "$deprecation$public int get$capitalized_name$Count()",
575
576    "return $name$_.size();\n",
577    "return $name$Builder_.getCount();\n",
578
579    NULL);
580
581  // Field getRepeatedField(int index)
582  WriteFieldDocComment(printer, descriptor_);
583  PrintNestedBuilderFunction(printer,
584    "$deprecation$public $type$ get$capitalized_name$(int index)",
585
586    "return ($type$) $name$_.get(index).getValue(\n"
587    "    $type$.getDefaultInstance());\n",
588
589    "return $name$Builder_.getMessage(index);\n",
590
591    NULL);
592
593  // Builder setRepeatedField(int index, Field value)
594  WriteFieldDocComment(printer, descriptor_);
595  PrintNestedBuilderFunction(printer,
596    "$deprecation$public Builder set$capitalized_name$(\n"
597    "    int index, $type$ value)",
598    "if (value == null) {\n"
599    "  throw new NullPointerException();\n"
600    "}\n"
601    "ensure$capitalized_name$IsMutable();\n"
602    "$name$_.set(index, com.google.protobuf.LazyFieldLite.fromValue(value));\n"
603    "$on_changed$\n",
604    "$name$Builder_.setMessage(index, value);\n",
605    "return this;\n");
606
607  // Builder setRepeatedField(int index, Field.Builder builderForValue)
608  WriteFieldDocComment(printer, descriptor_);
609  PrintNestedBuilderFunction(printer,
610    "$deprecation$public Builder set$capitalized_name$(\n"
611    "    int index, $type$.Builder builderForValue)",
612
613    "ensure$capitalized_name$IsMutable();\n"
614    "$name$_.set(index, com.google.protobuf.LazyFieldLite.fromValue(\n"
615    "    builderForValue.build()));\n"
616    "$on_changed$\n",
617
618    "$name$Builder_.setMessage(index, builderForValue.build());\n",
619
620    "return this;\n");
621
622  // Builder addRepeatedField(Field value)
623  WriteFieldDocComment(printer, descriptor_);
624  PrintNestedBuilderFunction(printer,
625    "$deprecation$public Builder add$capitalized_name$($type$ value)",
626
627    "if (value == null) {\n"
628    "  throw new NullPointerException();\n"
629    "}\n"
630    "ensure$capitalized_name$IsMutable();\n"
631    "$name$_.add(com.google.protobuf.LazyFieldLite.fromValue(value));\n"
632
633    "$on_changed$\n",
634
635    "$name$Builder_.addMessage(value);\n",
636
637    "return this;\n");
638
639  // Builder addRepeatedField(int index, Field value)
640  WriteFieldDocComment(printer, descriptor_);
641  PrintNestedBuilderFunction(printer,
642    "$deprecation$public Builder add$capitalized_name$(\n"
643    "    int index, $type$ value)",
644
645    "if (value == null) {\n"
646    "  throw new NullPointerException();\n"
647    "}\n"
648    "ensure$capitalized_name$IsMutable();\n"
649    "$name$_.add(index, com.google.protobuf.LazyFieldLite.fromValue(value));\n"
650    "$on_changed$\n",
651
652    "$name$Builder_.addMessage(index, value);\n",
653
654    "return this;\n");
655
656  // Builder addRepeatedField(Field.Builder builderForValue)
657  WriteFieldDocComment(printer, descriptor_);
658  PrintNestedBuilderFunction(printer,
659    "$deprecation$public Builder add$capitalized_name$(\n"
660    "    $type$.Builder builderForValue)",
661
662    "ensure$capitalized_name$IsMutable();\n"
663    "$name$_.add(com.google.protobuf.LazyFieldLite.fromValue(\n"
664    "    builderForValue.build()));\n"
665    "$on_changed$\n",
666
667    "$name$Builder_.addMessage(builderForValue.build());\n",
668
669    "return this;\n");
670
671  // Builder addRepeatedField(int index, Field.Builder builderForValue)
672  WriteFieldDocComment(printer, descriptor_);
673  PrintNestedBuilderFunction(printer,
674    "$deprecation$public Builder add$capitalized_name$(\n"
675    "    int index, $type$.Builder builderForValue)",
676
677    "ensure$capitalized_name$IsMutable();\n"
678    "$name$_.add(index, com.google.protobuf.LazyFieldLite.fromValue(\n"
679    "    builderForValue.build()));\n"
680    "$on_changed$\n",
681
682    "$name$Builder_.addMessage(index, builderForValue.build());\n",
683
684    "return this;\n");
685
686  // Builder addAllRepeatedField(Iterable<Field> values)
687  WriteFieldDocComment(printer, descriptor_);
688  PrintNestedBuilderFunction(printer,
689    "$deprecation$public Builder addAll$capitalized_name$(\n"
690    "    java.lang.Iterable<? extends $type$> values)",
691
692    "ensure$capitalized_name$IsMutable();\n"
693    "for (com.google.protobuf.MessageLite v : values) {\n"
694    "  $name$_.add(com.google.protobuf.LazyFieldLite.fromValue(v));\n"
695    "}\n"
696    "$on_changed$\n",
697
698    "$name$Builder_.addAllMessages(values);\n",
699
700    "return this;\n");
701
702  // Builder clearAllRepeatedField()
703  WriteFieldDocComment(printer, descriptor_);
704  PrintNestedBuilderFunction(printer,
705    "$deprecation$public Builder clear$capitalized_name$()",
706
707    "$name$_ = java.util.Collections.emptyList();\n"
708    "$clear_mutable_bit_builder$;\n"
709    "$on_changed$\n",
710
711    "$name$Builder_.clear();\n",
712
713    "return this;\n");
714
715  // Builder removeRepeatedField(int index)
716  WriteFieldDocComment(printer, descriptor_);
717  PrintNestedBuilderFunction(printer,
718    "$deprecation$public Builder remove$capitalized_name$(int index)",
719
720    "ensure$capitalized_name$IsMutable();\n"
721    "$name$_.remove(index);\n"
722    "$on_changed$\n",
723
724    "$name$Builder_.remove(index);\n",
725
726    "return this;\n");
727
728  if (HasNestedBuilders(descriptor_->containing_type())) {
729    WriteFieldDocComment(printer, descriptor_);
730    printer->Print(variables_,
731      "$deprecation$public $type$.Builder get$capitalized_name$Builder(\n"
732      "    int index) {\n"
733      "  return get$capitalized_name$FieldBuilder().getBuilder(index);\n"
734      "}\n");
735
736    WriteFieldDocComment(printer, descriptor_);
737        printer->Print(variables_,
738      "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
739      "    int index) {\n"
740      "  if ($name$Builder_ == null) {\n"
741      "    return $name$_.get(index);"
742      "  } else {\n"
743      "    return $name$Builder_.getMessageOrBuilder(index);\n"
744      "  }\n"
745      "}\n");
746
747    WriteFieldDocComment(printer, descriptor_);
748        printer->Print(variables_,
749      "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
750      "     get$capitalized_name$OrBuilderList() {\n"
751      "  if ($name$Builder_ != null) {\n"
752      "    return $name$Builder_.getMessageOrBuilderList();\n"
753      "  } else {\n"
754      "    return java.util.Collections.unmodifiableList($name$_);\n"
755      "  }\n"
756      "}\n");
757
758    WriteFieldDocComment(printer, descriptor_);
759        printer->Print(variables_,
760      "$deprecation$public $type$.Builder add$capitalized_name$Builder() {\n"
761      "  return get$capitalized_name$FieldBuilder().addBuilder(\n"
762      "      $type$.getDefaultInstance());\n"
763      "}\n");
764    WriteFieldDocComment(printer, descriptor_);
765        printer->Print(variables_,
766      "$deprecation$public $type$.Builder add$capitalized_name$Builder(\n"
767      "    int index) {\n"
768      "  return get$capitalized_name$FieldBuilder().addBuilder(\n"
769      "      index, $type$.getDefaultInstance());\n"
770      "}\n");
771    WriteFieldDocComment(printer, descriptor_);
772        printer->Print(variables_,
773      "$deprecation$public java.util.List<$type$.Builder> \n"
774      "     get$capitalized_name$BuilderList() {\n"
775      "  return get$capitalized_name$FieldBuilder().getBuilderList();\n"
776      "}\n"
777      "private com.google.protobuf.RepeatedFieldBuilder<\n"
778      "    $type$, $type$.Builder, $type$OrBuilder> \n"
779      "    get$capitalized_name$FieldBuilder() {\n"
780      "  if ($name$Builder_ == null) {\n"
781      "    $name$Builder_ = new com.google.protobuf.RepeatedFieldBuilder<\n"
782      "        $type$, $type$.Builder, $type$OrBuilder>(\n"
783      "            $name$_,\n"
784      "            $get_mutable_bit_builder$,\n"
785      "            getParentForChildren(),\n"
786      "            isClean());\n"
787      "    $name$_ = null;\n"
788      "  }\n"
789      "  return $name$Builder_;\n"
790      "}\n");
791  }
792}
793
794void RepeatedImmutableLazyMessageFieldGenerator::
795GenerateParsingCode(io::Printer* printer) const {
796  printer->Print(variables_,
797    "if (!$get_mutable_bit_parser$) {\n"
798    "  $name$_ =\n"
799    "      new java.util.ArrayList<com.google.protobuf.LazyFieldLite>();\n"
800    "  $set_mutable_bit_parser$;\n"
801    "}\n"
802    "$name$_.add(new com.google.protobuf.LazyFieldLite(\n"
803    "    extensionRegistry, input.readBytes()));\n");
804}
805
806void RepeatedImmutableLazyMessageFieldGenerator::
807GenerateSerializationCode(io::Printer* printer) const {
808  printer->Print(variables_,
809    "for (int i = 0; i < $name$_.size(); i++) {\n"
810    "  output.writeBytes($number$, $name$_.get(i).toByteString());\n"
811    "}\n");
812}
813
814void RepeatedImmutableLazyMessageFieldGenerator::
815GenerateSerializedSizeCode(io::Printer* printer) const {
816  printer->Print(variables_,
817    "for (int i = 0; i < $name$_.size(); i++) {\n"
818    "  size += com.google.protobuf.CodedOutputStream\n"
819    "    .computeLazyFieldSize($number$, $name$_.get(i));\n"
820    "}\n");
821}
822
823}  // namespace java
824}  // namespace compiler
825}  // namespace protobuf
826}  // namespace google
827