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  WriteFieldDocComment(printer, descriptor_);
77  printer->Print(variables_,
78    "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
79    "  return $name$_;\n"
80    "}\n");
81}
82
83void ImmutableLazyMessageFieldGenerator::
84GenerateBuilderMembers(io::Printer* printer) const {
85  // When using nested-builders, the code initially works just like the
86  // non-nested builder case. It only creates a nested builder lazily on
87  // demand and then forever delegates to it after creation.
88
89  printer->Print(variables_,
90    "private com.google.protobuf.LazyFieldLite $name$_ =\n"
91    "    new com.google.protobuf.LazyFieldLite();\n");
92
93  printer->Print(variables_,
94    // If this builder is non-null, it is used and the other fields are
95    // ignored.
96    "private com.google.protobuf.SingleFieldBuilder<\n"
97    "    $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
98    "\n");
99
100  // The comments above the methods below are based on a hypothetical
101  // field of type "Field" called "Field".
102
103  // boolean hasField()
104  WriteFieldDocComment(printer, descriptor_);
105  printer->Print(variables_,
106    "$deprecation$public boolean has$capitalized_name$() {\n"
107    "  return $get_has_field_bit_builder$;\n"
108    "}\n");
109
110    printer->Print(variables_,
111      "$deprecation$public $type$ get$capitalized_name$() {\n"
112      "  return ($type$) $name$_.getValue($type$.getDefaultInstance());\n"
113      "}\n");
114
115  // Field.Builder setField(Field value)
116  WriteFieldDocComment(printer, descriptor_);
117  PrintNestedBuilderFunction(printer,
118    "$deprecation$public Builder set$capitalized_name$($type$ value)",
119
120    "if (value == null) {\n"
121    "  throw new NullPointerException();\n"
122    "}\n"
123    "$name$_.setValue(value);\n"
124    "$on_changed$\n",
125
126     NULL,  // Lazy fields are supported only for lite-runtime.
127
128    "$set_has_field_bit_builder$;\n"
129    "return this;\n");
130
131  // Field.Builder setField(Field.Builder builderForValue)
132  WriteFieldDocComment(printer, descriptor_);
133  PrintNestedBuilderFunction(printer,
134    "$deprecation$public Builder set$capitalized_name$(\n"
135    "    $type$.Builder builderForValue)",
136
137    "$name$_.setValue(builderForValue.build());\n"
138    "$on_changed$\n",
139
140    NULL,
141
142    "$set_has_field_bit_builder$;\n"
143    "return this;\n");
144
145  // Field.Builder mergeField(Field value)
146  WriteFieldDocComment(printer, descriptor_);
147  PrintNestedBuilderFunction(printer,
148    "$deprecation$public Builder merge$capitalized_name$($type$ value)",
149
150    "if ($get_has_field_bit_builder$ &&\n"
151    "    !$name$_.containsDefaultInstance()) {\n"
152    "  $name$_.setValue(\n"
153    "    $type$.newBuilder(\n"
154    "        get$capitalized_name$()).mergeFrom(value).buildPartial());\n"
155    "} else {\n"
156    "  $name$_.setValue(value);\n"
157    "}\n"
158    "$on_changed$\n",
159
160    NULL,
161
162    "$set_has_field_bit_builder$;\n"
163    "return this;\n");
164
165  // Field.Builder clearField()
166  WriteFieldDocComment(printer, descriptor_);
167  PrintNestedBuilderFunction(printer,
168    "$deprecation$public Builder clear$capitalized_name$()",
169
170    "$name$_.clear();\n"
171    "$on_changed$\n",
172
173    NULL,
174
175    "$clear_has_field_bit_builder$;\n"
176    "return this;\n");
177
178  WriteFieldDocComment(printer, descriptor_);
179  printer->Print(variables_,
180    "$deprecation$public $type$.Builder get$capitalized_name$Builder() {\n"
181    "  $set_has_field_bit_builder$;\n"
182    "  $on_changed$\n"
183    "  return get$capitalized_name$FieldBuilder().getBuilder();\n"
184    "}\n");
185  WriteFieldDocComment(printer, descriptor_);
186  printer->Print(variables_,
187    "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
188    "  if ($name$Builder_ != null) {\n"
189    "    return $name$Builder_.getMessageOrBuilder();\n"
190    "  } else {\n"
191    "    return $name$_;\n"
192    "  }\n"
193    "}\n");
194  WriteFieldDocComment(printer, descriptor_);
195  printer->Print(variables_,
196    "private com.google.protobuf.SingleFieldBuilder<\n"
197    "    $type$, $type$.Builder, $type$OrBuilder> \n"
198    "    get$capitalized_name$FieldBuilder() {\n"
199    "  if ($name$Builder_ == null) {\n"
200    "    $name$Builder_ = new com.google.protobuf.SingleFieldBuilder<\n"
201    "        $type$, $type$.Builder, $type$OrBuilder>(\n"
202    "            $name$_,\n"
203    "            getParentForChildren(),\n"
204    "            isClean());\n"
205    "    $name$_ = null;\n"
206    "  }\n"
207    "  return $name$Builder_;\n"
208    "}\n");
209}
210
211
212void ImmutableLazyMessageFieldGenerator::
213GenerateInitializationCode(io::Printer* printer) const {
214  printer->Print(variables_, "$name$_.clear();\n");
215}
216
217void ImmutableLazyMessageFieldGenerator::
218GenerateBuilderClearCode(io::Printer* printer) const {
219  printer->Print(variables_, "$name$_.clear();\n");
220  printer->Print(variables_, "$clear_has_field_bit_builder$;\n");
221}
222
223void ImmutableLazyMessageFieldGenerator::
224GenerateMergingCode(io::Printer* printer) const {
225  printer->Print(variables_,
226    "if (other.has$capitalized_name$()) {\n"
227    "  $name$_.merge(other.$name$_);\n"
228    "  $set_has_field_bit_builder$;\n"
229    "}\n");
230}
231
232void ImmutableLazyMessageFieldGenerator::
233GenerateBuildingCode(io::Printer* printer) const {
234  printer->Print(variables_,
235      "if ($get_has_field_bit_from_local$) {\n"
236      "  $set_has_field_bit_to_local$;\n"
237      "}\n");
238
239  printer->Print(variables_,
240      "result.$name$_.set(\n"
241      "    $name$_);\n");
242}
243
244void ImmutableLazyMessageFieldGenerator::
245GenerateParsingCode(io::Printer* printer) const {
246  printer->Print(variables_,
247    "$name$_.setByteString(input.readBytes(), extensionRegistry);\n");
248  printer->Print(variables_,
249    "$set_has_field_bit_message$;\n");
250}
251
252void ImmutableLazyMessageFieldGenerator::
253GenerateSerializationCode(io::Printer* printer) const {
254  // Do not de-serialize lazy fields.
255  printer->Print(variables_,
256    "if ($get_has_field_bit_message$) {\n"
257    "  output.writeBytes($number$, $name$_.toByteString());\n"
258    "}\n");
259}
260
261void ImmutableLazyMessageFieldGenerator::
262GenerateSerializedSizeCode(io::Printer* printer) const {
263  printer->Print(variables_,
264    "if ($get_has_field_bit_message$) {\n"
265    "  size += com.google.protobuf.CodedOutputStream\n"
266    "    .computeLazyFieldSize($number$, $name$_);\n"
267    "}\n");
268}
269
270// ===================================================================
271
272ImmutableLazyMessageOneofFieldGenerator::
273ImmutableLazyMessageOneofFieldGenerator(const FieldDescriptor* descriptor,
274                                        int messageBitIndex,
275                                        int builderBitIndex,
276                                        Context* context)
277    : ImmutableLazyMessageFieldGenerator(
278          descriptor, messageBitIndex, builderBitIndex, context) {
279  const OneofGeneratorInfo* info =
280      context->GetOneofGeneratorInfo(descriptor->containing_oneof());
281  SetCommonOneofVariables(descriptor, info, &variables_);
282  variables_["lazy_type"] = "com.google.protobuf.LazyFieldLite";
283}
284
285ImmutableLazyMessageOneofFieldGenerator::
286~ImmutableLazyMessageOneofFieldGenerator() {}
287
288void ImmutableLazyMessageOneofFieldGenerator::
289GenerateMembers(io::Printer* printer) const {
290  PrintExtraFieldInfo(variables_, printer);
291  WriteFieldDocComment(printer, descriptor_);
292
293  printer->Print(variables_,
294    "$deprecation$public boolean has$capitalized_name$() {\n"
295    "  return $has_oneof_case_message$;\n"
296    "}\n");
297  WriteFieldDocComment(printer, descriptor_);
298
299  printer->Print(variables_,
300    "$deprecation$public $type$ get$capitalized_name$() {\n"
301    "  if ($has_oneof_case_message$) {\n"
302    "    return ($type$) (($lazy_type$) $oneof_name$_).getValue(\n"
303    "        $type$.getDefaultInstance());\n"
304    "  }\n"
305    "  return $type$.getDefaultInstance();\n"
306    "}\n");
307}
308
309void ImmutableLazyMessageOneofFieldGenerator::
310GenerateBuilderMembers(io::Printer* printer) const {
311  // boolean hasField()
312  WriteFieldDocComment(printer, descriptor_);
313  printer->Print(variables_,
314    "$deprecation$public boolean has$capitalized_name$() {\n"
315    "  return $has_oneof_case_message$;\n"
316    "}\n");
317
318  printer->Print(variables_,
319    "$deprecation$public $type$ get$capitalized_name$() {\n"
320    "  if ($has_oneof_case_message$) {\n"
321    "    return ($type$) (($lazy_type$) $oneof_name$_).getValue(\n"
322    "        $type$.getDefaultInstance());\n"
323    "  }\n"
324    "  return $type$.getDefaultInstance();\n"
325    "}\n");
326
327  // Field.Builder setField(Field value)
328  WriteFieldDocComment(printer, descriptor_);
329  PrintNestedBuilderFunction(printer,
330    "$deprecation$public Builder set$capitalized_name$($type$ value)",
331
332    "if (value == null) {\n"
333    "  throw new NullPointerException();\n"
334    "}\n"
335    "if (!($has_oneof_case_message$)) {\n"
336    "  $oneof_name$_ = new $lazy_type$();\n"
337    "  $set_oneof_case_message$;\n"
338    "}\n"
339    "(($lazy_type$) $oneof_name$_).setValue(value);\n"
340    "$on_changed$\n",
341
342     NULL,  // Lazy fields are supported only for lite-runtime.
343
344    "return this;\n");
345
346  // Field.Builder setField(Field.Builder builderForValue)
347  WriteFieldDocComment(printer, descriptor_);
348  PrintNestedBuilderFunction(printer,
349    "$deprecation$public Builder set$capitalized_name$(\n"
350    "    $type$.Builder builderForValue)",
351
352    "if (!($has_oneof_case_message$)) {\n"
353    "  $oneof_name$_ = new $lazy_type$();\n"
354    "  $set_oneof_case_message$;\n"
355    "}\n"
356    "(($lazy_type$) $oneof_name$_).setValue(builderForValue.build());\n"
357    "$on_changed$\n",
358
359    NULL,
360
361    "return this;\n");
362
363  // Field.Builder mergeField(Field value)
364  WriteFieldDocComment(printer, descriptor_);
365  PrintNestedBuilderFunction(printer,
366    "$deprecation$public Builder merge$capitalized_name$($type$ value)",
367
368    "if ($has_oneof_case_message$ &&\n"
369    "    !(($lazy_type$) $oneof_name$_).containsDefaultInstance()) {\n"
370    "  (($lazy_type$) $oneof_name$_).setValue(\n"
371    "    $type$.newBuilder(\n"
372    "        get$capitalized_name$()).mergeFrom(value).buildPartial());\n"
373    "} else {\n"
374    "  if (!($has_oneof_case_message$)) {\n"
375    "    $oneof_name$_ = new $lazy_type$();\n"
376    "    $set_oneof_case_message$;\n"
377    "  }\n"
378    "  (($lazy_type$) $oneof_name$_).setValue(value);\n"
379    "}\n"
380    "$on_changed$\n",
381
382    NULL,
383
384    "return this;\n");
385
386  // Field.Builder clearField()
387  WriteFieldDocComment(printer, descriptor_);
388  PrintNestedBuilderFunction(printer,
389    "$deprecation$public Builder clear$capitalized_name$()",
390
391    "if ($has_oneof_case_message$) {\n"
392    "  $clear_oneof_case_message$;\n"
393    "  $oneof_name$_ = null;\n"
394    "  $on_changed$\n"
395    "}\n",
396
397    NULL,
398
399    "return this;\n");
400}
401
402void ImmutableLazyMessageOneofFieldGenerator::
403GenerateMergingCode(io::Printer* printer) const {
404  printer->Print(variables_,
405    "if (!($has_oneof_case_message$)) {\n"
406    "  $oneof_name$_ = new $lazy_type$();\n"
407    "}\n"
408    "(($lazy_type$) $oneof_name$_).merge(\n"
409    "    ($lazy_type$) other.$oneof_name$_);\n"
410    "$set_oneof_case_message$;\n");
411}
412
413void ImmutableLazyMessageOneofFieldGenerator::
414GenerateBuildingCode(io::Printer* printer) const {
415  printer->Print(variables_,
416                 "if ($has_oneof_case_message$) {\n");
417  printer->Indent();
418
419  printer->Print(variables_,
420      "result.$oneof_name$_ = new $lazy_type$();\n"
421      "(($lazy_type$) result.$oneof_name$_).set(\n"
422      "    (($lazy_type$) $oneof_name$_));\n");
423  printer->Outdent();
424  printer->Print("}\n");
425}
426
427void ImmutableLazyMessageOneofFieldGenerator::
428GenerateParsingCode(io::Printer* printer) const {
429  printer->Print(variables_,
430    "if (!($has_oneof_case_message$)) {\n"
431    "  $oneof_name$_ = new $lazy_type$();\n"
432    "}\n"
433    "(($lazy_type$) $oneof_name$_).setByteString(\n"
434    "    input.readBytes(), extensionRegistry);\n"
435    "$set_oneof_case_message$;\n");
436}
437
438void ImmutableLazyMessageOneofFieldGenerator::
439GenerateSerializationCode(io::Printer* printer) const {
440  // Do not de-serialize lazy fields.
441  printer->Print(variables_,
442    "if ($has_oneof_case_message$) {\n"
443    "  output.writeBytes(\n"
444    "      $number$, (($lazy_type$) $oneof_name$_).toByteString());\n"
445    "}\n");
446}
447
448void ImmutableLazyMessageOneofFieldGenerator::
449GenerateSerializedSizeCode(io::Printer* printer) const {
450  printer->Print(variables_,
451    "if ($has_oneof_case_message$) {\n"
452    "  size += com.google.protobuf.CodedOutputStream\n"
453    "    .computeLazyFieldSize($number$, ($lazy_type$) $oneof_name$_);\n"
454    "}\n");
455}
456
457// ===================================================================
458
459RepeatedImmutableLazyMessageFieldGenerator::
460RepeatedImmutableLazyMessageFieldGenerator(
461    const FieldDescriptor* descriptor,
462    int messageBitIndex,
463    int builderBitIndex,
464    Context* context)
465    : RepeatedImmutableMessageFieldGenerator(
466          descriptor, messageBitIndex, builderBitIndex, context) {
467}
468
469
470RepeatedImmutableLazyMessageFieldGenerator::
471~RepeatedImmutableLazyMessageFieldGenerator() {}
472
473void RepeatedImmutableLazyMessageFieldGenerator::
474GenerateMembers(io::Printer* printer) const {
475  printer->Print(variables_,
476    "private java.util.List<com.google.protobuf.LazyFieldLite> $name$_;\n");
477  PrintExtraFieldInfo(variables_, printer);
478  WriteFieldDocComment(printer, descriptor_);
479  printer->Print(variables_,
480    "$deprecation$public java.util.List<$type$>\n"
481    "    get$capitalized_name$List() {\n"
482    "  java.util.List<$type$> list =\n"
483    "      new java.util.ArrayList<$type$>($name$_.size());\n"
484    "  for (com.google.protobuf.LazyFieldLite lf : $name$_) {\n"
485    "    list.add(($type$) lf.getValue($type$.getDefaultInstance()));\n"
486    "  }\n"
487    "  return list;\n"
488    "}\n");
489  WriteFieldDocComment(printer, descriptor_);
490  printer->Print(variables_,
491    "$deprecation$public java.util.List<? extends $type$OrBuilder>\n"
492    "    get$capitalized_name$OrBuilderList() {\n"
493    "  return get$capitalized_name$List();\n"
494    "}\n");
495  WriteFieldDocComment(printer, descriptor_);
496  printer->Print(variables_,
497    "$deprecation$public int get$capitalized_name$Count() {\n"
498    "  return $name$_.size();\n"
499    "}\n");
500  WriteFieldDocComment(printer, descriptor_);
501  printer->Print(variables_,
502    "$deprecation$public $type$ get$capitalized_name$(int index) {\n"
503    "  return ($type$)\n"
504    "      $name$_.get(index).getValue($type$.getDefaultInstance());\n"
505    "}\n");
506  WriteFieldDocComment(printer, descriptor_);
507  printer->Print(variables_,
508    "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
509    "    int index) {\n"
510    "  return ($type$OrBuilder)\n"
511    "      $name$_.get(index).getValue($type$.getDefaultInstance());\n"
512    "}\n");
513}
514
515void RepeatedImmutableLazyMessageFieldGenerator::
516GenerateBuilderMembers(io::Printer* printer) const {
517  // When using nested-builders, the code initially works just like the
518  // non-nested builder case. It only creates a nested builder lazily on
519  // demand and then forever delegates to it after creation.
520
521  printer->Print(variables_,
522    "private java.util.List<com.google.protobuf.LazyFieldLite> $name$_ =\n"
523    "  java.util.Collections.emptyList();\n"
524
525    "private void ensure$capitalized_name$IsMutable() {\n"
526    "  if (!$get_mutable_bit_builder$) {\n"
527    "    $name$_ =\n"
528    "        new java.util.ArrayList<com.google.protobuf.LazyFieldLite>(\n"
529    "            $name$_);\n"
530    "    $set_mutable_bit_builder$;\n"
531    "   }\n"
532    "}\n"
533    "\n");
534
535  printer->Print(variables_,
536    // If this builder is non-null, it is used and the other fields are
537    // ignored.
538    "private com.google.protobuf.RepeatedFieldBuilder<\n"
539    "    $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;\n"
540    "\n");
541
542  // The comments above the methods below are based on a hypothetical
543  // repeated field of type "Field" called "RepeatedField".
544
545  // List<Field> getRepeatedFieldList()
546  WriteFieldDocComment(printer, descriptor_);
547  PrintNestedBuilderFunction(printer,
548    "$deprecation$public java.util.List<$type$> get$capitalized_name$List()",
549
550    "java.util.List<$type$> list =\n"
551    "    new java.util.ArrayList<$type$>($name$_.size());\n"
552    "for (com.google.protobuf.LazyFieldLite lf : $name$_) {\n"
553    "  list.add(($type$) lf.getValue($type$.getDefaultInstance()));\n"
554    "}\n"
555    "return java.util.Collections.unmodifiableList(list);\n",
556
557    "return $name$Builder_.getMessageList();\n",
558
559    NULL);
560
561  // int getRepeatedFieldCount()
562  WriteFieldDocComment(printer, descriptor_);
563  PrintNestedBuilderFunction(printer,
564    "$deprecation$public int get$capitalized_name$Count()",
565
566    "return $name$_.size();\n",
567    "return $name$Builder_.getCount();\n",
568
569    NULL);
570
571  // Field getRepeatedField(int index)
572  WriteFieldDocComment(printer, descriptor_);
573  PrintNestedBuilderFunction(printer,
574    "$deprecation$public $type$ get$capitalized_name$(int index)",
575
576    "return ($type$) $name$_.get(index).getValue(\n"
577    "    $type$.getDefaultInstance());\n",
578
579    "return $name$Builder_.getMessage(index);\n",
580
581    NULL);
582
583  // Builder setRepeatedField(int index, Field value)
584  WriteFieldDocComment(printer, descriptor_);
585  PrintNestedBuilderFunction(printer,
586    "$deprecation$public Builder set$capitalized_name$(\n"
587    "    int index, $type$ value)",
588    "if (value == null) {\n"
589    "  throw new NullPointerException();\n"
590    "}\n"
591    "ensure$capitalized_name$IsMutable();\n"
592    "$name$_.set(index, com.google.protobuf.LazyFieldLite.fromValue(value));\n"
593    "$on_changed$\n",
594    "$name$Builder_.setMessage(index, value);\n",
595    "return this;\n");
596
597  // Builder setRepeatedField(int index, Field.Builder builderForValue)
598  WriteFieldDocComment(printer, descriptor_);
599  PrintNestedBuilderFunction(printer,
600    "$deprecation$public Builder set$capitalized_name$(\n"
601    "    int index, $type$.Builder builderForValue)",
602
603    "ensure$capitalized_name$IsMutable();\n"
604    "$name$_.set(index, com.google.protobuf.LazyFieldLite.fromValue(\n"
605    "    builderForValue.build()));\n"
606    "$on_changed$\n",
607
608    "$name$Builder_.setMessage(index, builderForValue.build());\n",
609
610    "return this;\n");
611
612  // Builder addRepeatedField(Field value)
613  WriteFieldDocComment(printer, descriptor_);
614  PrintNestedBuilderFunction(printer,
615    "$deprecation$public Builder add$capitalized_name$($type$ value)",
616
617    "if (value == null) {\n"
618    "  throw new NullPointerException();\n"
619    "}\n"
620    "ensure$capitalized_name$IsMutable();\n"
621    "$name$_.add(com.google.protobuf.LazyFieldLite.fromValue(value));\n"
622
623    "$on_changed$\n",
624
625    "$name$Builder_.addMessage(value);\n",
626
627    "return this;\n");
628
629  // Builder addRepeatedField(int index, Field value)
630  WriteFieldDocComment(printer, descriptor_);
631  PrintNestedBuilderFunction(printer,
632    "$deprecation$public Builder add$capitalized_name$(\n"
633    "    int index, $type$ value)",
634
635    "if (value == null) {\n"
636    "  throw new NullPointerException();\n"
637    "}\n"
638    "ensure$capitalized_name$IsMutable();\n"
639    "$name$_.add(index, com.google.protobuf.LazyFieldLite.fromValue(value));\n"
640    "$on_changed$\n",
641
642    "$name$Builder_.addMessage(index, value);\n",
643
644    "return this;\n");
645
646  // Builder addRepeatedField(Field.Builder builderForValue)
647  WriteFieldDocComment(printer, descriptor_);
648  PrintNestedBuilderFunction(printer,
649    "$deprecation$public Builder add$capitalized_name$(\n"
650    "    $type$.Builder builderForValue)",
651
652    "ensure$capitalized_name$IsMutable();\n"
653    "$name$_.add(com.google.protobuf.LazyFieldLite.fromValue(\n"
654    "    builderForValue.build()));\n"
655    "$on_changed$\n",
656
657    "$name$Builder_.addMessage(builderForValue.build());\n",
658
659    "return this;\n");
660
661  // Builder addRepeatedField(int index, Field.Builder builderForValue)
662  WriteFieldDocComment(printer, descriptor_);
663  PrintNestedBuilderFunction(printer,
664    "$deprecation$public Builder add$capitalized_name$(\n"
665    "    int index, $type$.Builder builderForValue)",
666
667    "ensure$capitalized_name$IsMutable();\n"
668    "$name$_.add(index, com.google.protobuf.LazyFieldLite.fromValue(\n"
669    "    builderForValue.build()));\n"
670    "$on_changed$\n",
671
672    "$name$Builder_.addMessage(index, builderForValue.build());\n",
673
674    "return this;\n");
675
676  // Builder addAllRepeatedField(Iterable<Field> values)
677  WriteFieldDocComment(printer, descriptor_);
678  PrintNestedBuilderFunction(printer,
679    "$deprecation$public Builder addAll$capitalized_name$(\n"
680    "    java.lang.Iterable<? extends $type$> values)",
681
682    "ensure$capitalized_name$IsMutable();\n"
683    "for (com.google.protobuf.MessageLite v : values) {\n"
684    "  $name$_.add(com.google.protobuf.LazyFieldLite.fromValue(v));\n"
685    "}\n"
686    "$on_changed$\n",
687
688    "$name$Builder_.addAllMessages(values);\n",
689
690    "return this;\n");
691
692  // Builder clearAllRepeatedField()
693  WriteFieldDocComment(printer, descriptor_);
694  PrintNestedBuilderFunction(printer,
695    "$deprecation$public Builder clear$capitalized_name$()",
696
697    "$name$_ = java.util.Collections.emptyList();\n"
698    "$clear_mutable_bit_builder$;\n"
699    "$on_changed$\n",
700
701    "$name$Builder_.clear();\n",
702
703    "return this;\n");
704
705  // Builder removeRepeatedField(int index)
706  WriteFieldDocComment(printer, descriptor_);
707  PrintNestedBuilderFunction(printer,
708    "$deprecation$public Builder remove$capitalized_name$(int index)",
709
710    "ensure$capitalized_name$IsMutable();\n"
711    "$name$_.remove(index);\n"
712    "$on_changed$\n",
713
714    "$name$Builder_.remove(index);\n",
715
716    "return this;\n");
717
718  WriteFieldDocComment(printer, descriptor_);
719  printer->Print(variables_,
720    "$deprecation$public $type$.Builder get$capitalized_name$Builder(\n"
721    "    int index) {\n"
722    "  return get$capitalized_name$FieldBuilder().getBuilder(index);\n"
723    "}\n");
724
725  WriteFieldDocComment(printer, descriptor_);
726      printer->Print(variables_,
727    "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
728    "    int index) {\n"
729    "  if ($name$Builder_ == null) {\n"
730    "    return $name$_.get(index);"
731    "  } else {\n"
732    "    return $name$Builder_.getMessageOrBuilder(index);\n"
733    "  }\n"
734    "}\n");
735
736  WriteFieldDocComment(printer, descriptor_);
737      printer->Print(variables_,
738    "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
739    "     get$capitalized_name$OrBuilderList() {\n"
740    "  if ($name$Builder_ != null) {\n"
741    "    return $name$Builder_.getMessageOrBuilderList();\n"
742    "  } else {\n"
743    "    return java.util.Collections.unmodifiableList($name$_);\n"
744    "  }\n"
745    "}\n");
746
747  WriteFieldDocComment(printer, descriptor_);
748      printer->Print(variables_,
749    "$deprecation$public $type$.Builder add$capitalized_name$Builder() {\n"
750    "  return get$capitalized_name$FieldBuilder().addBuilder(\n"
751    "      $type$.getDefaultInstance());\n"
752    "}\n");
753  WriteFieldDocComment(printer, descriptor_);
754      printer->Print(variables_,
755    "$deprecation$public $type$.Builder add$capitalized_name$Builder(\n"
756    "    int index) {\n"
757    "  return get$capitalized_name$FieldBuilder().addBuilder(\n"
758    "      index, $type$.getDefaultInstance());\n"
759    "}\n");
760  WriteFieldDocComment(printer, descriptor_);
761      printer->Print(variables_,
762    "$deprecation$public java.util.List<$type$.Builder> \n"
763    "     get$capitalized_name$BuilderList() {\n"
764    "  return get$capitalized_name$FieldBuilder().getBuilderList();\n"
765    "}\n"
766    "private com.google.protobuf.RepeatedFieldBuilder<\n"
767    "    $type$, $type$.Builder, $type$OrBuilder> \n"
768    "    get$capitalized_name$FieldBuilder() {\n"
769    "  if ($name$Builder_ == null) {\n"
770    "    $name$Builder_ = new com.google.protobuf.RepeatedFieldBuilder<\n"
771    "        $type$, $type$.Builder, $type$OrBuilder>(\n"
772    "            $name$_,\n"
773    "            $get_mutable_bit_builder$,\n"
774    "            getParentForChildren(),\n"
775    "            isClean());\n"
776    "    $name$_ = null;\n"
777    "  }\n"
778    "  return $name$Builder_;\n"
779    "}\n");
780}
781
782void RepeatedImmutableLazyMessageFieldGenerator::
783GenerateParsingCode(io::Printer* printer) const {
784  printer->Print(variables_,
785    "if (!$get_mutable_bit_parser$) {\n"
786    "  $name$_ =\n"
787    "      new java.util.ArrayList<com.google.protobuf.LazyFieldLite>();\n"
788    "  $set_mutable_bit_parser$;\n"
789    "}\n"
790    "$name$_.add(new com.google.protobuf.LazyFieldLite(\n"
791    "    extensionRegistry, input.readBytes()));\n");
792}
793
794void RepeatedImmutableLazyMessageFieldGenerator::
795GenerateSerializationCode(io::Printer* printer) const {
796  printer->Print(variables_,
797    "for (int i = 0; i < $name$_.size(); i++) {\n"
798    "  output.writeBytes($number$, $name$_.get(i).toByteString());\n"
799    "}\n");
800}
801
802void RepeatedImmutableLazyMessageFieldGenerator::
803GenerateSerializedSizeCode(io::Printer* printer) const {
804  printer->Print(variables_,
805    "for (int i = 0; i < $name$_.size(); i++) {\n"
806    "  size += com.google.protobuf.CodedOutputStream\n"
807    "    .computeLazyFieldSize($number$, $name$_.get(i));\n"
808    "}\n");
809}
810
811}  // namespace java
812}  // namespace compiler
813}  // namespace protobuf
814}  // namespace google
815