1/** 2 * @fileoverview Kernel wrapper message. 3 */ 4goog.module('protobuf.testing.binary.TestMessage'); 5 6const ByteString = goog.require('protobuf.ByteString'); 7const Int64 = goog.require('protobuf.Int64'); 8const InternalMessage = goog.require('protobuf.binary.InternalMessage'); 9const Kernel = goog.require('protobuf.runtime.Kernel'); 10 11/** 12 * A protobuf message implemented as a Kernel wrapper. 13 * @implements {InternalMessage} 14 */ 15class TestMessage { 16 /** 17 * @return {!TestMessage} 18 */ 19 static createEmpty() { 20 return TestMessage.instanceCreator(Kernel.createEmpty()); 21 } 22 23 /** 24 * @param {!Kernel} kernel 25 * @return {!TestMessage} 26 */ 27 static instanceCreator(kernel) { 28 return new TestMessage(kernel); 29 } 30 31 /** 32 * @param {!Kernel} kernel 33 */ 34 constructor(kernel) { 35 /** @private @const {!Kernel} */ 36 this.kernel_ = kernel; 37 } 38 39 /** 40 * @override 41 * @return {!Kernel} 42 */ 43 internalGetKernel() { 44 return this.kernel_; 45 } 46 47 /** 48 * @return {!ArrayBuffer} 49 */ 50 serialize() { 51 return this.kernel_.serialize(); 52 } 53 54 /** 55 * @param {number} fieldNumber 56 * @param {boolean=} defaultValue 57 * @return {boolean} 58 */ 59 getBoolWithDefault(fieldNumber, defaultValue = false) { 60 return this.kernel_.getBoolWithDefault(fieldNumber, defaultValue); 61 } 62 63 /** 64 * @param {number} fieldNumber 65 * @param {!ByteString=} defaultValue 66 * @return {!ByteString} 67 */ 68 getBytesWithDefault(fieldNumber, defaultValue = ByteString.EMPTY) { 69 return this.kernel_.getBytesWithDefault(fieldNumber, defaultValue); 70 } 71 72 /** 73 * @param {number} fieldNumber 74 * @param {number=} defaultValue 75 * @return {number} 76 */ 77 getDoubleWithDefault(fieldNumber, defaultValue = 0) { 78 return this.kernel_.getDoubleWithDefault(fieldNumber, defaultValue); 79 } 80 81 /** 82 * @param {number} fieldNumber 83 * @param {number=} defaultValue 84 * @return {number} 85 */ 86 getFixed32WithDefault(fieldNumber, defaultValue = 0) { 87 return this.kernel_.getFixed32WithDefault(fieldNumber, defaultValue); 88 } 89 90 /** 91 * @param {number} fieldNumber 92 * @param {!Int64=} defaultValue 93 * @return {!Int64} 94 */ 95 getFixed64WithDefault(fieldNumber, defaultValue = Int64.getZero()) { 96 return this.kernel_.getFixed64WithDefault(fieldNumber, defaultValue); 97 } 98 99 /** 100 * @param {number} fieldNumber 101 * @param {number=} defaultValue 102 * @return {number} 103 */ 104 getFloatWithDefault(fieldNumber, defaultValue = 0) { 105 return this.kernel_.getFloatWithDefault(fieldNumber, defaultValue); 106 } 107 108 /** 109 * @param {number} fieldNumber 110 * @param {number=} defaultValue 111 * @return {number} 112 */ 113 getInt32WithDefault(fieldNumber, defaultValue = 0) { 114 return this.kernel_.getInt32WithDefault(fieldNumber, defaultValue); 115 } 116 117 /** 118 * @param {number} fieldNumber 119 * @param {!Int64=} defaultValue 120 * @return {!Int64} 121 */ 122 getInt64WithDefault(fieldNumber, defaultValue = Int64.getZero()) { 123 return this.kernel_.getInt64WithDefault(fieldNumber, defaultValue); 124 } 125 126 /** 127 * @param {number} fieldNumber 128 * @param {number=} defaultValue 129 * @return {number} 130 */ 131 getSfixed32WithDefault(fieldNumber, defaultValue = 0) { 132 return this.kernel_.getSfixed32WithDefault(fieldNumber, defaultValue); 133 } 134 135 /** 136 * @param {number} fieldNumber 137 * @param {!Int64=} defaultValue 138 * @return {!Int64} 139 */ 140 getSfixed64WithDefault(fieldNumber, defaultValue = Int64.getZero()) { 141 return this.kernel_.getSfixed64WithDefault(fieldNumber, defaultValue); 142 } 143 144 /** 145 * @param {number} fieldNumber 146 * @param {number=} defaultValue 147 * @return {number} 148 */ 149 getSint32WithDefault(fieldNumber, defaultValue = 0) { 150 return this.kernel_.getSint32WithDefault(fieldNumber, defaultValue); 151 } 152 153 /** 154 * @param {number} fieldNumber 155 * @param {!Int64=} defaultValue 156 * @return {!Int64} 157 */ 158 getSint64WithDefault(fieldNumber, defaultValue = Int64.getZero()) { 159 return this.kernel_.getSint64WithDefault(fieldNumber, defaultValue); 160 } 161 162 /** 163 * @param {number} fieldNumber 164 * @param {string=} defaultValue 165 * @return {string} 166 */ 167 getStringWithDefault(fieldNumber, defaultValue = '') { 168 return this.kernel_.getStringWithDefault(fieldNumber, defaultValue); 169 } 170 171 /** 172 * @param {number} fieldNumber 173 * @param {number=} defaultValue 174 * @return {number} 175 */ 176 getUint32WithDefault(fieldNumber, defaultValue = 0) { 177 return this.kernel_.getUint32WithDefault(fieldNumber, defaultValue); 178 } 179 180 /** 181 * @param {number} fieldNumber 182 * @param {!Int64=} defaultValue 183 * @return {!Int64} 184 */ 185 getUint64WithDefault(fieldNumber, defaultValue = Int64.getZero()) { 186 return this.kernel_.getUint64WithDefault(fieldNumber, defaultValue); 187 } 188 189 /** 190 * @param {number} fieldNumber 191 * @param {function(!Kernel):T} instanceCreator 192 * @return {?T} 193 * @template T 194 */ 195 getMessageOrNull(fieldNumber, instanceCreator) { 196 return this.kernel_.getMessageOrNull(fieldNumber, instanceCreator); 197 } 198 199 /** 200 * @param {number} fieldNumber 201 * @param {function(!Kernel):T} instanceCreator 202 * @return {T} 203 * @template T 204 */ 205 getMessageAttach(fieldNumber, instanceCreator) { 206 return this.kernel_.getMessageAttach(fieldNumber, instanceCreator); 207 } 208 209 /** 210 * @param {number} fieldNumber 211 * @param {function(!Kernel):T} instanceCreator 212 * @return {T} 213 * @template T 214 */ 215 getMessage(fieldNumber, instanceCreator) { 216 return this.kernel_.getMessage(fieldNumber, instanceCreator); 217 } 218 219 /** 220 * @param {number} fieldNumber 221 * @return {?Kernel} 222 * @template T 223 */ 224 getMessageAccessorOrNull(fieldNumber) { 225 return this.kernel_.getMessageAccessorOrNull(fieldNumber); 226 } 227 228 /** 229 * @param {number} fieldNumber 230 * @param {number} index 231 * @return {boolean} 232 */ 233 getRepeatedBoolElement(fieldNumber, index) { 234 return this.kernel_.getRepeatedBoolElement(fieldNumber, index); 235 } 236 237 /** 238 * @param {number} fieldNumber 239 * @return {!Iterable<boolean>} 240 */ 241 getRepeatedBoolIterable(fieldNumber) { 242 return this.kernel_.getRepeatedBoolIterable(fieldNumber); 243 } 244 245 /** 246 * @param {number} fieldNumber 247 * @return {number} 248 */ 249 getRepeatedBoolSize(fieldNumber) { 250 return this.kernel_.getRepeatedBoolSize(fieldNumber); 251 } 252 253 /** 254 * @param {number} fieldNumber 255 * @param {number} index 256 * @return {number} 257 */ 258 getRepeatedDoubleElement(fieldNumber, index) { 259 return this.kernel_.getRepeatedDoubleElement(fieldNumber, index); 260 } 261 262 /** 263 * @param {number} fieldNumber 264 * @return {!Iterable<number>} 265 */ 266 getRepeatedDoubleIterable(fieldNumber) { 267 return this.kernel_.getRepeatedDoubleIterable(fieldNumber); 268 } 269 270 /** 271 * @param {number} fieldNumber 272 * @return {number} 273 */ 274 getRepeatedDoubleSize(fieldNumber) { 275 return this.kernel_.getRepeatedDoubleSize(fieldNumber); 276 } 277 278 /** 279 * @param {number} fieldNumber 280 * @param {number} index 281 * @return {number} 282 */ 283 getRepeatedFixed32Element(fieldNumber, index) { 284 return this.kernel_.getRepeatedFixed32Element(fieldNumber, index); 285 } 286 287 /** 288 * @param {number} fieldNumber 289 * @return {!Iterable<number>} 290 */ 291 getRepeatedFixed32Iterable(fieldNumber) { 292 return this.kernel_.getRepeatedFixed32Iterable(fieldNumber); 293 } 294 295 /** 296 * @param {number} fieldNumber 297 * @return {number} 298 */ 299 getRepeatedFixed32Size(fieldNumber) { 300 return this.kernel_.getRepeatedFixed32Size(fieldNumber); 301 } 302 303 /** 304 * @param {number} fieldNumber 305 * @param {number} index 306 * @return {!Int64} 307 */ 308 getRepeatedFixed64Element(fieldNumber, index) { 309 return this.kernel_.getRepeatedFixed64Element(fieldNumber, index); 310 } 311 312 /** 313 * @param {number} fieldNumber 314 * @return {!Iterable<!Int64>} 315 */ 316 getRepeatedFixed64Iterable(fieldNumber) { 317 return this.kernel_.getRepeatedFixed64Iterable(fieldNumber); 318 } 319 320 /** 321 * @param {number} fieldNumber 322 * @return {number} 323 */ 324 getRepeatedFixed64Size(fieldNumber) { 325 return this.kernel_.getRepeatedFixed64Size(fieldNumber); 326 } 327 /** 328 * @param {number} fieldNumber 329 * @param {number} index 330 * @return {number} 331 */ 332 getRepeatedFloatElement(fieldNumber, index) { 333 return this.kernel_.getRepeatedFloatElement(fieldNumber, index); 334 } 335 336 /** 337 * @param {number} fieldNumber 338 * @return {!Iterable<number>} 339 */ 340 getRepeatedFloatIterable(fieldNumber) { 341 return this.kernel_.getRepeatedFloatIterable(fieldNumber); 342 } 343 344 /** 345 * @param {number} fieldNumber 346 * @return {number} 347 */ 348 getRepeatedFloatSize(fieldNumber) { 349 return this.kernel_.getRepeatedFloatSize(fieldNumber); 350 } 351 /** 352 * @param {number} fieldNumber 353 * @param {number} index 354 * @return {number} 355 */ 356 getRepeatedInt32Element(fieldNumber, index) { 357 return this.kernel_.getRepeatedInt32Element(fieldNumber, index); 358 } 359 360 /** 361 * @param {number} fieldNumber 362 * @return {!Iterable<number>} 363 */ 364 getRepeatedInt32Iterable(fieldNumber) { 365 return this.kernel_.getRepeatedInt32Iterable(fieldNumber); 366 } 367 368 /** 369 * @param {number} fieldNumber 370 * @return {number} 371 */ 372 getRepeatedInt32Size(fieldNumber) { 373 return this.kernel_.getRepeatedInt32Size(fieldNumber); 374 } 375 376 /** 377 * @param {number} fieldNumber 378 * @param {number} index 379 * @return {!Int64} 380 */ 381 getRepeatedInt64Element(fieldNumber, index) { 382 return this.kernel_.getRepeatedInt64Element(fieldNumber, index); 383 } 384 385 /** 386 * @param {number} fieldNumber 387 * @return {!Iterable<!Int64>} 388 */ 389 getRepeatedInt64Iterable(fieldNumber) { 390 return this.kernel_.getRepeatedInt64Iterable(fieldNumber); 391 } 392 393 /** 394 * @param {number} fieldNumber 395 * @return {number} 396 */ 397 getRepeatedInt64Size(fieldNumber) { 398 return this.kernel_.getRepeatedInt64Size(fieldNumber); 399 } 400 401 /** 402 * @param {number} fieldNumber 403 * @param {number} index 404 * @return {number} 405 */ 406 getRepeatedSfixed32Element(fieldNumber, index) { 407 return this.kernel_.getRepeatedSfixed32Element(fieldNumber, index); 408 } 409 410 /** 411 * @param {number} fieldNumber 412 * @return {!Iterable<number>} 413 */ 414 getRepeatedSfixed32Iterable(fieldNumber) { 415 return this.kernel_.getRepeatedSfixed32Iterable(fieldNumber); 416 } 417 418 /** 419 * @param {number} fieldNumber 420 * @return {number} 421 */ 422 getRepeatedSfixed32Size(fieldNumber) { 423 return this.kernel_.getRepeatedSfixed32Size(fieldNumber); 424 } 425 426 /** 427 * @param {number} fieldNumber 428 * @param {number} index 429 * @return {!Int64} 430 */ 431 getRepeatedSfixed64Element(fieldNumber, index) { 432 return this.kernel_.getRepeatedSfixed64Element(fieldNumber, index); 433 } 434 435 /** 436 * @param {number} fieldNumber 437 * @return {!Iterable<!Int64>} 438 */ 439 getRepeatedSfixed64Iterable(fieldNumber) { 440 return this.kernel_.getRepeatedSfixed64Iterable(fieldNumber); 441 } 442 443 /** 444 * @param {number} fieldNumber 445 * @return {number} 446 */ 447 getRepeatedSfixed64Size(fieldNumber) { 448 return this.kernel_.getRepeatedSfixed64Size(fieldNumber); 449 } 450 451 /** 452 * @param {number} fieldNumber 453 * @param {number} index 454 * @return {number} 455 */ 456 getRepeatedSint32Element(fieldNumber, index) { 457 return this.kernel_.getRepeatedSint32Element(fieldNumber, index); 458 } 459 460 /** 461 * @param {number} fieldNumber 462 * @return {!Iterable<number>} 463 */ 464 getRepeatedSint32Iterable(fieldNumber) { 465 return this.kernel_.getRepeatedSint32Iterable(fieldNumber); 466 } 467 468 /** 469 * @param {number} fieldNumber 470 * @return {number} 471 */ 472 getRepeatedSint32Size(fieldNumber) { 473 return this.kernel_.getRepeatedSint32Size(fieldNumber); 474 } 475 476 /** 477 * @param {number} fieldNumber 478 * @param {number} index 479 * @return {!Int64} 480 */ 481 getRepeatedSint64Element(fieldNumber, index) { 482 return this.kernel_.getRepeatedSint64Element(fieldNumber, index); 483 } 484 485 /** 486 * @param {number} fieldNumber 487 * @return {!Iterable<!Int64>} 488 */ 489 getRepeatedSint64Iterable(fieldNumber) { 490 return this.kernel_.getRepeatedSint64Iterable(fieldNumber); 491 } 492 493 /** 494 * @param {number} fieldNumber 495 * @return {number} 496 */ 497 getRepeatedSint64Size(fieldNumber) { 498 return this.kernel_.getRepeatedSint64Size(fieldNumber); 499 } 500 501 /** 502 * @param {number} fieldNumber 503 * @param {number} index 504 * @return {number} 505 */ 506 getRepeatedUint32Element(fieldNumber, index) { 507 return this.kernel_.getRepeatedUint32Element(fieldNumber, index); 508 } 509 510 /** 511 * @param {number} fieldNumber 512 * @return {!Iterable<number>} 513 */ 514 getRepeatedUint32Iterable(fieldNumber) { 515 return this.kernel_.getRepeatedUint32Iterable(fieldNumber); 516 } 517 518 /** 519 * @param {number} fieldNumber 520 * @return {number} 521 */ 522 getRepeatedUint32Size(fieldNumber) { 523 return this.kernel_.getRepeatedUint32Size(fieldNumber); 524 } 525 526 /** 527 * @param {number} fieldNumber 528 * @param {number} index 529 * @return {!Int64} 530 */ 531 getRepeatedUint64Element(fieldNumber, index) { 532 return this.kernel_.getRepeatedUint64Element(fieldNumber, index); 533 } 534 535 /** 536 * @param {number} fieldNumber 537 * @return {!Iterable<!Int64>} 538 */ 539 getRepeatedUint64Iterable(fieldNumber) { 540 return this.kernel_.getRepeatedUint64Iterable(fieldNumber); 541 } 542 543 /** 544 * @param {number} fieldNumber 545 * @return {number} 546 */ 547 getRepeatedUint64Size(fieldNumber) { 548 return this.kernel_.getRepeatedUint64Size(fieldNumber); 549 } 550 551 /** 552 * @param {number} fieldNumber 553 * @param {number} index 554 * @return {!ByteString} 555 */ 556 getRepeatedBytesElement(fieldNumber, index) { 557 return this.kernel_.getRepeatedBytesElement(fieldNumber, index); 558 } 559 560 /** 561 * @param {number} fieldNumber 562 * @return {!Iterable<!ByteString>} 563 */ 564 getRepeatedBytesIterable(fieldNumber) { 565 return this.kernel_.getRepeatedBytesIterable(fieldNumber); 566 } 567 568 /** 569 * @param {number} fieldNumber 570 * @return {number} 571 */ 572 getRepeatedBytesSize(fieldNumber) { 573 return this.kernel_.getRepeatedBytesSize(fieldNumber); 574 } 575 576 /** 577 * @param {number} fieldNumber 578 * @param {number} index 579 * @return {string} 580 */ 581 getRepeatedStringElement(fieldNumber, index) { 582 return this.kernel_.getRepeatedStringElement(fieldNumber, index); 583 } 584 585 /** 586 * @param {number} fieldNumber 587 * @return {!Iterable<string>} 588 */ 589 getRepeatedStringIterable(fieldNumber) { 590 return this.kernel_.getRepeatedStringIterable(fieldNumber); 591 } 592 593 /** 594 * @param {number} fieldNumber 595 * @return {number} 596 */ 597 getRepeatedStringSize(fieldNumber) { 598 return this.kernel_.getRepeatedStringSize(fieldNumber); 599 } 600 601 /** 602 * @param {number} fieldNumber 603 * @param {function(!Kernel):T} instanceCreator 604 * @param {number} index 605 * @return {T} 606 * @template T 607 */ 608 getRepeatedMessageElement(fieldNumber, instanceCreator, index) { 609 return this.kernel_.getRepeatedMessageElement( 610 fieldNumber, instanceCreator, index); 611 } 612 613 /** 614 * @param {number} fieldNumber 615 * @param {function(!Kernel):T} instanceCreator 616 * @return {!Iterable<T>} 617 * @template T 618 */ 619 getRepeatedMessageIterable(fieldNumber, instanceCreator) { 620 return this.kernel_.getRepeatedMessageIterable( 621 fieldNumber, instanceCreator); 622 } 623 624 /** 625 * @param {number} fieldNumber 626 * @return {!Iterable<!Kernel>} 627 * @template T 628 */ 629 getRepeatedMessageAccessorIterable(fieldNumber) { 630 return this.kernel_.getRepeatedMessageAccessorIterable(fieldNumber); 631 } 632 633 /** 634 * @param {number} fieldNumber 635 * @param {function(!Kernel):T} instanceCreator 636 * @return {number} 637 * @template T 638 */ 639 getRepeatedMessageSize(fieldNumber, instanceCreator) { 640 return this.kernel_.getRepeatedMessageSize(fieldNumber, instanceCreator); 641 } 642 643 /** 644 * @param {number} fieldNumber 645 * @param {boolean} value 646 */ 647 setBool(fieldNumber, value) { 648 this.kernel_.setBool(fieldNumber, value); 649 } 650 651 /** 652 * @param {number} fieldNumber 653 * @param {!ByteString} value 654 */ 655 setBytes(fieldNumber, value) { 656 this.kernel_.setBytes(fieldNumber, value); 657 } 658 659 /** 660 * @param {number} fieldNumber 661 * @param {number} value 662 */ 663 setDouble(fieldNumber, value) { 664 this.kernel_.setDouble(fieldNumber, value); 665 } 666 667 /** 668 * @param {number} fieldNumber 669 * @param {number} value 670 */ 671 setFixed32(fieldNumber, value) { 672 this.kernel_.setFixed32(fieldNumber, value); 673 } 674 675 /** 676 * @param {number} fieldNumber 677 * @param {!Int64} value 678 */ 679 setFixed64(fieldNumber, value) { 680 this.kernel_.setFixed64(fieldNumber, value); 681 } 682 683 /** 684 * @param {number} fieldNumber 685 * @param {number} value 686 */ 687 setFloat(fieldNumber, value) { 688 this.kernel_.setFloat(fieldNumber, value); 689 } 690 691 /** 692 * @param {number} fieldNumber 693 * @param {number} value 694 */ 695 setInt32(fieldNumber, value) { 696 this.kernel_.setInt32(fieldNumber, value); 697 } 698 699 /** 700 * @param {number} fieldNumber 701 * @param {!Int64} value 702 */ 703 setInt64(fieldNumber, value) { 704 this.kernel_.setInt64(fieldNumber, value); 705 } 706 707 /** 708 * @param {number} fieldNumber 709 * @param {number} value 710 */ 711 setSfixed32(fieldNumber, value) { 712 this.kernel_.setSfixed32(fieldNumber, value); 713 } 714 715 /** 716 * @param {number} fieldNumber 717 * @param {!Int64} value 718 */ 719 setSfixed64(fieldNumber, value) { 720 this.kernel_.setSfixed64(fieldNumber, value); 721 } 722 723 /** 724 * @param {number} fieldNumber 725 * @param {number} value 726 */ 727 setSint32(fieldNumber, value) { 728 this.kernel_.setSint32(fieldNumber, value); 729 } 730 731 /** 732 * @param {number} fieldNumber 733 * @param {!Int64} value 734 */ 735 setSint64(fieldNumber, value) { 736 this.kernel_.setSint64(fieldNumber, value); 737 } 738 739 /** 740 * @param {number} fieldNumber 741 * @param {string} value 742 */ 743 setString(fieldNumber, value) { 744 this.kernel_.setString(fieldNumber, value); 745 } 746 747 /** 748 * @param {number} fieldNumber 749 * @param {number} value 750 */ 751 setUint32(fieldNumber, value) { 752 this.kernel_.setUint32(fieldNumber, value); 753 } 754 755 /** 756 * @param {number} fieldNumber 757 * @param {!Int64} value 758 */ 759 setUint64(fieldNumber, value) { 760 this.kernel_.setUint64(fieldNumber, value); 761 } 762 763 /** 764 * @param {number} fieldNumber 765 * @param {T} value 766 * @template T 767 */ 768 setMessage(fieldNumber, value) { 769 this.kernel_.setMessage(fieldNumber, value); 770 } 771 772 /** 773 * @param {number} fieldNumber 774 * @param {boolean} value 775 */ 776 addPackedBoolElement(fieldNumber, value) { 777 this.kernel_.addPackedBoolElement(fieldNumber, value); 778 } 779 780 /** 781 * @param {number} fieldNumber 782 * @param {!Iterable<boolean>} values 783 */ 784 addPackedBoolIterable(fieldNumber, values) { 785 this.kernel_.addPackedBoolIterable(fieldNumber, values); 786 } 787 788 /** 789 * @param {number} fieldNumber 790 * @param {boolean} value 791 */ 792 addUnpackedBoolElement(fieldNumber, value) { 793 this.kernel_.addUnpackedBoolElement(fieldNumber, value); 794 } 795 796 /** 797 * @param {number} fieldNumber 798 * @param {!Iterable<boolean>} values 799 */ 800 addUnpackedBoolIterable(fieldNumber, values) { 801 this.kernel_.addUnpackedBoolIterable(fieldNumber, values); 802 } 803 804 /** 805 * @param {number} fieldNumber 806 * @param {number} index 807 * @param {boolean} value 808 * @throws {!Error} if index is out of range when check mode is critical 809 */ 810 setPackedBoolElement(fieldNumber, index, value) { 811 this.kernel_.setPackedBoolElement(fieldNumber, index, value); 812 } 813 814 /** 815 * @param {number} fieldNumber 816 * @param {!Iterable<boolean>} values 817 */ 818 setPackedBoolIterable(fieldNumber, values) { 819 this.kernel_.setPackedBoolIterable(fieldNumber, values); 820 } 821 822 /** 823 * @param {number} fieldNumber 824 * @param {number} index 825 * @param {boolean} value 826 * @throws {!Error} if index is out of range when check mode is critical 827 */ 828 setUnpackedBoolElement(fieldNumber, index, value) { 829 this.kernel_.setUnpackedBoolElement(fieldNumber, index, value); 830 } 831 832 /** 833 * @param {number} fieldNumber 834 * @param {!Iterable<boolean>} values 835 */ 836 setUnpackedBoolIterable(fieldNumber, values) { 837 this.kernel_.setUnpackedBoolIterable(fieldNumber, values); 838 } 839 840 /** 841 * @param {number} fieldNumber 842 * @param {number} value 843 */ 844 addPackedDoubleElement(fieldNumber, value) { 845 this.kernel_.addPackedDoubleElement(fieldNumber, value); 846 } 847 848 /** 849 * @param {number} fieldNumber 850 * @param {!Iterable<number>} values 851 */ 852 addPackedDoubleIterable(fieldNumber, values) { 853 this.kernel_.addPackedDoubleIterable(fieldNumber, values); 854 } 855 856 /** 857 * @param {number} fieldNumber 858 * @param {number} value 859 */ 860 addUnpackedDoubleElement(fieldNumber, value) { 861 this.kernel_.addUnpackedDoubleElement(fieldNumber, value); 862 } 863 864 /** 865 * @param {number} fieldNumber 866 * @param {!Iterable<number>} values 867 */ 868 addUnpackedDoubleIterable(fieldNumber, values) { 869 this.kernel_.addUnpackedDoubleIterable(fieldNumber, values); 870 } 871 872 /** 873 * @param {number} fieldNumber 874 * @param {number} index 875 * @param {number} value 876 * @throws {!Error} if index is out of range when check mode is critical 877 */ 878 setPackedDoubleElement(fieldNumber, index, value) { 879 this.kernel_.setPackedDoubleElement(fieldNumber, index, value); 880 } 881 882 /** 883 * @param {number} fieldNumber 884 * @param {!Iterable<number>} values 885 */ 886 setPackedDoubleIterable(fieldNumber, values) { 887 this.kernel_.setPackedDoubleIterable(fieldNumber, values); 888 } 889 890 /** 891 * @param {number} fieldNumber 892 * @param {number} index 893 * @param {number} value 894 * @throws {!Error} if index is out of range when check mode is critical 895 */ 896 setUnpackedDoubleElement(fieldNumber, index, value) { 897 this.kernel_.setUnpackedDoubleElement(fieldNumber, index, value); 898 } 899 900 /** 901 * @param {number} fieldNumber 902 * @param {!Iterable<number>} values 903 */ 904 setUnpackedDoubleIterable(fieldNumber, values) { 905 this.kernel_.setUnpackedDoubleIterable(fieldNumber, values); 906 } 907 908 /** 909 * @param {number} fieldNumber 910 * @param {number} value 911 */ 912 addPackedFixed32Element(fieldNumber, value) { 913 this.kernel_.addPackedFixed32Element(fieldNumber, value); 914 } 915 916 /** 917 * @param {number} fieldNumber 918 * @param {!Iterable<number>} values 919 */ 920 addPackedFixed32Iterable(fieldNumber, values) { 921 this.kernel_.addPackedFixed32Iterable(fieldNumber, values); 922 } 923 924 /** 925 * @param {number} fieldNumber 926 * @param {number} value 927 */ 928 addUnpackedFixed32Element(fieldNumber, value) { 929 this.kernel_.addUnpackedFixed32Element(fieldNumber, value); 930 } 931 932 /** 933 * @param {number} fieldNumber 934 * @param {!Iterable<number>} values 935 */ 936 addUnpackedFixed32Iterable(fieldNumber, values) { 937 this.kernel_.addUnpackedFixed32Iterable(fieldNumber, values); 938 } 939 940 /** 941 * @param {number} fieldNumber 942 * @param {number} index 943 * @param {number} value 944 * @throws {!Error} if index is out of range when check mode is critical 945 */ 946 setPackedFixed32Element(fieldNumber, index, value) { 947 this.kernel_.setPackedFixed32Element(fieldNumber, index, value); 948 } 949 950 /** 951 * @param {number} fieldNumber 952 * @param {!Iterable<number>} values 953 */ 954 setPackedFixed32Iterable(fieldNumber, values) { 955 this.kernel_.setPackedFixed32Iterable(fieldNumber, values); 956 } 957 958 /** 959 * @param {number} fieldNumber 960 * @param {number} index 961 * @param {number} value 962 * @throws {!Error} if index is out of range when check mode is critical 963 */ 964 setUnpackedFixed32Element(fieldNumber, index, value) { 965 this.kernel_.setUnpackedFixed32Element(fieldNumber, index, value); 966 } 967 968 /** 969 * @param {number} fieldNumber 970 * @param {!Iterable<number>} values 971 */ 972 setUnpackedFixed32Iterable(fieldNumber, values) { 973 this.kernel_.setUnpackedFixed32Iterable(fieldNumber, values); 974 } 975 976 /** 977 * @param {number} fieldNumber 978 * @param {!Int64} value 979 */ 980 addPackedFixed64Element(fieldNumber, value) { 981 this.kernel_.addPackedFixed64Element(fieldNumber, value); 982 } 983 984 /** 985 * @param {number} fieldNumber 986 * @param {!Iterable<!Int64>} values 987 */ 988 addPackedFixed64Iterable(fieldNumber, values) { 989 this.kernel_.addPackedFixed64Iterable(fieldNumber, values); 990 } 991 992 /** 993 * @param {number} fieldNumber 994 * @param {!Int64} value 995 */ 996 addUnpackedFixed64Element(fieldNumber, value) { 997 this.kernel_.addUnpackedFixed64Element(fieldNumber, value); 998 } 999 1000 /** 1001 * @param {number} fieldNumber 1002 * @param {!Iterable<!Int64>} values 1003 */ 1004 addUnpackedFixed64Iterable(fieldNumber, values) { 1005 this.kernel_.addUnpackedFixed64Iterable(fieldNumber, values); 1006 } 1007 1008 /** 1009 * @param {number} fieldNumber 1010 * @param {number} index 1011 * @param {!Int64} value 1012 * @throws {!Error} if index is out of range when check mode is critical 1013 */ 1014 setPackedFixed64Element(fieldNumber, index, value) { 1015 this.kernel_.setPackedFixed64Element(fieldNumber, index, value); 1016 } 1017 1018 /** 1019 * @param {number} fieldNumber 1020 * @param {!Iterable<!Int64>} values 1021 */ 1022 setPackedFixed64Iterable(fieldNumber, values) { 1023 this.kernel_.setPackedFixed64Iterable(fieldNumber, values); 1024 } 1025 1026 /** 1027 * @param {number} fieldNumber 1028 * @param {number} index 1029 * @param {!Int64} value 1030 * @throws {!Error} if index is out of range when check mode is critical 1031 */ 1032 setUnpackedFixed64Element(fieldNumber, index, value) { 1033 this.kernel_.setUnpackedFixed64Element(fieldNumber, index, value); 1034 } 1035 1036 /** 1037 * @param {number} fieldNumber 1038 * @param {!Iterable<!Int64>} values 1039 */ 1040 setUnpackedFixed64Iterable(fieldNumber, values) { 1041 this.kernel_.setUnpackedFixed64Iterable(fieldNumber, values); 1042 } 1043 1044 /** 1045 * @param {number} fieldNumber 1046 * @param {number} value 1047 */ 1048 addPackedFloatElement(fieldNumber, value) { 1049 this.kernel_.addPackedFloatElement(fieldNumber, value); 1050 } 1051 1052 /** 1053 * @param {number} fieldNumber 1054 * @param {!Iterable<number>} values 1055 */ 1056 addPackedFloatIterable(fieldNumber, values) { 1057 this.kernel_.addPackedFloatIterable(fieldNumber, values); 1058 } 1059 1060 /** 1061 * @param {number} fieldNumber 1062 * @param {number} value 1063 */ 1064 addUnpackedFloatElement(fieldNumber, value) { 1065 this.kernel_.addUnpackedFloatElement(fieldNumber, value); 1066 } 1067 1068 /** 1069 * @param {number} fieldNumber 1070 * @param {!Iterable<number>} values 1071 */ 1072 addUnpackedFloatIterable(fieldNumber, values) { 1073 this.kernel_.addUnpackedFloatIterable(fieldNumber, values); 1074 } 1075 1076 /** 1077 * @param {number} fieldNumber 1078 * @param {number} index 1079 * @param {number} value 1080 * @throws {!Error} if index is out of range when check mode is critical 1081 */ 1082 setPackedFloatElement(fieldNumber, index, value) { 1083 this.kernel_.setPackedFloatElement(fieldNumber, index, value); 1084 } 1085 1086 /** 1087 * @param {number} fieldNumber 1088 * @param {!Iterable<number>} values 1089 */ 1090 setPackedFloatIterable(fieldNumber, values) { 1091 this.kernel_.setPackedFloatIterable(fieldNumber, values); 1092 } 1093 1094 /** 1095 * @param {number} fieldNumber 1096 * @param {number} index 1097 * @param {number} value 1098 * @throws {!Error} if index is out of range when check mode is critical 1099 */ 1100 setUnpackedFloatElement(fieldNumber, index, value) { 1101 this.kernel_.setUnpackedFloatElement(fieldNumber, index, value); 1102 } 1103 1104 /** 1105 * @param {number} fieldNumber 1106 * @param {!Iterable<number>} values 1107 */ 1108 setUnpackedFloatIterable(fieldNumber, values) { 1109 this.kernel_.setUnpackedFloatIterable(fieldNumber, values); 1110 } 1111 1112 /** 1113 * @param {number} fieldNumber 1114 * @param {number} value 1115 */ 1116 addPackedInt32Element(fieldNumber, value) { 1117 this.kernel_.addPackedInt32Element(fieldNumber, value); 1118 } 1119 1120 /** 1121 * @param {number} fieldNumber 1122 * @param {!Iterable<number>} values 1123 */ 1124 addPackedInt32Iterable(fieldNumber, values) { 1125 this.kernel_.addPackedInt32Iterable(fieldNumber, values); 1126 } 1127 1128 /** 1129 * @param {number} fieldNumber 1130 * @param {number} value 1131 */ 1132 addUnpackedInt32Element(fieldNumber, value) { 1133 this.kernel_.addUnpackedInt32Element(fieldNumber, value); 1134 } 1135 1136 /** 1137 * @param {number} fieldNumber 1138 * @param {!Iterable<number>} values 1139 */ 1140 addUnpackedInt32Iterable(fieldNumber, values) { 1141 this.kernel_.addUnpackedInt32Iterable(fieldNumber, values); 1142 } 1143 1144 /** 1145 * @param {number} fieldNumber 1146 * @param {number} index 1147 * @param {number} value 1148 * @throws {!Error} if index is out of range when check mode is critical 1149 */ 1150 setPackedInt32Element(fieldNumber, index, value) { 1151 this.kernel_.setPackedInt32Element(fieldNumber, index, value); 1152 } 1153 1154 /** 1155 * @param {number} fieldNumber 1156 * @param {!Iterable<number>} values 1157 */ 1158 setPackedInt32Iterable(fieldNumber, values) { 1159 this.kernel_.setPackedInt32Iterable(fieldNumber, values); 1160 } 1161 1162 /** 1163 * @param {number} fieldNumber 1164 * @param {number} index 1165 * @param {number} value 1166 * @throws {!Error} if index is out of range when check mode is critical 1167 */ 1168 setUnpackedInt32Element(fieldNumber, index, value) { 1169 this.kernel_.setUnpackedInt32Element(fieldNumber, index, value); 1170 } 1171 1172 /** 1173 * @param {number} fieldNumber 1174 * @param {!Iterable<number>} values 1175 */ 1176 setUnpackedInt32Iterable(fieldNumber, values) { 1177 this.kernel_.setUnpackedInt32Iterable(fieldNumber, values); 1178 } 1179 1180 /** 1181 * @param {number} fieldNumber 1182 * @param {!Int64} value 1183 */ 1184 addPackedInt64Element(fieldNumber, value) { 1185 this.kernel_.addPackedInt64Element(fieldNumber, value); 1186 } 1187 1188 /** 1189 * @param {number} fieldNumber 1190 * @param {!Iterable<!Int64>} values 1191 */ 1192 addPackedInt64Iterable(fieldNumber, values) { 1193 this.kernel_.addPackedInt64Iterable(fieldNumber, values); 1194 } 1195 1196 /** 1197 * @param {number} fieldNumber 1198 * @param {!Int64} value 1199 */ 1200 addUnpackedInt64Element(fieldNumber, value) { 1201 this.kernel_.addUnpackedInt64Element(fieldNumber, value); 1202 } 1203 1204 /** 1205 * @param {number} fieldNumber 1206 * @param {!Iterable<!Int64>} values 1207 */ 1208 addUnpackedInt64Iterable(fieldNumber, values) { 1209 this.kernel_.addUnpackedInt64Iterable(fieldNumber, values); 1210 } 1211 1212 /** 1213 * @param {number} fieldNumber 1214 * @param {number} index 1215 * @param {!Int64} value 1216 * @throws {!Error} if index is out of range when check mode is critical 1217 */ 1218 setPackedInt64Element(fieldNumber, index, value) { 1219 this.kernel_.setPackedInt64Element(fieldNumber, index, value); 1220 } 1221 1222 /** 1223 * @param {number} fieldNumber 1224 * @param {!Iterable<!Int64>} values 1225 */ 1226 setPackedInt64Iterable(fieldNumber, values) { 1227 this.kernel_.setPackedInt64Iterable(fieldNumber, values); 1228 } 1229 1230 /** 1231 * @param {number} fieldNumber 1232 * @param {number} index 1233 * @param {!Int64} value 1234 * @throws {!Error} if index is out of range when check mode is critical 1235 */ 1236 setUnpackedInt64Element(fieldNumber, index, value) { 1237 this.kernel_.setUnpackedInt64Element(fieldNumber, index, value); 1238 } 1239 1240 /** 1241 * @param {number} fieldNumber 1242 * @param {!Iterable<!Int64>} values 1243 */ 1244 setUnpackedInt64Iterable(fieldNumber, values) { 1245 this.kernel_.setUnpackedInt64Iterable(fieldNumber, values); 1246 } 1247 1248 /** 1249 * @param {number} fieldNumber 1250 * @param {number} value 1251 */ 1252 addPackedSfixed32Element(fieldNumber, value) { 1253 this.kernel_.addPackedSfixed32Element(fieldNumber, value); 1254 } 1255 1256 /** 1257 * @param {number} fieldNumber 1258 * @param {!Iterable<number>} values 1259 */ 1260 addPackedSfixed32Iterable(fieldNumber, values) { 1261 this.kernel_.addPackedSfixed32Iterable(fieldNumber, values); 1262 } 1263 1264 /** 1265 * @param {number} fieldNumber 1266 * @param {number} value 1267 */ 1268 addUnpackedSfixed32Element(fieldNumber, value) { 1269 this.kernel_.addUnpackedSfixed32Element(fieldNumber, value); 1270 } 1271 1272 /** 1273 * @param {number} fieldNumber 1274 * @param {!Iterable<number>} values 1275 */ 1276 addUnpackedSfixed32Iterable(fieldNumber, values) { 1277 this.kernel_.addUnpackedSfixed32Iterable(fieldNumber, values); 1278 } 1279 1280 /** 1281 * @param {number} fieldNumber 1282 * @param {number} index 1283 * @param {number} value 1284 * @throws {!Error} if index is out of range when check mode is critical 1285 */ 1286 setPackedSfixed32Element(fieldNumber, index, value) { 1287 this.kernel_.setPackedSfixed32Element(fieldNumber, index, value); 1288 } 1289 1290 /** 1291 * @param {number} fieldNumber 1292 * @param {!Iterable<number>} values 1293 */ 1294 setPackedSfixed32Iterable(fieldNumber, values) { 1295 this.kernel_.setPackedSfixed32Iterable(fieldNumber, values); 1296 } 1297 1298 /** 1299 * @param {number} fieldNumber 1300 * @param {number} index 1301 * @param {number} value 1302 * @throws {!Error} if index is out of range when check mode is critical 1303 */ 1304 setUnpackedSfixed32Element(fieldNumber, index, value) { 1305 this.kernel_.setUnpackedSfixed32Element(fieldNumber, index, value); 1306 } 1307 1308 /** 1309 * @param {number} fieldNumber 1310 * @param {!Iterable<number>} values 1311 */ 1312 setUnpackedSfixed32Iterable(fieldNumber, values) { 1313 this.kernel_.setUnpackedSfixed32Iterable(fieldNumber, values); 1314 } 1315 1316 /** 1317 * @param {number} fieldNumber 1318 * @param {!Int64} value 1319 */ 1320 addPackedSfixed64Element(fieldNumber, value) { 1321 this.kernel_.addPackedSfixed64Element(fieldNumber, value); 1322 } 1323 1324 /** 1325 * @param {number} fieldNumber 1326 * @param {!Iterable<!Int64>} values 1327 */ 1328 addPackedSfixed64Iterable(fieldNumber, values) { 1329 this.kernel_.addPackedSfixed64Iterable(fieldNumber, values); 1330 } 1331 1332 /** 1333 * @param {number} fieldNumber 1334 * @param {!Int64} value 1335 */ 1336 addUnpackedSfixed64Element(fieldNumber, value) { 1337 this.kernel_.addUnpackedSfixed64Element(fieldNumber, value); 1338 } 1339 1340 /** 1341 * @param {number} fieldNumber 1342 * @param {!Iterable<!Int64>} values 1343 */ 1344 addUnpackedSfixed64Iterable(fieldNumber, values) { 1345 this.kernel_.addUnpackedSfixed64Iterable(fieldNumber, values); 1346 } 1347 1348 /** 1349 * @param {number} fieldNumber 1350 * @param {number} index 1351 * @param {!Int64} value 1352 * @throws {!Error} if index is out of range when check mode is critical 1353 */ 1354 setPackedSfixed64Element(fieldNumber, index, value) { 1355 this.kernel_.setPackedSfixed64Element(fieldNumber, index, value); 1356 } 1357 1358 /** 1359 * @param {number} fieldNumber 1360 * @param {!Iterable<!Int64>} values 1361 */ 1362 setPackedSfixed64Iterable(fieldNumber, values) { 1363 this.kernel_.setPackedSfixed64Iterable(fieldNumber, values); 1364 } 1365 1366 /** 1367 * @param {number} fieldNumber 1368 * @param {number} index 1369 * @param {!Int64} value 1370 * @throws {!Error} if index is out of range when check mode is critical 1371 */ 1372 setUnpackedSfixed64Element(fieldNumber, index, value) { 1373 this.kernel_.setUnpackedSfixed64Element(fieldNumber, index, value); 1374 } 1375 1376 /** 1377 * @param {number} fieldNumber 1378 * @param {!Iterable<!Int64>} values 1379 */ 1380 setUnpackedSfixed64Iterable(fieldNumber, values) { 1381 this.kernel_.setUnpackedSfixed64Iterable(fieldNumber, values); 1382 } 1383 1384 /** 1385 * @param {number} fieldNumber 1386 * @param {number} value 1387 */ 1388 addPackedSint32Element(fieldNumber, value) { 1389 this.kernel_.addPackedSint32Element(fieldNumber, value); 1390 } 1391 1392 /** 1393 * @param {number} fieldNumber 1394 * @param {!Iterable<number>} values 1395 */ 1396 addPackedSint32Iterable(fieldNumber, values) { 1397 this.kernel_.addPackedSint32Iterable(fieldNumber, values); 1398 } 1399 1400 /** 1401 * @param {number} fieldNumber 1402 * @param {number} value 1403 */ 1404 addUnpackedSint32Element(fieldNumber, value) { 1405 this.kernel_.addUnpackedSint32Element(fieldNumber, value); 1406 } 1407 1408 /** 1409 * @param {number} fieldNumber 1410 * @param {!Iterable<number>} values 1411 */ 1412 addUnpackedSint32Iterable(fieldNumber, values) { 1413 this.kernel_.addUnpackedSint32Iterable(fieldNumber, values); 1414 } 1415 1416 /** 1417 * @param {number} fieldNumber 1418 * @param {number} index 1419 * @param {number} value 1420 * @throws {!Error} if index is out of range when check mode is critical 1421 */ 1422 setPackedSint32Element(fieldNumber, index, value) { 1423 this.kernel_.setPackedSint32Element(fieldNumber, index, value); 1424 } 1425 1426 /** 1427 * @param {number} fieldNumber 1428 * @param {!Iterable<number>} values 1429 */ 1430 setPackedSint32Iterable(fieldNumber, values) { 1431 this.kernel_.setPackedSint32Iterable(fieldNumber, values); 1432 } 1433 1434 /** 1435 * @param {number} fieldNumber 1436 * @param {number} index 1437 * @param {number} value 1438 * @throws {!Error} if index is out of range when check mode is critical 1439 */ 1440 setUnpackedSint32Element(fieldNumber, index, value) { 1441 this.kernel_.setUnpackedSint32Element(fieldNumber, index, value); 1442 } 1443 1444 /** 1445 * @param {number} fieldNumber 1446 * @param {!Iterable<number>} values 1447 */ 1448 setUnpackedSint32Iterable(fieldNumber, values) { 1449 this.kernel_.setUnpackedSint32Iterable(fieldNumber, values); 1450 } 1451 1452 /** 1453 * @param {number} fieldNumber 1454 * @param {!Int64} value 1455 */ 1456 addPackedSint64Element(fieldNumber, value) { 1457 this.kernel_.addPackedSint64Element(fieldNumber, value); 1458 } 1459 1460 /** 1461 * @param {number} fieldNumber 1462 * @param {!Iterable<!Int64>} values 1463 */ 1464 addPackedSint64Iterable(fieldNumber, values) { 1465 this.kernel_.addPackedSint64Iterable(fieldNumber, values); 1466 } 1467 1468 /** 1469 * @param {number} fieldNumber 1470 * @param {!Int64} value 1471 */ 1472 addUnpackedSint64Element(fieldNumber, value) { 1473 this.kernel_.addUnpackedSint64Element(fieldNumber, value); 1474 } 1475 1476 /** 1477 * @param {number} fieldNumber 1478 * @param {!Iterable<!Int64>} values 1479 */ 1480 addUnpackedSint64Iterable(fieldNumber, values) { 1481 this.kernel_.addUnpackedSint64Iterable(fieldNumber, values); 1482 } 1483 1484 /** 1485 * @param {number} fieldNumber 1486 * @param {number} index 1487 * @param {!Int64} value 1488 * @throws {!Error} if index is out of range when check mode is critical 1489 */ 1490 setPackedSint64Element(fieldNumber, index, value) { 1491 this.kernel_.setPackedSint64Element(fieldNumber, index, value); 1492 } 1493 1494 /** 1495 * @param {number} fieldNumber 1496 * @param {!Iterable<!Int64>} values 1497 */ 1498 setPackedSint64Iterable(fieldNumber, values) { 1499 this.kernel_.setPackedSint64Iterable(fieldNumber, values); 1500 } 1501 1502 /** 1503 * @param {number} fieldNumber 1504 * @param {number} index 1505 * @param {!Int64} value 1506 * @throws {!Error} if index is out of range when check mode is critical 1507 */ 1508 setUnpackedSint64Element(fieldNumber, index, value) { 1509 this.kernel_.setUnpackedSint64Element(fieldNumber, index, value); 1510 } 1511 1512 /** 1513 * @param {number} fieldNumber 1514 * @param {!Iterable<!Int64>} values 1515 */ 1516 setUnpackedSint64Iterable(fieldNumber, values) { 1517 this.kernel_.setUnpackedSint64Iterable(fieldNumber, values); 1518 } 1519 1520 /** 1521 * @param {number} fieldNumber 1522 * @param {number} value 1523 */ 1524 addPackedUint32Element(fieldNumber, value) { 1525 this.kernel_.addPackedUint32Element(fieldNumber, value); 1526 } 1527 1528 /** 1529 * @param {number} fieldNumber 1530 * @param {!Iterable<number>} values 1531 */ 1532 addPackedUint32Iterable(fieldNumber, values) { 1533 this.kernel_.addPackedUint32Iterable(fieldNumber, values); 1534 } 1535 1536 /** 1537 * @param {number} fieldNumber 1538 * @param {number} value 1539 */ 1540 addUnpackedUint32Element(fieldNumber, value) { 1541 this.kernel_.addUnpackedUint32Element(fieldNumber, value); 1542 } 1543 1544 /** 1545 * @param {number} fieldNumber 1546 * @param {!Iterable<number>} values 1547 */ 1548 addUnpackedUint32Iterable(fieldNumber, values) { 1549 this.kernel_.addUnpackedUint32Iterable(fieldNumber, values); 1550 } 1551 1552 /** 1553 * @param {number} fieldNumber 1554 * @param {number} index 1555 * @param {number} value 1556 * @throws {!Error} if index is out of range when check mode is critical 1557 */ 1558 setPackedUint32Element(fieldNumber, index, value) { 1559 this.kernel_.setPackedUint32Element(fieldNumber, index, value); 1560 } 1561 1562 /** 1563 * @param {number} fieldNumber 1564 * @param {!Iterable<number>} values 1565 */ 1566 setPackedUint32Iterable(fieldNumber, values) { 1567 this.kernel_.setPackedUint32Iterable(fieldNumber, values); 1568 } 1569 1570 /** 1571 * @param {number} fieldNumber 1572 * @param {number} index 1573 * @param {number} value 1574 * @throws {!Error} if index is out of range when check mode is critical 1575 */ 1576 setUnpackedUint32Element(fieldNumber, index, value) { 1577 this.kernel_.setUnpackedUint32Element(fieldNumber, index, value); 1578 } 1579 1580 /** 1581 * @param {number} fieldNumber 1582 * @param {!Iterable<number>} values 1583 */ 1584 setUnpackedUint32Iterable(fieldNumber, values) { 1585 this.kernel_.setUnpackedUint32Iterable(fieldNumber, values); 1586 } 1587 1588 /** 1589 * @param {number} fieldNumber 1590 * @param {!Int64} value 1591 */ 1592 addPackedUint64Element(fieldNumber, value) { 1593 this.kernel_.addPackedUint64Element(fieldNumber, value); 1594 } 1595 1596 /** 1597 * @param {number} fieldNumber 1598 * @param {!Iterable<!Int64>} values 1599 */ 1600 addPackedUint64Iterable(fieldNumber, values) { 1601 this.kernel_.addPackedUint64Iterable(fieldNumber, values); 1602 } 1603 1604 /** 1605 * @param {number} fieldNumber 1606 * @param {!Int64} value 1607 */ 1608 addUnpackedUint64Element(fieldNumber, value) { 1609 this.kernel_.addUnpackedUint64Element(fieldNumber, value); 1610 } 1611 1612 /** 1613 * @param {number} fieldNumber 1614 * @param {!Iterable<!Int64>} values 1615 */ 1616 addUnpackedUint64Iterable(fieldNumber, values) { 1617 this.kernel_.addUnpackedUint64Iterable(fieldNumber, values); 1618 } 1619 1620 /** 1621 * @param {number} fieldNumber 1622 * @param {number} index 1623 * @param {!Int64} value 1624 * @throws {!Error} if index is out of range when check mode is critical 1625 */ 1626 setPackedUint64Element(fieldNumber, index, value) { 1627 this.kernel_.setPackedUint64Element(fieldNumber, index, value); 1628 } 1629 1630 /** 1631 * @param {number} fieldNumber 1632 * @param {!Iterable<!Int64>} values 1633 */ 1634 setPackedUint64Iterable(fieldNumber, values) { 1635 this.kernel_.setPackedUint64Iterable(fieldNumber, values); 1636 } 1637 1638 /** 1639 * @param {number} fieldNumber 1640 * @param {number} index 1641 * @param {!Int64} value 1642 * @throws {!Error} if index is out of range when check mode is critical 1643 */ 1644 setUnpackedUint64Element(fieldNumber, index, value) { 1645 this.kernel_.setUnpackedUint64Element(fieldNumber, index, value); 1646 } 1647 1648 /** 1649 * @param {number} fieldNumber 1650 * @param {!Iterable<!Int64>} values 1651 */ 1652 setUnpackedUint64Iterable(fieldNumber, values) { 1653 this.kernel_.setUnpackedUint64Iterable(fieldNumber, values); 1654 } 1655 1656 /** 1657 * @param {number} fieldNumber 1658 * @param {!Iterable<!ByteString>} values 1659 */ 1660 setRepeatedBytesIterable(fieldNumber, values) { 1661 this.kernel_.setRepeatedBytesIterable(fieldNumber, values); 1662 } 1663 1664 /** 1665 * @param {number} fieldNumber 1666 * @param {!Iterable<!ByteString>} values 1667 */ 1668 addRepeatedBytesIterable(fieldNumber, values) { 1669 this.kernel_.addRepeatedBytesIterable(fieldNumber, values); 1670 } 1671 1672 /** 1673 * @param {number} fieldNumber 1674 * @param {number} index 1675 * @param {!ByteString} value 1676 * @throws {!Error} if index is out of range when check mode is critical 1677 */ 1678 setRepeatedBytesElement(fieldNumber, index, value) { 1679 this.kernel_.setRepeatedBytesElement(fieldNumber, index, value); 1680 } 1681 1682 /** 1683 * @param {number} fieldNumber 1684 * @param {!ByteString} value 1685 */ 1686 addRepeatedBytesElement(fieldNumber, value) { 1687 this.kernel_.addRepeatedBytesElement(fieldNumber, value); 1688 } 1689 1690 1691 /** 1692 * @param {number} fieldNumber 1693 * @param {!Iterable<string>} values 1694 */ 1695 setRepeatedStringIterable(fieldNumber, values) { 1696 this.kernel_.setRepeatedStringIterable(fieldNumber, values); 1697 } 1698 1699 /** 1700 * @param {number} fieldNumber 1701 * @param {!Iterable<string>} values 1702 */ 1703 addRepeatedStringIterable(fieldNumber, values) { 1704 this.kernel_.addRepeatedStringIterable(fieldNumber, values); 1705 } 1706 1707 /** 1708 * @param {number} fieldNumber 1709 * @param {number} index 1710 * @param {string} value 1711 * @throws {!Error} if index is out of range when check mode is critical 1712 */ 1713 setRepeatedStringElement(fieldNumber, index, value) { 1714 this.kernel_.setRepeatedStringElement(fieldNumber, index, value); 1715 } 1716 1717 /** 1718 * @param {number} fieldNumber 1719 * @param {string} value 1720 */ 1721 addRepeatedStringElement(fieldNumber, value) { 1722 this.kernel_.addRepeatedStringElement(fieldNumber, value); 1723 } 1724 1725 /** 1726 * @param {number} fieldNumber 1727 * @param {!Iterable<T>} values 1728 * @template T 1729 */ 1730 setRepeatedMessageIterable(fieldNumber, values) { 1731 this.kernel_.setRepeatedMessageIterable(fieldNumber, values); 1732 } 1733 1734 /** 1735 * @param {number} fieldNumber 1736 * @param {!Iterable<T>} values 1737 * @param {function(!Kernel):T} instanceCreator 1738 * @template T 1739 */ 1740 addRepeatedMessageIterable(fieldNumber, values, instanceCreator) { 1741 this.kernel_.addRepeatedMessageIterable( 1742 fieldNumber, values, instanceCreator); 1743 } 1744 1745 /** 1746 * @param {number} fieldNumber 1747 * @param {T} value 1748 * @param {function(!Kernel):T} instanceCreator 1749 * @param {number} index 1750 * @throws {!Error} if index is out of range when check mode is critical 1751 * @template T 1752 */ 1753 setRepeatedMessageElement(fieldNumber, value, instanceCreator, index) { 1754 this.kernel_.setRepeatedMessageElement( 1755 fieldNumber, value, instanceCreator, index); 1756 } 1757 1758 /** 1759 * @param {number} fieldNumber 1760 * @param {T} value 1761 * @param {function(!Kernel):T} instanceCreator 1762 * @template T 1763 */ 1764 addRepeatedMessageElement(fieldNumber, value, instanceCreator) { 1765 this.kernel_.addRepeatedMessageElement(fieldNumber, value, instanceCreator); 1766 } 1767} 1768 1769exports = TestMessage; 1770