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_lite.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 46ImmutableLazyMessageFieldLiteGenerator:: 47ImmutableLazyMessageFieldLiteGenerator( 48 const FieldDescriptor* descriptor, 49 int messageBitIndex, 50 int builderBitIndex, 51 Context* context) 52 : ImmutableMessageFieldLiteGenerator( 53 descriptor, messageBitIndex, builderBitIndex, context) { 54} 55 56ImmutableLazyMessageFieldLiteGenerator:: 57~ImmutableLazyMessageFieldLiteGenerator() {} 58 59void ImmutableLazyMessageFieldLiteGenerator:: 60GenerateMembers(io::Printer* printer) const { 61 printer->Print(variables_, 62 "private com.google.protobuf.LazyFieldLite $name$_ =\n" 63 " new com.google.protobuf.LazyFieldLite();\n"); 64 65 PrintExtraFieldInfo(variables_, printer); 66 WriteFieldDocComment(printer, descriptor_); 67 printer->Print(variables_, 68 "$deprecation$public boolean has$capitalized_name$() {\n" 69 " return $get_has_field_bit_message$;\n" 70 "}\n"); 71 72 WriteFieldDocComment(printer, descriptor_); 73 printer->Print(variables_, 74 "$deprecation$public $type$ get$capitalized_name$() {\n" 75 " return ($type$) $name$_.getValue($type$.getDefaultInstance());\n" 76 "}\n"); 77 78 // Field.Builder setField(Field value) 79 WriteFieldDocComment(printer, descriptor_); 80 printer->Print(variables_, 81 "private void set$capitalized_name$($type$ value) {\n" 82 " if (value == null) {\n" 83 " throw new NullPointerException();\n" 84 " }\n" 85 " $name$_.setValue(value);\n" 86 " $set_has_field_bit_message$;\n" 87 "}\n"); 88 89 // Field.Builder setField(Field.Builder builderForValue) 90 WriteFieldDocComment(printer, descriptor_); 91 printer->Print(variables_, 92 "private void set$capitalized_name$(\n" 93 " $type$.Builder builderForValue) {\n" 94 " $name$_.setValue(builderForValue.build());\n" 95 " $set_has_field_bit_message$;\n" 96 "}\n"); 97 98 // Field.Builder mergeField(Field value) 99 WriteFieldDocComment(printer, descriptor_); 100 printer->Print(variables_, 101 "private void merge$capitalized_name$($type$ value) {\n" 102 " if ($get_has_field_bit_message$ &&\n" 103 " !$name$_.containsDefaultInstance()) {\n" 104 " $name$_.setValue(\n" 105 " $type$.newBuilder(\n" 106 " get$capitalized_name$()).mergeFrom(value).buildPartial());\n" 107 " } else {\n" 108 " $name$_.setValue(value);\n" 109 " }\n" 110 " $set_has_field_bit_message$;\n" 111 "}\n"); 112 113 // Field.Builder clearField() 114 WriteFieldDocComment(printer, descriptor_); 115 printer->Print(variables_, 116 "private void clear$capitalized_name$() {\n" 117 " $name$_.clear();\n" 118 " $clear_has_field_bit_message$;\n" 119 "}\n"); 120} 121 122void ImmutableLazyMessageFieldLiteGenerator:: 123GenerateBuilderMembers(io::Printer* printer) const { 124 // The comments above the methods below are based on a hypothetical 125 // field of type "Field" called "Field". 126 127 // boolean hasField() 128 WriteFieldDocComment(printer, descriptor_); 129 printer->Print(variables_, 130 "$deprecation$public boolean has$capitalized_name$() {\n" 131 " return instance.has$capitalized_name$();\n" 132 "}\n"); 133 134 WriteFieldDocComment(printer, descriptor_); 135 printer->Print(variables_, 136 "$deprecation$public $type$ get$capitalized_name$() {\n" 137 " return instance.get$capitalized_name$();\n" 138 "}\n"); 139 140 // Field.Builder setField(Field value) 141 WriteFieldDocComment(printer, descriptor_); 142 printer->Print(variables_, 143 "$deprecation$public Builder set$capitalized_name$($type$ value) {\n" 144 " copyOnWrite();\n" 145 " instance.set$capitalized_name$(value);\n" 146 " return this;\n" 147 "}\n"); 148 149 // Field.Builder setField(Field.Builder builderForValue) 150 WriteFieldDocComment(printer, descriptor_); 151 printer->Print(variables_, 152 "$deprecation$public Builder set$capitalized_name$(\n" 153 " $type$.Builder builderForValue) {\n" 154 " copyOnWrite();\n" 155 " instance.set$capitalized_name$(builderForValue);\n" 156 " return this;\n" 157 "}\n"); 158 159 // Field.Builder mergeField(Field value) 160 WriteFieldDocComment(printer, descriptor_); 161 printer->Print(variables_, 162 "$deprecation$public Builder merge$capitalized_name$($type$ value) {\n" 163 " copyOnWrite();\n" 164 " instance.merge$capitalized_name$(value);\n" 165 " return this;\n" 166 "}\n"); 167 168 // Field.Builder clearField() 169 WriteFieldDocComment(printer, descriptor_); 170 printer->Print(variables_, 171 "$deprecation$public Builder clear$capitalized_name$() {\n" 172 " copyOnWrite();\n" 173 " instance.clear$capitalized_name$();\n" 174 " return this;\n" 175 "}\n"); 176} 177 178 179void ImmutableLazyMessageFieldLiteGenerator:: 180GenerateInitializationCode(io::Printer* printer) const { 181 printer->Print(variables_, "$name$_.clear();\n"); 182} 183 184void ImmutableLazyMessageFieldLiteGenerator:: 185GenerateVisitCode(io::Printer* printer) const { 186 printer->Print(variables_, 187 "$name$_ = visitor.visitLazyMessage(\n" 188 " has$capitalized_name$(), $name$_,\n" 189 " other.has$capitalized_name$(), other.$name$_);\n"); 190} 191 192void ImmutableLazyMessageFieldLiteGenerator:: 193GenerateParsingCode(io::Printer* printer) const { 194 printer->Print(variables_, 195 "$name$_.mergeFrom(input, extensionRegistry);\n"); 196 printer->Print(variables_, 197 "$set_has_field_bit_message$;\n"); 198} 199 200void ImmutableLazyMessageFieldLiteGenerator:: 201GenerateSerializationCode(io::Printer* printer) const { 202 // Do not de-serialize lazy fields. 203 printer->Print(variables_, 204 "if ($get_has_field_bit_message$) {\n" 205 " output.writeBytes($number$, $name$_.toByteString());\n" 206 "}\n"); 207} 208 209void ImmutableLazyMessageFieldLiteGenerator:: 210GenerateSerializedSizeCode(io::Printer* printer) const { 211 printer->Print(variables_, 212 "if ($get_has_field_bit_message$) {\n" 213 " size += com.google.protobuf.CodedOutputStream\n" 214 " .computeLazyFieldSize($number$, $name$_);\n" 215 "}\n"); 216} 217 218// =================================================================== 219 220ImmutableLazyMessageOneofFieldLiteGenerator:: 221ImmutableLazyMessageOneofFieldLiteGenerator(const FieldDescriptor* descriptor, 222 int messageBitIndex, 223 int builderBitIndex, 224 Context* context) 225 : ImmutableLazyMessageFieldLiteGenerator( 226 descriptor, messageBitIndex, builderBitIndex, context) { 227 const OneofGeneratorInfo* info = 228 context->GetOneofGeneratorInfo(descriptor->containing_oneof()); 229 SetCommonOneofVariables(descriptor, info, &variables_); 230 variables_["lazy_type"] = "com.google.protobuf.LazyFieldLite"; 231} 232 233ImmutableLazyMessageOneofFieldLiteGenerator:: 234~ImmutableLazyMessageOneofFieldLiteGenerator() {} 235 236void ImmutableLazyMessageOneofFieldLiteGenerator:: 237GenerateMembers(io::Printer* printer) const { 238 PrintExtraFieldInfo(variables_, printer); 239 WriteFieldDocComment(printer, descriptor_); 240 241 printer->Print(variables_, 242 "$deprecation$public boolean has$capitalized_name$() {\n" 243 " return $has_oneof_case_message$;\n" 244 "}\n"); 245 WriteFieldDocComment(printer, descriptor_); 246 247 printer->Print(variables_, 248 "$deprecation$public $type$ get$capitalized_name$() {\n" 249 " if ($has_oneof_case_message$) {\n" 250 " return ($type$) (($lazy_type$) $oneof_name$_).getValue(\n" 251 " $type$.getDefaultInstance());\n" 252 " }\n" 253 " return $type$.getDefaultInstance();\n" 254 "}\n"); 255 256 // Field.Builder setField(Field value) 257 WriteFieldDocComment(printer, descriptor_); 258 printer->Print(variables_, 259 "private void set$capitalized_name$($type$ value) {\n" 260 " if (value == null) {\n" 261 " throw new NullPointerException();\n" 262 " }\n" 263 " if (!($has_oneof_case_message$)) {\n" 264 " $oneof_name$_ = new $lazy_type$();\n" 265 " $set_oneof_case_message$;\n" 266 " }\n" 267 " (($lazy_type$) $oneof_name$_).setValue(value);\n" 268 "}\n"); 269 270 // Field.Builder setField(Field.Builder builderForValue) 271 WriteFieldDocComment(printer, descriptor_); 272 printer->Print(variables_, 273 "private void set$capitalized_name$(\n" 274 " $type$.Builder builderForValue) {\n" 275 " if (!($has_oneof_case_message$)) {\n" 276 " $oneof_name$_ = new $lazy_type$();\n" 277 " $set_oneof_case_message$;\n" 278 " }\n" 279 " (($lazy_type$) $oneof_name$_).setValue(builderForValue.build());\n" 280 "}\n"); 281 282 // Field.Builder mergeField(Field value) 283 WriteFieldDocComment(printer, descriptor_); 284 printer->Print(variables_, 285 "private void merge$capitalized_name$($type$ value) {\n" 286 " if ($has_oneof_case_message$ &&\n" 287 " !(($lazy_type$) $oneof_name$_).containsDefaultInstance()) {\n" 288 " (($lazy_type$) $oneof_name$_).setValue(\n" 289 " $type$.newBuilder(\n" 290 " get$capitalized_name$()).mergeFrom(value).buildPartial());\n" 291 " } else {\n" 292 " if (!($has_oneof_case_message$)) {\n" 293 " $oneof_name$_ = new $lazy_type$();\n" 294 " $set_oneof_case_message$;\n" 295 " }\n" 296 " (($lazy_type$) $oneof_name$_).setValue(value);\n" 297 " }\n" 298 "}\n"); 299 300 // Field.Builder clearField() 301 WriteFieldDocComment(printer, descriptor_); 302 printer->Print(variables_, 303 "private void clear$capitalized_name$() {\n" 304 " if ($has_oneof_case_message$) {\n" 305 " $clear_oneof_case_message$;\n" 306 " $oneof_name$_ = null;\n" 307 " }\n" 308 "}\n"); 309} 310 311void ImmutableLazyMessageOneofFieldLiteGenerator:: 312GenerateBuilderMembers(io::Printer* printer) const { 313 // boolean hasField() 314 WriteFieldDocComment(printer, descriptor_); 315 printer->Print(variables_, 316 "$deprecation$public boolean has$capitalized_name$() {\n" 317 " return instance.has$capitalized_name$();\n" 318 "}\n"); 319 320 printer->Print(variables_, 321 "$deprecation$public $type$ get$capitalized_name$() {\n" 322 " return instance.get$capitalized_name$();\n" 323 "}\n"); 324 325 // Field.Builder setField(Field value) 326 WriteFieldDocComment(printer, descriptor_); 327 printer->Print(variables_, 328 "$deprecation$public Builder set$capitalized_name$($type$ value) {\n" 329 " copyOnWrite();\n" 330 " instance.set$capitalized_name$(value);\n" 331 " return this;\n" 332 "}\n"); 333 334 // Field.Builder setField(Field.Builder builderForValue) 335 WriteFieldDocComment(printer, descriptor_); 336 printer->Print(variables_, 337 "$deprecation$public Builder set$capitalized_name$(\n" 338 " $type$.Builder builderForValue) {\n" 339 " copyOnWrite();\n" 340 " instance.set$capitalized_name$(builderForValue);\n" 341 " return this;\n" 342 "}\n"); 343 344 // Field.Builder mergeField(Field value) 345 WriteFieldDocComment(printer, descriptor_); 346 printer->Print(variables_, 347 "$deprecation$public Builder merge$capitalized_name$($type$ value) {\n" 348 " copyOnWrite();\n" 349 " instance.merge$capitalized_name$(value);\n" 350 " return this;\n" 351 "}\n"); 352 353 // Field.Builder clearField() 354 WriteFieldDocComment(printer, descriptor_); 355 printer->Print(variables_, 356 "$deprecation$public Builder clear$capitalized_name$() {\n" 357 " copyOnWrite();\n" 358 " instance.clear$capitalized_name$();\n" 359 " return this;\n" 360 "}\n"); 361} 362 363void ImmutableLazyMessageOneofFieldLiteGenerator:: 364GenerateVisitCode(io::Printer* printer) const { 365 printer->Print(variables_, 366 "$oneof_name$_ = visitor.visitOneofLazyMessage(\n" 367 " $has_oneof_case_message$,\n" 368 " ($lazy_type$) $oneof_name$_,\n" 369 " ($lazy_type$) other.$oneof_name$_);\n"); 370} 371 372void ImmutableLazyMessageOneofFieldLiteGenerator:: 373GenerateParsingCode(io::Printer* printer) const { 374 printer->Print(variables_, 375 "if (!($has_oneof_case_message$)) {\n" 376 " $oneof_name$_ = new $lazy_type$();\n" 377 "}\n" 378 "(($lazy_type$) $oneof_name$_).mergeFrom(input, extensionRegistry);\n" 379 "$set_oneof_case_message$;\n"); 380} 381 382void ImmutableLazyMessageOneofFieldLiteGenerator:: 383GenerateSerializationCode(io::Printer* printer) const { 384 // Do not de-serialize lazy fields. 385 printer->Print(variables_, 386 "if ($has_oneof_case_message$) {\n" 387 " output.writeBytes(\n" 388 " $number$, (($lazy_type$) $oneof_name$_).toByteString());\n" 389 "}\n"); 390} 391 392void ImmutableLazyMessageOneofFieldLiteGenerator:: 393GenerateSerializedSizeCode(io::Printer* printer) const { 394 printer->Print(variables_, 395 "if ($has_oneof_case_message$) {\n" 396 " size += com.google.protobuf.CodedOutputStream\n" 397 " .computeLazyFieldSize($number$, ($lazy_type$) $oneof_name$_);\n" 398 "}\n"); 399} 400 401// =================================================================== 402 403RepeatedImmutableLazyMessageFieldLiteGenerator:: 404RepeatedImmutableLazyMessageFieldLiteGenerator( 405 const FieldDescriptor* descriptor, 406 int messageBitIndex, 407 int builderBitIndex, 408 Context* context) 409 : RepeatedImmutableMessageFieldLiteGenerator( 410 descriptor, messageBitIndex, builderBitIndex, context) { 411} 412 413 414RepeatedImmutableLazyMessageFieldLiteGenerator:: 415~RepeatedImmutableLazyMessageFieldLiteGenerator() {} 416 417void RepeatedImmutableLazyMessageFieldLiteGenerator:: 418GenerateMembers(io::Printer* printer) const { 419 printer->Print(variables_, 420 "private com.google.protobuf.Internal.ProtobufList<\n" 421 " com.google.protobuf.LazyFieldLite> $name$_;\n"); 422 PrintExtraFieldInfo(variables_, printer); 423 WriteFieldDocComment(printer, descriptor_); 424 printer->Print(variables_, 425 "$deprecation$public java.util.List<$type$>\n" 426 " get$capitalized_name$List() {\n" 427 " java.util.List<$type$> list =\n" 428 " new java.util.ArrayList<$type$>($name$_.size());\n" 429 " for (com.google.protobuf.LazyFieldLite lf : $name$_) {\n" 430 " list.add(($type$) lf.getValue($type$.getDefaultInstance()));\n" 431 " }\n" 432 // TODO(dweis): Make this list immutable? 433 " return list;\n" 434 "}\n"); 435 WriteFieldDocComment(printer, descriptor_); 436 printer->Print(variables_, 437 "$deprecation$public java.util.List<? extends $type$OrBuilder>\n" 438 " get$capitalized_name$OrBuilderList() {\n" 439 " return get$capitalized_name$List();\n" 440 "}\n"); 441 WriteFieldDocComment(printer, descriptor_); 442 printer->Print(variables_, 443 "$deprecation$public int get$capitalized_name$Count() {\n" 444 " return $name$_.size();\n" 445 "}\n"); 446 WriteFieldDocComment(printer, descriptor_); 447 printer->Print(variables_, 448 "$deprecation$public $type$ get$capitalized_name$(int index) {\n" 449 " return ($type$)\n" 450 " $name$_.get(index).getValue($type$.getDefaultInstance());\n" 451 "}\n"); 452 WriteFieldDocComment(printer, descriptor_); 453 printer->Print(variables_, 454 "$deprecation$public $type$OrBuilder get$capitalized_name$OrBuilder(\n" 455 " int index) {\n" 456 " return ($type$OrBuilder)\n" 457 " $name$_.get(index).getValue($type$.getDefaultInstance());\n" 458 "}\n"); 459 460 printer->Print(variables_, 461 "private void ensure$capitalized_name$IsMutable() {\n" 462 " if (!$is_mutable$) {\n" 463 " $name$_ =\n" 464 " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n" 465 " }\n" 466 "}\n" 467 "\n"); 468 469 // Builder setRepeatedField(int index, Field value) 470 WriteFieldDocComment(printer, descriptor_); 471 printer->Print(variables_, 472 "private void set$capitalized_name$(\n" 473 " int index, $type$ value) {\n" 474 " if (value == null) {\n" 475 " throw new NullPointerException();\n" 476 " }\n" 477 " ensure$capitalized_name$IsMutable();\n" 478 " $name$_.set(\n" 479 " index, com.google.protobuf.LazyFieldLite.fromValue(value));\n" 480 "}\n"); 481 482 // Builder setRepeatedField(int index, Field.Builder builderForValue) 483 WriteFieldDocComment(printer, descriptor_); 484 printer->Print(variables_, 485 "private void set$capitalized_name$(\n" 486 " int index, $type$.Builder builderForValue) {\n" 487 " ensure$capitalized_name$IsMutable();\n" 488 " $name$_.set(index, com.google.protobuf.LazyFieldLite.fromValue(\n" 489 " builderForValue.build()));\n" 490 "}\n"); 491 492 // Builder addRepeatedField(Field value) 493 WriteFieldDocComment(printer, descriptor_); 494 printer->Print(variables_, 495 "private void add$capitalized_name$($type$ value) {\n" 496 " if (value == null) {\n" 497 " throw new NullPointerException();\n" 498 " }\n" 499 " ensure$capitalized_name$IsMutable();\n" 500 " $name$_.add(com.google.protobuf.LazyFieldLite.fromValue(value));\n" 501 "}\n"); 502 503 // Builder addRepeatedField(int index, Field value) 504 WriteFieldDocComment(printer, descriptor_); 505 printer->Print(variables_, 506 "private void add$capitalized_name$(\n" 507 " int index, $type$ value) {\n" 508 " if (value == null) {\n" 509 " throw new NullPointerException();\n" 510 " }\n" 511 " ensure$capitalized_name$IsMutable();\n" 512 " $name$_.add(\n" 513 " index, com.google.protobuf.LazyFieldLite.fromValue(value));\n" 514 "}\n"); 515 516 // Builder addRepeatedField(Field.Builder builderForValue) 517 WriteFieldDocComment(printer, descriptor_); 518 printer->Print(variables_, 519 "private void add$capitalized_name$(\n" 520 " $type$.Builder builderForValue) {\n" 521 " ensure$capitalized_name$IsMutable();\n" 522 " $name$_.add(com.google.protobuf.LazyFieldLite.fromValue(\n" 523 " builderForValue.build()));\n" 524 "}\n"); 525 526 // Builder addRepeatedField(int index, Field.Builder builderForValue) 527 WriteFieldDocComment(printer, descriptor_); 528 printer->Print(variables_, 529 "private void add$capitalized_name$(\n" 530 " int index, $type$.Builder builderForValue) {\n" 531 " ensure$capitalized_name$IsMutable();\n" 532 " $name$_.add(index, com.google.protobuf.LazyFieldLite.fromValue(\n" 533 " builderForValue.build()));\n" 534 "}\n"); 535 536 // Builder addAllRepeatedField(Iterable<Field> values) 537 WriteFieldDocComment(printer, descriptor_); 538 printer->Print(variables_, 539 "private void addAll$capitalized_name$(\n" 540 " java.lang.Iterable<? extends $type$> values) {\n" 541 " ensure$capitalized_name$IsMutable();\n" 542 " for (com.google.protobuf.MessageLite v : values) {\n" 543 " $name$_.add(com.google.protobuf.LazyFieldLite.fromValue(v));\n" 544 " }\n" 545 "}\n"); 546 547 // Builder clearAllRepeatedField() 548 WriteFieldDocComment(printer, descriptor_); 549 printer->Print(variables_, 550 "private void clear$capitalized_name$() {\n" 551 " $name$_ = emptyProtobufList();\n" 552 "}\n"); 553 554 // Builder removeRepeatedField(int index) 555 WriteFieldDocComment(printer, descriptor_); 556 printer->Print(variables_, 557 "private void remove$capitalized_name$(int index) {\n" 558 " ensure$capitalized_name$IsMutable();\n" 559 " $name$_.remove(index);\n" 560 "}\n"); 561} 562 563void RepeatedImmutableLazyMessageFieldLiteGenerator:: 564GenerateBuilderMembers(io::Printer* printer) const { 565 // List<Field> getRepeatedFieldList() 566 WriteFieldDocComment(printer, descriptor_); 567 printer->Print(variables_, 568 "$deprecation$public java.util.List<$type$> get$capitalized_name$List() {\n" 569 " return java.util.Collections.unmodifiableList(\n" 570 " instance.get$capitalized_name$List());\n" 571 "}\n"); 572 573 // int getRepeatedFieldCount() 574 WriteFieldDocComment(printer, descriptor_); 575 printer->Print(variables_, 576 "$deprecation$public int get$capitalized_name$Count() {\n" 577 " return instance.get$capitalized_name$Count();\n" 578 "}\n"); 579 580 // Field getRepeatedField(int index) 581 WriteFieldDocComment(printer, descriptor_); 582 printer->Print(variables_, 583 "$deprecation$public $type$ get$capitalized_name$(int index) {\n" 584 " return instance.get$capitalized_name$(index);\n" 585 "}\n"); 586 587 // Builder setRepeatedField(int index, Field value) 588 WriteFieldDocComment(printer, descriptor_); 589 printer->Print(variables_, 590 "$deprecation$public Builder set$capitalized_name$(\n" 591 " int index, $type$ value) {\n" 592 " copyOnWrite();\n" 593 " instance.set$capitalized_name$(index, value);\n" 594 " return this;\n" 595 "}\n"); 596 597 // Builder setRepeatedField(int index, Field.Builder builderForValue) 598 WriteFieldDocComment(printer, descriptor_); 599 printer->Print(variables_, 600 "$deprecation$public Builder set$capitalized_name$(\n" 601 " int index, $type$.Builder builderForValue) {\n" 602 " copyOnWrite();\n" 603 " instance.set$capitalized_name$(index, builderForValue);\n" 604 " return this;\n" 605 "}\n"); 606 607 // Builder addRepeatedField(Field value) 608 WriteFieldDocComment(printer, descriptor_); 609 printer->Print(variables_, 610 "$deprecation$public Builder add$capitalized_name$($type$ value) {\n" 611 " copyOnWrite();\n" 612 " instance.add$capitalized_name$(value);\n" 613 " return this;\n" 614 "}\n"); 615 616 // Builder addRepeatedField(int index, Field value) 617 WriteFieldDocComment(printer, descriptor_); 618 printer->Print(variables_, 619 "$deprecation$public Builder add$capitalized_name$(\n" 620 " int index, $type$ value) {\n" 621 " copyOnWrite();\n" 622 " instance.add$capitalized_name$(index, value);\n" 623 " return this;\n" 624 "}\n"); 625 626 // Builder addRepeatedField(Field.Builder builderForValue) 627 WriteFieldDocComment(printer, descriptor_); 628 printer->Print(variables_, 629 "$deprecation$public Builder add$capitalized_name$(\n" 630 " $type$.Builder builderForValue) {\n" 631 " copyOnWrite();\n" 632 " instance.add$capitalized_name$(builderForValue);\n" 633 " return this;\n" 634 "}\n"); 635 636 // Builder addRepeatedField(int index, Field.Builder builderForValue) 637 WriteFieldDocComment(printer, descriptor_); 638 printer->Print(variables_, 639 "$deprecation$public Builder add$capitalized_name$(\n" 640 " int index, $type$.Builder builderForValue) {\n" 641 " copyOnWrite();\n" 642 " instance.add$capitalized_name$(index, builderForValue);\n" 643 " return this;\n" 644 "}\n"); 645 646 // Builder addAllRepeatedField(Iterable<Field> values) 647 WriteFieldDocComment(printer, descriptor_); 648 printer->Print(variables_, 649 "$deprecation$public Builder addAll$capitalized_name$(\n" 650 " java.lang.Iterable<? extends $type$> values) {\n" 651 " copyOnWrite();\n" 652 " instance.addAll$capitalized_name$(values);\n" 653 " return this;\n" 654 "}\n"); 655 656 // Builder clearAllRepeatedField() 657 WriteFieldDocComment(printer, descriptor_); 658 printer->Print(variables_, 659 "$deprecation$public Builder clear$capitalized_name$() {\n" 660 " copyOnWrite();\n" 661 " instance.clear$capitalized_name$();\n" 662 " return this;\n" 663 "}\n"); 664 665 // Builder removeRepeatedField(int index) 666 WriteFieldDocComment(printer, descriptor_); 667 printer->Print(variables_, 668 "$deprecation$public Builder remove$capitalized_name$(int index) {\n" 669 " copyOnWrite();\n" 670 " instance.remove$capitalized_name$(index);\n" 671 " return this;\n" 672 "}\n"); 673} 674 675void RepeatedImmutableLazyMessageFieldLiteGenerator:: 676GenerateParsingCode(io::Printer* printer) const { 677 printer->Print(variables_, 678 "if (!$is_mutable$) {\n" 679 " $name$_ =\n" 680 " com.google.protobuf.GeneratedMessageLite.mutableCopy($name$_);\n" 681 "}\n" 682 "$name$_.add(new com.google.protobuf.LazyFieldLite(\n" 683 " extensionRegistry, input.readBytes()));\n"); 684} 685 686void RepeatedImmutableLazyMessageFieldLiteGenerator:: 687GenerateSerializationCode(io::Printer* printer) const { 688 printer->Print(variables_, 689 "for (int i = 0; i < $name$_.size(); i++) {\n" 690 " output.writeBytes($number$, $name$_.get(i).toByteString());\n" 691 "}\n"); 692} 693 694void RepeatedImmutableLazyMessageFieldLiteGenerator:: 695GenerateSerializedSizeCode(io::Printer* printer) const { 696 printer->Print(variables_, 697 "for (int i = 0; i < $name$_.size(); i++) {\n" 698 " size += com.google.protobuf.CodedOutputStream\n" 699 " .computeLazyFieldSize($number$, $name$_.get(i));\n" 700 "}\n"); 701} 702 703} // namespace java 704} // namespace compiler 705} // namespace protobuf 706} // namespace google 707