Line data Source code
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: kenton@google.com (Kenton Varda)
32 : // Based on original Protocol Buffers design by
33 : // Sanjay Ghemawat, Jeff Dean, and others.
34 :
35 : #include <map>
36 : #include <string>
37 :
38 : #include <google/protobuf/compiler/java/java_context.h>
39 : #include <google/protobuf/compiler/java/java_message_field.h>
40 : #include <google/protobuf/compiler/java/java_doc_comment.h>
41 : #include <google/protobuf/compiler/java/java_helpers.h>
42 : #include <google/protobuf/compiler/java/java_name_resolver.h>
43 : #include <google/protobuf/io/printer.h>
44 : #include <google/protobuf/wire_format.h>
45 : #include <google/protobuf/stubs/strutil.h>
46 :
47 : namespace google {
48 : namespace protobuf {
49 : namespace compiler {
50 : namespace java {
51 :
52 : namespace {
53 :
54 0 : void SetMessageVariables(const FieldDescriptor* descriptor,
55 : int messageBitIndex,
56 : int builderBitIndex,
57 : const FieldGeneratorInfo* info,
58 : ClassNameResolver* name_resolver,
59 : map<string, string>* variables) {
60 0 : SetCommonFieldVariables(descriptor, info, variables);
61 :
62 0 : (*variables)["type"] =
63 : name_resolver->GetImmutableClassName(descriptor->message_type());
64 0 : (*variables)["mutable_type"] =
65 : name_resolver->GetMutableClassName(descriptor->message_type());
66 0 : (*variables)["group_or_message"] =
67 0 : (GetType(descriptor) == FieldDescriptor::TYPE_GROUP) ?
68 : "Group" : "Message";
69 : // TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
70 : // by the proto compiler
71 0 : (*variables)["deprecation"] = descriptor->options().deprecated()
72 : ? "@java.lang.Deprecated " : "";
73 0 : (*variables)["on_changed"] =
74 0 : HasDescriptorMethods(descriptor->containing_type()) ? "onChanged();" : "";
75 :
76 0 : if (SupportFieldPresence(descriptor->file())) {
77 : // For singular messages and builders, one bit is used for the hasField bit.
78 0 : (*variables)["get_has_field_bit_message"] = GenerateGetBit(messageBitIndex);
79 0 : (*variables)["get_has_field_bit_builder"] = GenerateGetBit(builderBitIndex);
80 :
81 : // Note that these have a trailing ";".
82 0 : (*variables)["set_has_field_bit_message"] =
83 0 : GenerateSetBit(messageBitIndex) + ";";
84 0 : (*variables)["set_has_field_bit_builder"] =
85 0 : GenerateSetBit(builderBitIndex) + ";";
86 0 : (*variables)["clear_has_field_bit_builder"] =
87 0 : GenerateClearBit(builderBitIndex) + ";";
88 :
89 0 : (*variables)["is_field_present_message"] = GenerateGetBit(messageBitIndex);
90 : } else {
91 0 : (*variables)["set_has_field_bit_message"] = "";
92 0 : (*variables)["set_has_field_bit_builder"] = "";
93 0 : (*variables)["clear_has_field_bit_builder"] = "";
94 :
95 0 : (*variables)["is_field_present_message"] =
96 0 : (*variables)["name"] + "_ != null";
97 : }
98 :
99 : // For repated builders, one bit is used for whether the array is immutable.
100 0 : (*variables)["get_mutable_bit_builder"] = GenerateGetBit(builderBitIndex);
101 0 : (*variables)["set_mutable_bit_builder"] = GenerateSetBit(builderBitIndex);
102 0 : (*variables)["clear_mutable_bit_builder"] = GenerateClearBit(builderBitIndex);
103 :
104 : // For repeated fields, one bit is used for whether the array is immutable
105 : // in the parsing constructor.
106 0 : (*variables)["get_mutable_bit_parser"] =
107 : GenerateGetBitMutableLocal(builderBitIndex);
108 0 : (*variables)["set_mutable_bit_parser"] =
109 : GenerateSetBitMutableLocal(builderBitIndex);
110 :
111 0 : (*variables)["get_has_field_bit_from_local"] =
112 : GenerateGetBitFromLocal(builderBitIndex);
113 0 : (*variables)["set_has_field_bit_to_local"] =
114 : GenerateSetBitToLocal(messageBitIndex);
115 0 : }
116 :
117 : } // namespace
118 :
119 : // ===================================================================
120 :
121 0 : ImmutableMessageFieldGenerator::
122 : ImmutableMessageFieldGenerator(const FieldDescriptor* descriptor,
123 : int messageBitIndex,
124 : int builderBitIndex,
125 : Context* context)
126 : : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
127 : builderBitIndex_(builderBitIndex), context_(context),
128 0 : name_resolver_(context->GetNameResolver()) {
129 : SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
130 : context->GetFieldGeneratorInfo(descriptor),
131 0 : name_resolver_, &variables_);
132 0 : }
133 :
134 0 : ImmutableMessageFieldGenerator::~ImmutableMessageFieldGenerator() {}
135 :
136 0 : int ImmutableMessageFieldGenerator::GetNumBitsForMessage() const {
137 0 : return 1;
138 : }
139 :
140 0 : int ImmutableMessageFieldGenerator::GetNumBitsForBuilder() const {
141 0 : return 1;
142 : }
143 :
144 0 : void ImmutableMessageFieldGenerator::
145 : GenerateInterfaceMembers(io::Printer* printer) const {
146 : // TODO(jonp): In the future, consider having a method specific to the
147 : // interface so that builders can choose dynamically to either return a
148 : // message or a nested builder, so that asking for the interface doesn't
149 : // cause a message to ever be built.
150 0 : if (SupportFieldPresence(descriptor_->file()) ||
151 0 : descriptor_->containing_oneof() == NULL) {
152 0 : WriteFieldDocComment(printer, descriptor_);
153 : printer->Print(variables_,
154 0 : "$deprecation$boolean has$capitalized_name$();\n");
155 : }
156 0 : WriteFieldDocComment(printer, descriptor_);
157 : printer->Print(variables_,
158 0 : "$deprecation$$type$ get$capitalized_name$();\n");
159 :
160 0 : WriteFieldDocComment(printer, descriptor_);
161 : printer->Print(variables_,
162 0 : "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder();\n");
163 0 : }
164 :
165 0 : void ImmutableMessageFieldGenerator::
166 : GenerateMembers(io::Printer* printer) const {
167 : printer->Print(variables_,
168 0 : "private $type$ $name$_;\n");
169 0 : PrintExtraFieldInfo(variables_, printer);
170 :
171 0 : if (SupportFieldPresence(descriptor_->file())) {
172 0 : WriteFieldDocComment(printer, descriptor_);
173 : printer->Print(variables_,
174 : "$deprecation$public boolean has$capitalized_name$() {\n"
175 : " return $get_has_field_bit_message$;\n"
176 0 : "}\n");
177 0 : WriteFieldDocComment(printer, descriptor_);
178 : printer->Print(variables_,
179 : "$deprecation$public $type$ get$capitalized_name$() {\n"
180 : " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
181 0 : "}\n");
182 :
183 0 : WriteFieldDocComment(printer, descriptor_);
184 : printer->Print(variables_,
185 : "$deprecation$public $type$OrBuilder "
186 : "get$capitalized_name$OrBuilder() {\n"
187 : " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
188 0 : "}\n");
189 : } else {
190 0 : WriteFieldDocComment(printer, descriptor_);
191 : printer->Print(variables_,
192 : "$deprecation$public boolean has$capitalized_name$() {\n"
193 : " return $name$_ != null;\n"
194 0 : "}\n");
195 0 : WriteFieldDocComment(printer, descriptor_);
196 : printer->Print(variables_,
197 : "$deprecation$public $type$ get$capitalized_name$() {\n"
198 : " return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n"
199 0 : "}\n");
200 :
201 0 : WriteFieldDocComment(printer, descriptor_);
202 : printer->Print(variables_,
203 : "$deprecation$public $type$OrBuilder "
204 : "get$capitalized_name$OrBuilder() {\n"
205 : " return get$capitalized_name$();\n"
206 0 : "}\n");
207 : }
208 0 : }
209 :
210 0 : void ImmutableMessageFieldGenerator::PrintNestedBuilderCondition(
211 : io::Printer* printer,
212 : const char* regular_case,
213 : const char* nested_builder_case) const {
214 0 : printer->Print(variables_, "if ($name$Builder_ == null) {\n");
215 0 : printer->Indent();
216 0 : printer->Print(variables_, regular_case);
217 0 : printer->Outdent();
218 0 : printer->Print("} else {\n");
219 0 : printer->Indent();
220 0 : printer->Print(variables_, nested_builder_case);
221 0 : printer->Outdent();
222 0 : printer->Print("}\n");
223 0 : }
224 :
225 0 : void ImmutableMessageFieldGenerator::PrintNestedBuilderFunction(
226 : io::Printer* printer,
227 : const char* method_prototype,
228 : const char* regular_case,
229 : const char* nested_builder_case,
230 : const char* trailing_code) const {
231 0 : printer->Print(variables_, method_prototype);
232 0 : printer->Print(" {\n");
233 0 : printer->Indent();
234 0 : PrintNestedBuilderCondition(printer, regular_case, nested_builder_case);
235 0 : if (trailing_code != NULL) {
236 0 : printer->Print(variables_, trailing_code);
237 : }
238 0 : printer->Outdent();
239 0 : printer->Print("}\n");
240 0 : }
241 :
242 0 : void ImmutableMessageFieldGenerator::
243 : GenerateBuilderMembers(io::Printer* printer) const {
244 : // When using nested-builders, the code initially works just like the
245 : // non-nested builder case. It only creates a nested builder lazily on
246 : // demand and then forever delegates to it after creation.
247 :
248 0 : bool support_field_presence = SupportFieldPresence(descriptor_->file());
249 :
250 : printer->Print(variables_,
251 0 : "private $type$ $name$_ = null;\n");
252 :
253 : printer->Print(variables_,
254 : // If this builder is non-null, it is used and the other fields are
255 : // ignored.
256 : "private com.google.protobuf.SingleFieldBuilder<\n"
257 : " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
258 0 : "\n");
259 :
260 : // The comments above the methods below are based on a hypothetical
261 : // field of type "Field" called "Field".
262 :
263 : // boolean hasField()
264 0 : WriteFieldDocComment(printer, descriptor_);
265 0 : if (support_field_presence) {
266 : printer->Print(variables_,
267 : "$deprecation$public boolean has$capitalized_name$() {\n"
268 : " return $get_has_field_bit_builder$;\n"
269 0 : "}\n");
270 : } else {
271 : printer->Print(variables_,
272 : "$deprecation$public boolean has$capitalized_name$() {\n"
273 : " return $name$Builder_ != null || $name$_ != null;\n"
274 0 : "}\n");
275 : }
276 :
277 : // Field getField()
278 0 : WriteFieldDocComment(printer, descriptor_);
279 : PrintNestedBuilderFunction(printer,
280 : "$deprecation$public $type$ get$capitalized_name$()",
281 : "return $name$_ == null ? $type$.getDefaultInstance() : $name$_;\n",
282 : "return $name$Builder_.getMessage();\n",
283 0 : NULL);
284 :
285 : // Field.Builder setField(Field value)
286 0 : WriteFieldDocComment(printer, descriptor_);
287 : PrintNestedBuilderFunction(printer,
288 : "$deprecation$public Builder set$capitalized_name$($type$ value)",
289 :
290 : "if (value == null) {\n"
291 : " throw new NullPointerException();\n"
292 : "}\n"
293 : "$name$_ = value;\n"
294 : "$on_changed$\n",
295 :
296 : "$name$Builder_.setMessage(value);\n",
297 :
298 : "$set_has_field_bit_builder$\n"
299 0 : "return this;\n");
300 :
301 : // Field.Builder setField(Field.Builder builderForValue)
302 0 : WriteFieldDocComment(printer, descriptor_);
303 : PrintNestedBuilderFunction(printer,
304 : "$deprecation$public Builder set$capitalized_name$(\n"
305 : " $type$.Builder builderForValue)",
306 :
307 : "$name$_ = builderForValue.build();\n"
308 : "$on_changed$\n",
309 :
310 : "$name$Builder_.setMessage(builderForValue.build());\n",
311 :
312 : "$set_has_field_bit_builder$\n"
313 0 : "return this;\n");
314 :
315 : // Field.Builder mergeField(Field value)
316 0 : WriteFieldDocComment(printer, descriptor_);
317 : PrintNestedBuilderFunction(printer,
318 : "$deprecation$public Builder merge$capitalized_name$($type$ value)",
319 :
320 : support_field_presence
321 : ? "if ($get_has_field_bit_builder$ &&\n"
322 : " $name$_ != null &&\n"
323 : " $name$_ != $type$.getDefaultInstance()) {\n"
324 : " $name$_ =\n"
325 : " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
326 : "} else {\n"
327 : " $name$_ = value;\n"
328 : "}\n"
329 : "$on_changed$\n"
330 : : "if ($name$_ != null) {\n"
331 : " $name$_ =\n"
332 : " $type$.newBuilder($name$_).mergeFrom(value).buildPartial();\n"
333 : "} else {\n"
334 : " $name$_ = value;\n"
335 : "}\n"
336 : "$on_changed$\n",
337 :
338 : "$name$Builder_.mergeFrom(value);\n",
339 :
340 : "$set_has_field_bit_builder$\n"
341 0 : "return this;\n");
342 :
343 : // Field.Builder clearField()
344 0 : WriteFieldDocComment(printer, descriptor_);
345 : PrintNestedBuilderFunction(printer,
346 : "$deprecation$public Builder clear$capitalized_name$()",
347 :
348 : "$name$_ = null;\n"
349 : "$on_changed$\n",
350 :
351 : support_field_presence
352 : ? "$name$Builder_.clear();\n"
353 : : "$name$_ = null;\n"
354 : "$name$Builder_ = null;\n",
355 :
356 : "$clear_has_field_bit_builder$\n"
357 0 : "return this;\n");
358 :
359 0 : WriteFieldDocComment(printer, descriptor_);
360 : printer->Print(variables_,
361 : "$deprecation$public $type$.Builder get$capitalized_name$Builder() {\n"
362 : " $set_has_field_bit_builder$\n"
363 : " $on_changed$\n"
364 : " return get$capitalized_name$FieldBuilder().getBuilder();\n"
365 0 : "}\n");
366 0 : WriteFieldDocComment(printer, descriptor_);
367 : printer->Print(variables_,
368 : "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
369 : " if ($name$Builder_ != null) {\n"
370 : " return $name$Builder_.getMessageOrBuilder();\n"
371 : " } else {\n"
372 : " return $name$_ == null ?\n"
373 : " $type$.getDefaultInstance() : $name$_;\n"
374 : " }\n"
375 0 : "}\n");
376 0 : WriteFieldDocComment(printer, descriptor_);
377 : printer->Print(variables_,
378 : "private com.google.protobuf.SingleFieldBuilder<\n"
379 : " $type$, $type$.Builder, $type$OrBuilder> \n"
380 : " get$capitalized_name$FieldBuilder() {\n"
381 : " if ($name$Builder_ == null) {\n"
382 : " $name$Builder_ = new com.google.protobuf.SingleFieldBuilder<\n"
383 : " $type$, $type$.Builder, $type$OrBuilder>(\n"
384 : " get$capitalized_name$(),\n"
385 : " getParentForChildren(),\n"
386 : " isClean());\n"
387 : " $name$_ = null;\n"
388 : " }\n"
389 : " return $name$Builder_;\n"
390 0 : "}\n");
391 0 : }
392 :
393 0 : void ImmutableMessageFieldGenerator::
394 : GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
395 0 : if (SupportFieldPresence(descriptor_->file())) {
396 : printer->Print(variables_,
397 0 : "get$capitalized_name$FieldBuilder();\n");
398 : }
399 0 : }
400 :
401 :
402 0 : void ImmutableMessageFieldGenerator::
403 0 : GenerateInitializationCode(io::Printer* printer) const {}
404 :
405 0 : void ImmutableMessageFieldGenerator::
406 : GenerateBuilderClearCode(io::Printer* printer) const {
407 0 : if (SupportFieldPresence(descriptor_->file())) {
408 : PrintNestedBuilderCondition(printer,
409 : "$name$_ = null;\n",
410 :
411 0 : "$name$Builder_.clear();\n");
412 0 : printer->Print(variables_, "$clear_has_field_bit_builder$\n");
413 : } else {
414 : PrintNestedBuilderCondition(printer,
415 : "$name$_ = null;\n",
416 :
417 : "$name$_ = null;\n"
418 0 : "$name$Builder_ = null;\n");
419 : }
420 0 : }
421 :
422 0 : void ImmutableMessageFieldGenerator::
423 : GenerateMergingCode(io::Printer* printer) const {
424 : printer->Print(variables_,
425 : "if (other.has$capitalized_name$()) {\n"
426 : " merge$capitalized_name$(other.get$capitalized_name$());\n"
427 0 : "}\n");
428 0 : }
429 :
430 0 : void ImmutableMessageFieldGenerator::
431 : GenerateBuildingCode(io::Printer* printer) const {
432 0 : if (SupportFieldPresence(descriptor_->file())) {
433 : printer->Print(variables_,
434 : "if ($get_has_field_bit_from_local$) {\n"
435 : " $set_has_field_bit_to_local$;\n"
436 0 : "}\n");
437 : }
438 :
439 : PrintNestedBuilderCondition(printer,
440 : "result.$name$_ = $name$_;\n",
441 :
442 0 : "result.$name$_ = $name$Builder_.build();\n");
443 0 : }
444 :
445 0 : void ImmutableMessageFieldGenerator::
446 : GenerateParsingCode(io::Printer* printer) const {
447 : printer->Print(variables_,
448 : "$type$.Builder subBuilder = null;\n"
449 : "if ($is_field_present_message$) {\n"
450 : " subBuilder = $name$_.toBuilder();\n"
451 0 : "}\n");
452 :
453 0 : if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
454 : printer->Print(variables_,
455 : "$name$_ = input.readGroup($number$, $type$.parser(),\n"
456 0 : " extensionRegistry);\n");
457 : } else {
458 : printer->Print(variables_,
459 0 : "$name$_ = input.readMessage($type$.parser(), extensionRegistry);\n");
460 : }
461 :
462 : printer->Print(variables_,
463 : "if (subBuilder != null) {\n"
464 : " subBuilder.mergeFrom($name$_);\n"
465 : " $name$_ = subBuilder.buildPartial();\n"
466 : "}\n"
467 0 : "$set_has_field_bit_message$\n");
468 0 : }
469 :
470 0 : void ImmutableMessageFieldGenerator::
471 : GenerateParsingDoneCode(io::Printer* printer) const {
472 : // noop for messages.
473 0 : }
474 :
475 0 : void ImmutableMessageFieldGenerator::
476 : GenerateSerializationCode(io::Printer* printer) const {
477 : printer->Print(variables_,
478 : "if ($is_field_present_message$) {\n"
479 : " output.write$group_or_message$($number$, get$capitalized_name$());\n"
480 0 : "}\n");
481 0 : }
482 :
483 0 : void ImmutableMessageFieldGenerator::
484 : GenerateSerializedSizeCode(io::Printer* printer) const {
485 : printer->Print(variables_,
486 : "if ($is_field_present_message$) {\n"
487 : " size += com.google.protobuf.CodedOutputStream\n"
488 : " .compute$group_or_message$Size($number$, get$capitalized_name$());\n"
489 0 : "}\n");
490 0 : }
491 :
492 0 : void ImmutableMessageFieldGenerator::
493 : GenerateEqualsCode(io::Printer* printer) const {
494 : printer->Print(variables_,
495 : "result = result && get$capitalized_name$()\n"
496 0 : " .equals(other.get$capitalized_name$());\n");
497 0 : }
498 :
499 0 : void ImmutableMessageFieldGenerator::
500 : GenerateHashCode(io::Printer* printer) const {
501 : printer->Print(variables_,
502 : "hash = (37 * hash) + $constant_name$;\n"
503 0 : "hash = (53 * hash) + get$capitalized_name$().hashCode();\n");
504 0 : }
505 :
506 0 : string ImmutableMessageFieldGenerator::GetBoxedType() const {
507 0 : return name_resolver_->GetImmutableClassName(descriptor_->message_type());
508 : }
509 :
510 : // ===================================================================
511 :
512 0 : ImmutableMessageOneofFieldGenerator::
513 0 : ImmutableMessageOneofFieldGenerator(const FieldDescriptor* descriptor,
514 : int messageBitIndex,
515 : int builderBitIndex,
516 : Context* context)
517 : : ImmutableMessageFieldGenerator(
518 0 : descriptor, messageBitIndex, builderBitIndex, context) {
519 : const OneofGeneratorInfo* info =
520 0 : context->GetOneofGeneratorInfo(descriptor->containing_oneof());
521 0 : SetCommonOneofVariables(descriptor, info, &variables_);
522 0 : }
523 :
524 0 : ImmutableMessageOneofFieldGenerator::
525 0 : ~ImmutableMessageOneofFieldGenerator() {}
526 :
527 0 : void ImmutableMessageOneofFieldGenerator::
528 : GenerateMembers(io::Printer* printer) const {
529 0 : PrintExtraFieldInfo(variables_, printer);
530 0 : if (SupportFieldPresence(descriptor_->file())) {
531 0 : WriteFieldDocComment(printer, descriptor_);
532 : printer->Print(variables_,
533 : "$deprecation$public boolean has$capitalized_name$() {\n"
534 : " return $has_oneof_case_message$;\n"
535 0 : "}\n");
536 : }
537 0 : WriteFieldDocComment(printer, descriptor_);
538 : printer->Print(variables_,
539 : "$deprecation$public $type$ get$capitalized_name$() {\n"
540 : " if ($has_oneof_case_message$) {\n"
541 : " return ($type$) $oneof_name$_;\n"
542 : " }\n"
543 : " return $type$.getDefaultInstance();\n"
544 0 : "}\n");
545 :
546 0 : WriteFieldDocComment(printer, descriptor_);
547 : printer->Print(variables_,
548 : "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
549 : " if ($has_oneof_case_message$) {\n"
550 : " return ($type$) $oneof_name$_;\n"
551 : " }\n"
552 : " return $type$.getDefaultInstance();\n"
553 0 : "}\n");
554 0 : }
555 :
556 0 : void ImmutableMessageOneofFieldGenerator::
557 : GenerateBuilderMembers(io::Printer* printer) const {
558 : // When using nested-builders, the code initially works just like the
559 : // non-nested builder case. It only creates a nested builder lazily on
560 : // demand and then forever delegates to it after creation.
561 : printer->Print(variables_,
562 : // If this builder is non-null, it is used and the other fields are
563 : // ignored.
564 : "private com.google.protobuf.SingleFieldBuilder<\n"
565 : " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;"
566 0 : "\n");
567 :
568 : // The comments above the methods below are based on a hypothetical
569 : // field of type "Field" called "Field".
570 :
571 0 : if (SupportFieldPresence(descriptor_->file())) {
572 : // boolean hasField()
573 0 : WriteFieldDocComment(printer, descriptor_);
574 : printer->Print(variables_,
575 : "$deprecation$public boolean has$capitalized_name$() {\n"
576 : " return $has_oneof_case_message$;\n"
577 0 : "}\n");
578 : }
579 :
580 : // Field getField()
581 0 : WriteFieldDocComment(printer, descriptor_);
582 : PrintNestedBuilderFunction(printer,
583 : "$deprecation$public $type$ get$capitalized_name$()",
584 :
585 : "if ($has_oneof_case_message$) {\n"
586 : " return ($type$) $oneof_name$_;\n"
587 : "}\n"
588 : "return $type$.getDefaultInstance();\n",
589 :
590 : "if ($has_oneof_case_message$) {\n"
591 : " return $name$Builder_.getMessage();\n"
592 : "}\n"
593 : "return $type$.getDefaultInstance();\n",
594 :
595 0 : NULL);
596 :
597 : // Field.Builder setField(Field value)
598 0 : WriteFieldDocComment(printer, descriptor_);
599 : PrintNestedBuilderFunction(printer,
600 : "$deprecation$public Builder set$capitalized_name$($type$ value)",
601 :
602 : "if (value == null) {\n"
603 : " throw new NullPointerException();\n"
604 : "}\n"
605 : "$oneof_name$_ = value;\n"
606 : "$on_changed$\n",
607 :
608 : "$name$Builder_.setMessage(value);\n",
609 :
610 : "$set_oneof_case_message$;\n"
611 0 : "return this;\n");
612 :
613 : // Field.Builder setField(Field.Builder builderForValue)
614 0 : WriteFieldDocComment(printer, descriptor_);
615 : PrintNestedBuilderFunction(printer,
616 : "$deprecation$public Builder set$capitalized_name$(\n"
617 : " $type$.Builder builderForValue)",
618 :
619 : "$oneof_name$_ = builderForValue.build();\n"
620 : "$on_changed$\n",
621 :
622 : "$name$Builder_.setMessage(builderForValue.build());\n",
623 :
624 : "$set_oneof_case_message$;\n"
625 0 : "return this;\n");
626 :
627 : // Field.Builder mergeField(Field value)
628 0 : WriteFieldDocComment(printer, descriptor_);
629 : PrintNestedBuilderFunction(printer,
630 : "$deprecation$public Builder merge$capitalized_name$($type$ value)",
631 :
632 : "if ($has_oneof_case_message$ &&\n"
633 : " $oneof_name$_ != $type$.getDefaultInstance()) {\n"
634 : " $oneof_name$_ = $type$.newBuilder(($type$) $oneof_name$_)\n"
635 : " .mergeFrom(value).buildPartial();\n"
636 : "} else {\n"
637 : " $oneof_name$_ = value;\n"
638 : "}\n"
639 : "$on_changed$\n",
640 :
641 : "if ($has_oneof_case_message$) {\n"
642 : " $name$Builder_.mergeFrom(value);\n"
643 : "}\n"
644 : "$name$Builder_.setMessage(value);\n",
645 :
646 : "$set_oneof_case_message$;\n"
647 0 : "return this;\n");
648 :
649 : // Field.Builder clearField()
650 0 : WriteFieldDocComment(printer, descriptor_);
651 : PrintNestedBuilderFunction(printer,
652 : "$deprecation$public Builder clear$capitalized_name$()",
653 :
654 : "if ($has_oneof_case_message$) {\n"
655 : " $clear_oneof_case_message$;\n"
656 : " $oneof_name$_ = null;\n"
657 : " $on_changed$\n"
658 : "}\n",
659 :
660 : "if ($has_oneof_case_message$) {\n"
661 : " $clear_oneof_case_message$;\n"
662 : " $oneof_name$_ = null;\n"
663 : "}\n"
664 : "$name$Builder_.clear();\n",
665 :
666 0 : "return this;\n");
667 :
668 0 : WriteFieldDocComment(printer, descriptor_);
669 : printer->Print(variables_,
670 : "$deprecation$public $type$.Builder get$capitalized_name$Builder() {\n"
671 : " return get$capitalized_name$FieldBuilder().getBuilder();\n"
672 0 : "}\n");
673 0 : WriteFieldDocComment(printer, descriptor_);
674 : printer->Print(variables_,
675 : "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder() {\n"
676 : " if (($has_oneof_case_message$) && ($name$Builder_ != null)) {\n"
677 : " return $name$Builder_.getMessageOrBuilder();\n"
678 : " } else {\n"
679 : " if ($has_oneof_case_message$) {\n"
680 : " return ($type$) $oneof_name$_;\n"
681 : " }\n"
682 : " return $type$.getDefaultInstance();\n"
683 : " }\n"
684 0 : "}\n");
685 0 : WriteFieldDocComment(printer, descriptor_);
686 : printer->Print(variables_,
687 : "private com.google.protobuf.SingleFieldBuilder<\n"
688 : " $type$, $type$.Builder, $type$OrBuilder> \n"
689 : " get$capitalized_name$FieldBuilder() {\n"
690 : " if ($name$Builder_ == null) {\n"
691 : " if (!($has_oneof_case_message$)) {\n"
692 : " $oneof_name$_ = $type$.getDefaultInstance();\n"
693 : " }\n"
694 : " $name$Builder_ = new com.google.protobuf.SingleFieldBuilder<\n"
695 : " $type$, $type$.Builder, $type$OrBuilder>(\n"
696 : " ($type$) $oneof_name$_,\n"
697 : " getParentForChildren(),\n"
698 : " isClean());\n"
699 : " $oneof_name$_ = null;\n"
700 : " }\n"
701 : " $set_oneof_case_message$;\n"
702 : " $on_changed$;\n"
703 : " return $name$Builder_;\n"
704 0 : "}\n");
705 0 : }
706 :
707 0 : void ImmutableMessageOneofFieldGenerator::
708 : GenerateBuildingCode(io::Printer* printer) const {
709 :
710 : printer->Print(variables_,
711 0 : "if ($has_oneof_case_message$) {\n");
712 0 : printer->Indent();
713 :
714 : PrintNestedBuilderCondition(printer,
715 : "result.$oneof_name$_ = $oneof_name$_;\n",
716 :
717 0 : "result.$oneof_name$_ = $name$Builder_.build();\n");
718 :
719 0 : printer->Outdent();
720 0 : printer->Print("}\n");
721 0 : }
722 :
723 0 : void ImmutableMessageOneofFieldGenerator::
724 : GenerateMergingCode(io::Printer* printer) const {
725 : printer->Print(variables_,
726 0 : "merge$capitalized_name$(other.get$capitalized_name$());\n");
727 0 : }
728 :
729 0 : void ImmutableMessageOneofFieldGenerator::
730 : GenerateParsingCode(io::Printer* printer) const {
731 : printer->Print(variables_,
732 : "$type$.Builder subBuilder = null;\n"
733 : "if ($has_oneof_case_message$) {\n"
734 : " subBuilder = (($type$) $oneof_name$_).toBuilder();\n"
735 0 : "}\n");
736 :
737 0 : if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
738 : printer->Print(variables_,
739 : "$oneof_name$_ = input.readGroup($number$, $type$.parser(),\n"
740 0 : " extensionRegistry);\n");
741 : } else {
742 : printer->Print(variables_,
743 : "$oneof_name$_ =\n"
744 0 : " input.readMessage($type$.parser(), extensionRegistry);\n");
745 : }
746 :
747 : printer->Print(variables_,
748 : "if (subBuilder != null) {\n"
749 : " subBuilder.mergeFrom(($type$) $oneof_name$_);\n"
750 : " $oneof_name$_ = subBuilder.buildPartial();\n"
751 0 : "}\n");
752 : printer->Print(variables_,
753 0 : "$set_oneof_case_message$;\n");
754 0 : }
755 :
756 0 : void ImmutableMessageOneofFieldGenerator::
757 : GenerateSerializationCode(io::Printer* printer) const {
758 : printer->Print(variables_,
759 : "if ($has_oneof_case_message$) {\n"
760 : " output.write$group_or_message$($number$, ($type$) $oneof_name$_);\n"
761 0 : "}\n");
762 0 : }
763 :
764 0 : void ImmutableMessageOneofFieldGenerator::
765 : GenerateSerializedSizeCode(io::Printer* printer) const {
766 : printer->Print(variables_,
767 : "if ($has_oneof_case_message$) {\n"
768 : " size += com.google.protobuf.CodedOutputStream\n"
769 : " .compute$group_or_message$Size($number$, ($type$) $oneof_name$_);\n"
770 0 : "}\n");
771 0 : }
772 :
773 : // ===================================================================
774 :
775 0 : RepeatedImmutableMessageFieldGenerator::
776 : RepeatedImmutableMessageFieldGenerator(const FieldDescriptor* descriptor,
777 : int messageBitIndex,
778 : int builderBitIndex,
779 : Context* context)
780 : : descriptor_(descriptor), messageBitIndex_(messageBitIndex),
781 : builderBitIndex_(builderBitIndex), context_(context),
782 0 : name_resolver_(context->GetNameResolver()) {
783 : SetMessageVariables(descriptor, messageBitIndex, builderBitIndex,
784 : context->GetFieldGeneratorInfo(descriptor),
785 0 : name_resolver_, &variables_);
786 0 : }
787 :
788 0 : RepeatedImmutableMessageFieldGenerator::
789 0 : ~RepeatedImmutableMessageFieldGenerator() {}
790 :
791 0 : int RepeatedImmutableMessageFieldGenerator::GetNumBitsForMessage() const {
792 0 : return 0;
793 : }
794 :
795 0 : int RepeatedImmutableMessageFieldGenerator::GetNumBitsForBuilder() const {
796 0 : return 1;
797 : }
798 :
799 0 : void RepeatedImmutableMessageFieldGenerator::
800 : GenerateInterfaceMembers(io::Printer* printer) const {
801 : // TODO(jonp): In the future, consider having methods specific to the
802 : // interface so that builders can choose dynamically to either return a
803 : // message or a nested builder, so that asking for the interface doesn't
804 : // cause a message to ever be built.
805 0 : WriteFieldDocComment(printer, descriptor_);
806 : printer->Print(variables_,
807 : "$deprecation$java.util.List<$type$> \n"
808 0 : " get$capitalized_name$List();\n");
809 0 : WriteFieldDocComment(printer, descriptor_);
810 : printer->Print(variables_,
811 0 : "$deprecation$$type$ get$capitalized_name$(int index);\n");
812 0 : WriteFieldDocComment(printer, descriptor_);
813 : printer->Print(variables_,
814 0 : "$deprecation$int get$capitalized_name$Count();\n");
815 :
816 0 : WriteFieldDocComment(printer, descriptor_);
817 : printer->Print(variables_,
818 : "$deprecation$java.util.List<? extends $type$OrBuilder> \n"
819 0 : " get$capitalized_name$OrBuilderList();\n");
820 0 : WriteFieldDocComment(printer, descriptor_);
821 : printer->Print(variables_,
822 : "$deprecation$$type$OrBuilder get$capitalized_name$OrBuilder(\n"
823 0 : " int index);\n");
824 0 : }
825 :
826 0 : void RepeatedImmutableMessageFieldGenerator::
827 : GenerateMembers(io::Printer* printer) const {
828 : printer->Print(variables_,
829 0 : "private java.util.List<$type$> $name$_;\n");
830 0 : PrintExtraFieldInfo(variables_, printer);
831 0 : WriteFieldDocComment(printer, descriptor_);
832 : printer->Print(variables_,
833 : "$deprecation$public java.util.List<$type$> get$capitalized_name$List() {\n"
834 : " return $name$_;\n" // note: unmodifiable list
835 0 : "}\n");
836 0 : WriteFieldDocComment(printer, descriptor_);
837 : printer->Print(variables_,
838 : "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
839 : " get$capitalized_name$OrBuilderList() {\n"
840 : " return $name$_;\n"
841 0 : "}\n");
842 0 : WriteFieldDocComment(printer, descriptor_);
843 : printer->Print(variables_,
844 : "$deprecation$public int get$capitalized_name$Count() {\n"
845 : " return $name$_.size();\n"
846 0 : "}\n");
847 0 : WriteFieldDocComment(printer, descriptor_);
848 : printer->Print(variables_,
849 : "$deprecation$public $type$ get$capitalized_name$(int index) {\n"
850 : " return $name$_.get(index);\n"
851 0 : "}\n");
852 0 : WriteFieldDocComment(printer, descriptor_);
853 : printer->Print(variables_,
854 : "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
855 : " int index) {\n"
856 : " return $name$_.get(index);\n"
857 0 : "}\n");
858 :
859 0 : }
860 :
861 0 : void RepeatedImmutableMessageFieldGenerator::PrintNestedBuilderCondition(
862 : io::Printer* printer,
863 : const char* regular_case,
864 : const char* nested_builder_case) const {
865 0 : printer->Print(variables_, "if ($name$Builder_ == null) {\n");
866 0 : printer->Indent();
867 0 : printer->Print(variables_, regular_case);
868 0 : printer->Outdent();
869 0 : printer->Print("} else {\n");
870 0 : printer->Indent();
871 0 : printer->Print(variables_, nested_builder_case);
872 0 : printer->Outdent();
873 0 : printer->Print("}\n");
874 0 : }
875 :
876 0 : void RepeatedImmutableMessageFieldGenerator::PrintNestedBuilderFunction(
877 : io::Printer* printer,
878 : const char* method_prototype,
879 : const char* regular_case,
880 : const char* nested_builder_case,
881 : const char* trailing_code) const {
882 0 : printer->Print(variables_, method_prototype);
883 0 : printer->Print(" {\n");
884 0 : printer->Indent();
885 0 : PrintNestedBuilderCondition(printer, regular_case, nested_builder_case);
886 0 : if (trailing_code != NULL) {
887 0 : printer->Print(variables_, trailing_code);
888 : }
889 0 : printer->Outdent();
890 0 : printer->Print("}\n");
891 0 : }
892 :
893 0 : void RepeatedImmutableMessageFieldGenerator::
894 : GenerateBuilderMembers(io::Printer* printer) const {
895 : // When using nested-builders, the code initially works just like the
896 : // non-nested builder case. It only creates a nested builder lazily on
897 : // demand and then forever delegates to it after creation.
898 :
899 : printer->Print(variables_,
900 : // Used when the builder is null.
901 : // One field is the list and the other field keeps track of whether the
902 : // list is immutable. If it's immutable, the invariant is that it must
903 : // either an instance of Collections.emptyList() or it's an ArrayList
904 : // wrapped in a Collections.unmodifiableList() wrapper and nobody else has
905 : // a refererence to the underlying ArrayList. This invariant allows us to
906 : // share instances of lists between protocol buffers avoiding expensive
907 : // memory allocations. Note, immutable is a strong guarantee here -- not
908 : // just that the list cannot be modified via the reference but that the
909 : // list can never be modified.
910 : "private java.util.List<$type$> $name$_ =\n"
911 : " java.util.Collections.emptyList();\n"
912 :
913 : "private void ensure$capitalized_name$IsMutable() {\n"
914 : " if (!$get_mutable_bit_builder$) {\n"
915 : " $name$_ = new java.util.ArrayList<$type$>($name$_);\n"
916 : " $set_mutable_bit_builder$;\n"
917 : " }\n"
918 : "}\n"
919 0 : "\n");
920 :
921 : printer->Print(variables_,
922 : // If this builder is non-null, it is used and the other fields are
923 : // ignored.
924 : "private com.google.protobuf.RepeatedFieldBuilder<\n"
925 : " $type$, $type$.Builder, $type$OrBuilder> $name$Builder_;\n"
926 0 : "\n");
927 :
928 : // The comments above the methods below are based on a hypothetical
929 : // repeated field of type "Field" called "RepeatedField".
930 :
931 : // List<Field> getRepeatedFieldList()
932 0 : WriteFieldDocComment(printer, descriptor_);
933 : PrintNestedBuilderFunction(printer,
934 : "$deprecation$public java.util.List<$type$> get$capitalized_name$List()",
935 :
936 : "return java.util.Collections.unmodifiableList($name$_);\n",
937 : "return $name$Builder_.getMessageList();\n",
938 :
939 0 : NULL);
940 :
941 : // int getRepeatedFieldCount()
942 0 : WriteFieldDocComment(printer, descriptor_);
943 : PrintNestedBuilderFunction(printer,
944 : "$deprecation$public int get$capitalized_name$Count()",
945 :
946 : "return $name$_.size();\n",
947 : "return $name$Builder_.getCount();\n",
948 :
949 0 : NULL);
950 :
951 : // Field getRepeatedField(int index)
952 0 : WriteFieldDocComment(printer, descriptor_);
953 : PrintNestedBuilderFunction(printer,
954 : "$deprecation$public $type$ get$capitalized_name$(int index)",
955 :
956 : "return $name$_.get(index);\n",
957 :
958 : "return $name$Builder_.getMessage(index);\n",
959 :
960 0 : NULL);
961 :
962 : // Builder setRepeatedField(int index, Field value)
963 0 : WriteFieldDocComment(printer, descriptor_);
964 : PrintNestedBuilderFunction(printer,
965 : "$deprecation$public Builder set$capitalized_name$(\n"
966 : " int index, $type$ value)",
967 : "if (value == null) {\n"
968 : " throw new NullPointerException();\n"
969 : "}\n"
970 : "ensure$capitalized_name$IsMutable();\n"
971 : "$name$_.set(index, value);\n"
972 : "$on_changed$\n",
973 : "$name$Builder_.setMessage(index, value);\n",
974 0 : "return this;\n");
975 :
976 : // Builder setRepeatedField(int index, Field.Builder builderForValue)
977 0 : WriteFieldDocComment(printer, descriptor_);
978 : PrintNestedBuilderFunction(printer,
979 : "$deprecation$public Builder set$capitalized_name$(\n"
980 : " int index, $type$.Builder builderForValue)",
981 :
982 : "ensure$capitalized_name$IsMutable();\n"
983 : "$name$_.set(index, builderForValue.build());\n"
984 : "$on_changed$\n",
985 :
986 : "$name$Builder_.setMessage(index, builderForValue.build());\n",
987 :
988 0 : "return this;\n");
989 :
990 : // Builder addRepeatedField(Field value)
991 0 : WriteFieldDocComment(printer, descriptor_);
992 : PrintNestedBuilderFunction(printer,
993 : "$deprecation$public Builder add$capitalized_name$($type$ value)",
994 :
995 : "if (value == null) {\n"
996 : " throw new NullPointerException();\n"
997 : "}\n"
998 : "ensure$capitalized_name$IsMutable();\n"
999 : "$name$_.add(value);\n"
1000 :
1001 : "$on_changed$\n",
1002 :
1003 : "$name$Builder_.addMessage(value);\n",
1004 :
1005 0 : "return this;\n");
1006 :
1007 : // Builder addRepeatedField(int index, Field value)
1008 0 : WriteFieldDocComment(printer, descriptor_);
1009 : PrintNestedBuilderFunction(printer,
1010 : "$deprecation$public Builder add$capitalized_name$(\n"
1011 : " int index, $type$ value)",
1012 :
1013 : "if (value == null) {\n"
1014 : " throw new NullPointerException();\n"
1015 : "}\n"
1016 : "ensure$capitalized_name$IsMutable();\n"
1017 : "$name$_.add(index, value);\n"
1018 : "$on_changed$\n",
1019 :
1020 : "$name$Builder_.addMessage(index, value);\n",
1021 :
1022 0 : "return this;\n");
1023 :
1024 : // Builder addRepeatedField(Field.Builder builderForValue)
1025 0 : WriteFieldDocComment(printer, descriptor_);
1026 : PrintNestedBuilderFunction(printer,
1027 : "$deprecation$public Builder add$capitalized_name$(\n"
1028 : " $type$.Builder builderForValue)",
1029 :
1030 : "ensure$capitalized_name$IsMutable();\n"
1031 : "$name$_.add(builderForValue.build());\n"
1032 : "$on_changed$\n",
1033 :
1034 : "$name$Builder_.addMessage(builderForValue.build());\n",
1035 :
1036 0 : "return this;\n");
1037 :
1038 : // Builder addRepeatedField(int index, Field.Builder builderForValue)
1039 0 : WriteFieldDocComment(printer, descriptor_);
1040 : PrintNestedBuilderFunction(printer,
1041 : "$deprecation$public Builder add$capitalized_name$(\n"
1042 : " int index, $type$.Builder builderForValue)",
1043 :
1044 : "ensure$capitalized_name$IsMutable();\n"
1045 : "$name$_.add(index, builderForValue.build());\n"
1046 : "$on_changed$\n",
1047 :
1048 : "$name$Builder_.addMessage(index, builderForValue.build());\n",
1049 :
1050 0 : "return this;\n");
1051 :
1052 : // Builder addAllRepeatedField(Iterable<Field> values)
1053 0 : WriteFieldDocComment(printer, descriptor_);
1054 : PrintNestedBuilderFunction(printer,
1055 : "$deprecation$public Builder addAll$capitalized_name$(\n"
1056 : " java.lang.Iterable<? extends $type$> values)",
1057 :
1058 : "ensure$capitalized_name$IsMutable();\n"
1059 : "com.google.protobuf.AbstractMessageLite.Builder.addAll(\n"
1060 : " values, $name$_);\n"
1061 : "$on_changed$\n",
1062 :
1063 : "$name$Builder_.addAllMessages(values);\n",
1064 :
1065 0 : "return this;\n");
1066 :
1067 : // Builder clearAllRepeatedField()
1068 0 : WriteFieldDocComment(printer, descriptor_);
1069 : PrintNestedBuilderFunction(printer,
1070 : "$deprecation$public Builder clear$capitalized_name$()",
1071 :
1072 : "$name$_ = java.util.Collections.emptyList();\n"
1073 : "$clear_mutable_bit_builder$;\n"
1074 : "$on_changed$\n",
1075 :
1076 : "$name$Builder_.clear();\n",
1077 :
1078 0 : "return this;\n");
1079 :
1080 : // Builder removeRepeatedField(int index)
1081 0 : WriteFieldDocComment(printer, descriptor_);
1082 : PrintNestedBuilderFunction(printer,
1083 : "$deprecation$public Builder remove$capitalized_name$(int index)",
1084 :
1085 : "ensure$capitalized_name$IsMutable();\n"
1086 : "$name$_.remove(index);\n"
1087 : "$on_changed$\n",
1088 :
1089 : "$name$Builder_.remove(index);\n",
1090 :
1091 0 : "return this;\n");
1092 :
1093 0 : WriteFieldDocComment(printer, descriptor_);
1094 : printer->Print(variables_,
1095 : "$deprecation$public $type$.Builder get$capitalized_name$Builder(\n"
1096 : " int index) {\n"
1097 : " return get$capitalized_name$FieldBuilder().getBuilder(index);\n"
1098 0 : "}\n");
1099 :
1100 0 : WriteFieldDocComment(printer, descriptor_);
1101 : printer->Print(variables_,
1102 : "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n"
1103 : " int index) {\n"
1104 : " if ($name$Builder_ == null) {\n"
1105 : " return $name$_.get(index);"
1106 : " } else {\n"
1107 : " return $name$Builder_.getMessageOrBuilder(index);\n"
1108 : " }\n"
1109 0 : "}\n");
1110 :
1111 0 : WriteFieldDocComment(printer, descriptor_);
1112 : printer->Print(variables_,
1113 : "$deprecation$public java.util.List<? extends $type$OrBuilder> \n"
1114 : " get$capitalized_name$OrBuilderList() {\n"
1115 : " if ($name$Builder_ != null) {\n"
1116 : " return $name$Builder_.getMessageOrBuilderList();\n"
1117 : " } else {\n"
1118 : " return java.util.Collections.unmodifiableList($name$_);\n"
1119 : " }\n"
1120 0 : "}\n");
1121 :
1122 0 : WriteFieldDocComment(printer, descriptor_);
1123 : printer->Print(variables_,
1124 : "$deprecation$public $type$.Builder add$capitalized_name$Builder() {\n"
1125 : " return get$capitalized_name$FieldBuilder().addBuilder(\n"
1126 : " $type$.getDefaultInstance());\n"
1127 0 : "}\n");
1128 0 : WriteFieldDocComment(printer, descriptor_);
1129 : printer->Print(variables_,
1130 : "$deprecation$public $type$.Builder add$capitalized_name$Builder(\n"
1131 : " int index) {\n"
1132 : " return get$capitalized_name$FieldBuilder().addBuilder(\n"
1133 : " index, $type$.getDefaultInstance());\n"
1134 0 : "}\n");
1135 0 : WriteFieldDocComment(printer, descriptor_);
1136 : printer->Print(variables_,
1137 : "$deprecation$public java.util.List<$type$.Builder> \n"
1138 : " get$capitalized_name$BuilderList() {\n"
1139 : " return get$capitalized_name$FieldBuilder().getBuilderList();\n"
1140 : "}\n"
1141 : "private com.google.protobuf.RepeatedFieldBuilder<\n"
1142 : " $type$, $type$.Builder, $type$OrBuilder> \n"
1143 : " get$capitalized_name$FieldBuilder() {\n"
1144 : " if ($name$Builder_ == null) {\n"
1145 : " $name$Builder_ = new com.google.protobuf.RepeatedFieldBuilder<\n"
1146 : " $type$, $type$.Builder, $type$OrBuilder>(\n"
1147 : " $name$_,\n"
1148 : " $get_mutable_bit_builder$,\n"
1149 : " getParentForChildren(),\n"
1150 : " isClean());\n"
1151 : " $name$_ = null;\n"
1152 : " }\n"
1153 : " return $name$Builder_;\n"
1154 0 : "}\n");
1155 0 : }
1156 :
1157 0 : void RepeatedImmutableMessageFieldGenerator::
1158 : GenerateFieldBuilderInitializationCode(io::Printer* printer) const {
1159 : printer->Print(variables_,
1160 0 : "get$capitalized_name$FieldBuilder();\n");
1161 0 : }
1162 :
1163 0 : void RepeatedImmutableMessageFieldGenerator::
1164 : GenerateInitializationCode(io::Printer* printer) const {
1165 0 : printer->Print(variables_, "$name$_ = java.util.Collections.emptyList();\n");
1166 0 : }
1167 :
1168 0 : void RepeatedImmutableMessageFieldGenerator::
1169 : GenerateBuilderClearCode(io::Printer* printer) const {
1170 : PrintNestedBuilderCondition(printer,
1171 : "$name$_ = java.util.Collections.emptyList();\n"
1172 : "$clear_mutable_bit_builder$;\n",
1173 :
1174 0 : "$name$Builder_.clear();\n");
1175 0 : }
1176 :
1177 0 : void RepeatedImmutableMessageFieldGenerator::
1178 : GenerateMergingCode(io::Printer* printer) const {
1179 : // The code below does two optimizations (non-nested builder case):
1180 : // 1. If the other list is empty, there's nothing to do. This ensures we
1181 : // don't allocate a new array if we already have an immutable one.
1182 : // 2. If the other list is non-empty and our current list is empty, we can
1183 : // reuse the other list which is guaranteed to be immutable.
1184 : PrintNestedBuilderCondition(printer,
1185 : "if (!other.$name$_.isEmpty()) {\n"
1186 : " if ($name$_.isEmpty()) {\n"
1187 : " $name$_ = other.$name$_;\n"
1188 : " $clear_mutable_bit_builder$;\n"
1189 : " } else {\n"
1190 : " ensure$capitalized_name$IsMutable();\n"
1191 : " $name$_.addAll(other.$name$_);\n"
1192 : " }\n"
1193 : " $on_changed$\n"
1194 : "}\n",
1195 :
1196 : "if (!other.$name$_.isEmpty()) {\n"
1197 : " if ($name$Builder_.isEmpty()) {\n"
1198 : " $name$Builder_.dispose();\n"
1199 : " $name$Builder_ = null;\n"
1200 : " $name$_ = other.$name$_;\n"
1201 : " $clear_mutable_bit_builder$;\n"
1202 : " $name$Builder_ = \n"
1203 : " com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?\n"
1204 : " get$capitalized_name$FieldBuilder() : null;\n"
1205 : " } else {\n"
1206 : " $name$Builder_.addAllMessages(other.$name$_);\n"
1207 : " }\n"
1208 0 : "}\n");
1209 0 : }
1210 :
1211 0 : void RepeatedImmutableMessageFieldGenerator::
1212 : GenerateBuildingCode(io::Printer* printer) const {
1213 : // The code below (non-nested builder case) ensures that the result has an
1214 : // immutable list. If our list is immutable, we can just reuse it. If not,
1215 : // we make it immutable.
1216 : PrintNestedBuilderCondition(printer,
1217 : "if ($get_mutable_bit_builder$) {\n"
1218 : " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
1219 : " $clear_mutable_bit_builder$;\n"
1220 : "}\n"
1221 : "result.$name$_ = $name$_;\n",
1222 :
1223 0 : "result.$name$_ = $name$Builder_.build();\n");
1224 0 : }
1225 :
1226 0 : void RepeatedImmutableMessageFieldGenerator::
1227 : GenerateParsingCode(io::Printer* printer) const {
1228 : printer->Print(variables_,
1229 : "if (!$get_mutable_bit_parser$) {\n"
1230 : " $name$_ = new java.util.ArrayList<$type$>();\n"
1231 : " $set_mutable_bit_parser$;\n"
1232 0 : "}\n");
1233 :
1234 0 : if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
1235 : printer->Print(variables_,
1236 : "$name$_.add(input.readGroup($number$, $type$.parser(),\n"
1237 0 : " extensionRegistry));\n");
1238 : } else {
1239 : printer->Print(variables_,
1240 0 : "$name$_.add(input.readMessage($type$.parser(), extensionRegistry));\n");
1241 : }
1242 0 : }
1243 :
1244 0 : void RepeatedImmutableMessageFieldGenerator::
1245 : GenerateParsingDoneCode(io::Printer* printer) const {
1246 : printer->Print(variables_,
1247 : "if ($get_mutable_bit_parser$) {\n"
1248 : " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
1249 0 : "}\n");
1250 0 : }
1251 :
1252 0 : void RepeatedImmutableMessageFieldGenerator::
1253 : GenerateSerializationCode(io::Printer* printer) const {
1254 : printer->Print(variables_,
1255 : "for (int i = 0; i < $name$_.size(); i++) {\n"
1256 : " output.write$group_or_message$($number$, $name$_.get(i));\n"
1257 0 : "}\n");
1258 0 : }
1259 :
1260 0 : void RepeatedImmutableMessageFieldGenerator::
1261 : GenerateSerializedSizeCode(io::Printer* printer) const {
1262 : printer->Print(variables_,
1263 : "for (int i = 0; i < $name$_.size(); i++) {\n"
1264 : " size += com.google.protobuf.CodedOutputStream\n"
1265 : " .compute$group_or_message$Size($number$, $name$_.get(i));\n"
1266 0 : "}\n");
1267 0 : }
1268 :
1269 0 : void RepeatedImmutableMessageFieldGenerator::
1270 : GenerateEqualsCode(io::Printer* printer) const {
1271 : printer->Print(variables_,
1272 : "result = result && get$capitalized_name$List()\n"
1273 0 : " .equals(other.get$capitalized_name$List());\n");
1274 0 : }
1275 :
1276 0 : void RepeatedImmutableMessageFieldGenerator::
1277 : GenerateHashCode(io::Printer* printer) const {
1278 : printer->Print(variables_,
1279 : "if (get$capitalized_name$Count() > 0) {\n"
1280 : " hash = (37 * hash) + $constant_name$;\n"
1281 : " hash = (53 * hash) + get$capitalized_name$List().hashCode();\n"
1282 0 : "}\n");
1283 0 : }
1284 :
1285 0 : string RepeatedImmutableMessageFieldGenerator::GetBoxedType() const {
1286 0 : return name_resolver_->GetImmutableClassName(descriptor_->message_type());
1287 : }
1288 :
1289 : } // namespace java
1290 : } // namespace compiler
1291 : } // namespace protobuf
1292 : } // namespace google
|
