Debian Codegraph @

closure-library/closure/goog/proto2/test.pb.js

raw
1 // Copyright 2008 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 // All other code copyright its respective owners(s).
15
16 /**
17 * @fileoverview Generated Protocol Buffer code for file
18 * closure/goog/proto2/test.proto.
19 */
20
21 goog.provide('proto2.TestAllTypes');
22 goog.provide('proto2.TestAllTypes.NestedEnum');
23 goog.provide('proto2.TestAllTypes.NestedMessage');
24 goog.provide('proto2.TestAllTypes.OptionalGroup');
25 goog.provide('proto2.TestAllTypes.RepeatedGroup');
26 goog.provide('proto2.TestDefaultChild');
27 goog.provide('proto2.TestDefaultParent');
28 goog.setTestOnly('proto2.TestAllTypes');
29
30 goog.require('goog.proto2.Message');
31
32
33
34 /**
35 * Message TestAllTypes.
36 * @constructor
37 * @extends {goog.proto2.Message}
38 * @final
39 */
40 proto2.TestAllTypes = function() {
41 goog.proto2.Message.call(this);
42 };
43 goog.inherits(proto2.TestAllTypes, goog.proto2.Message);
44
45
46 /**
47 * Descriptor for this message, deserialized lazily in getDescriptor().
48 * @private {?goog.proto2.Descriptor}
49 */
50 proto2.TestAllTypes.descriptor_ = null;
51
52
53 /**
54 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
55 * @return {!proto2.TestAllTypes} The cloned message.
56 * @override
57 */
58 proto2.TestAllTypes.prototype.clone;
59
60
61 /**
62 * Gets the value of the optional_int32 field.
63 * @return {?number} The value.
64 */
65 proto2.TestAllTypes.prototype.getOptionalInt32 = function() {
66 return /** @type {?number} */ (this.get$Value(1));
67 };
68
69
70 /**
71 * Gets the value of the optional_int32 field or the default value if not set.
72 * @return {number} The value.
73 */
74 proto2.TestAllTypes.prototype.getOptionalInt32OrDefault = function() {
75 return /** @type {number} */ (this.get$ValueOrDefault(1));
76 };
77
78
79 /**
80 * Sets the value of the optional_int32 field.
81 * @param {number} value The value.
82 */
83 proto2.TestAllTypes.prototype.setOptionalInt32 = function(value) {
84 this.set$Value(1, value);
85 };
86
87
88 /**
89 * @return {boolean} Whether the optional_int32 field has a value.
90 */
91 proto2.TestAllTypes.prototype.hasOptionalInt32 = function() {
92 return this.has$Value(1);
93 };
94
95
96 /**
97 * @return {number} The number of values in the optional_int32 field.
98 */
99 proto2.TestAllTypes.prototype.optionalInt32Count = function() {
100 return this.count$Values(1);
101 };
102
103
104 /**
105 * Clears the values in the optional_int32 field.
106 */
107 proto2.TestAllTypes.prototype.clearOptionalInt32 = function() {
108 this.clear$Field(1);
109 };
110
111
112 /**
113 * Gets the value of the optional_int64 field.
114 * @return {?string} The value.
115 */
116 proto2.TestAllTypes.prototype.getOptionalInt64 = function() {
117 return /** @type {?string} */ (this.get$Value(2));
118 };
119
120
121 /**
122 * Gets the value of the optional_int64 field or the default value if not set.
123 * @return {string} The value.
124 */
125 proto2.TestAllTypes.prototype.getOptionalInt64OrDefault = function() {
126 return /** @type {string} */ (this.get$ValueOrDefault(2));
127 };
128
129
130 /**
131 * Sets the value of the optional_int64 field.
132 * @param {string} value The value.
133 */
134 proto2.TestAllTypes.prototype.setOptionalInt64 = function(value) {
135 this.set$Value(2, value);
136 };
137
138
139 /**
140 * @return {boolean} Whether the optional_int64 field has a value.
141 */
142 proto2.TestAllTypes.prototype.hasOptionalInt64 = function() {
143 return this.has$Value(2);
144 };
145
146
147 /**
148 * @return {number} The number of values in the optional_int64 field.
149 */
150 proto2.TestAllTypes.prototype.optionalInt64Count = function() {
151 return this.count$Values(2);
152 };
153
154
155 /**
156 * Clears the values in the optional_int64 field.
157 */
158 proto2.TestAllTypes.prototype.clearOptionalInt64 = function() {
159 this.clear$Field(2);
160 };
161
162
163 /**
164 * Gets the value of the optional_uint32 field.
165 * @return {?number} The value.
166 */
167 proto2.TestAllTypes.prototype.getOptionalUint32 = function() {
168 return /** @type {?number} */ (this.get$Value(3));
169 };
170
171
172 /**
173 * Gets the value of the optional_uint32 field or the default value if not set.
174 * @return {number} The value.
175 */
176 proto2.TestAllTypes.prototype.getOptionalUint32OrDefault = function() {
177 return /** @type {number} */ (this.get$ValueOrDefault(3));
178 };
179
180
181 /**
182 * Sets the value of the optional_uint32 field.
183 * @param {number} value The value.
184 */
185 proto2.TestAllTypes.prototype.setOptionalUint32 = function(value) {
186 this.set$Value(3, value);
187 };
188
189
190 /**
191 * @return {boolean} Whether the optional_uint32 field has a value.
192 */
193 proto2.TestAllTypes.prototype.hasOptionalUint32 = function() {
194 return this.has$Value(3);
195 };
196
197
198 /**
199 * @return {number} The number of values in the optional_uint32 field.
200 */
201 proto2.TestAllTypes.prototype.optionalUint32Count = function() {
202 return this.count$Values(3);
203 };
204
205
206 /**
207 * Clears the values in the optional_uint32 field.
208 */
209 proto2.TestAllTypes.prototype.clearOptionalUint32 = function() {
210 this.clear$Field(3);
211 };
212
213
214 /**
215 * Gets the value of the optional_uint64 field.
216 * @return {?string} The value.
217 */
218 proto2.TestAllTypes.prototype.getOptionalUint64 = function() {
219 return /** @type {?string} */ (this.get$Value(4));
220 };
221
222
223 /**
224 * Gets the value of the optional_uint64 field or the default value if not set.
225 * @return {string} The value.
226 */
227 proto2.TestAllTypes.prototype.getOptionalUint64OrDefault = function() {
228 return /** @type {string} */ (this.get$ValueOrDefault(4));
229 };
230
231
232 /**
233 * Sets the value of the optional_uint64 field.
234 * @param {string} value The value.
235 */
236 proto2.TestAllTypes.prototype.setOptionalUint64 = function(value) {
237 this.set$Value(4, value);
238 };
239
240
241 /**
242 * @return {boolean} Whether the optional_uint64 field has a value.
243 */
244 proto2.TestAllTypes.prototype.hasOptionalUint64 = function() {
245 return this.has$Value(4);
246 };
247
248
249 /**
250 * @return {number} The number of values in the optional_uint64 field.
251 */
252 proto2.TestAllTypes.prototype.optionalUint64Count = function() {
253 return this.count$Values(4);
254 };
255
256
257 /**
258 * Clears the values in the optional_uint64 field.
259 */
260 proto2.TestAllTypes.prototype.clearOptionalUint64 = function() {
261 this.clear$Field(4);
262 };
263
264
265 /**
266 * Gets the value of the optional_sint32 field.
267 * @return {?number} The value.
268 */
269 proto2.TestAllTypes.prototype.getOptionalSint32 = function() {
270 return /** @type {?number} */ (this.get$Value(5));
271 };
272
273
274 /**
275 * Gets the value of the optional_sint32 field or the default value if not set.
276 * @return {number} The value.
277 */
278 proto2.TestAllTypes.prototype.getOptionalSint32OrDefault = function() {
279 return /** @type {number} */ (this.get$ValueOrDefault(5));
280 };
281
282
283 /**
284 * Sets the value of the optional_sint32 field.
285 * @param {number} value The value.
286 */
287 proto2.TestAllTypes.prototype.setOptionalSint32 = function(value) {
288 this.set$Value(5, value);
289 };
290
291
292 /**
293 * @return {boolean} Whether the optional_sint32 field has a value.
294 */
295 proto2.TestAllTypes.prototype.hasOptionalSint32 = function() {
296 return this.has$Value(5);
297 };
298
299
300 /**
301 * @return {number} The number of values in the optional_sint32 field.
302 */
303 proto2.TestAllTypes.prototype.optionalSint32Count = function() {
304 return this.count$Values(5);
305 };
306
307
308 /**
309 * Clears the values in the optional_sint32 field.
310 */
311 proto2.TestAllTypes.prototype.clearOptionalSint32 = function() {
312 this.clear$Field(5);
313 };
314
315
316 /**
317 * Gets the value of the optional_sint64 field.
318 * @return {?string} The value.
319 */
320 proto2.TestAllTypes.prototype.getOptionalSint64 = function() {
321 return /** @type {?string} */ (this.get$Value(6));
322 };
323
324
325 /**
326 * Gets the value of the optional_sint64 field or the default value if not set.
327 * @return {string} The value.
328 */
329 proto2.TestAllTypes.prototype.getOptionalSint64OrDefault = function() {
330 return /** @type {string} */ (this.get$ValueOrDefault(6));
331 };
332
333
334 /**
335 * Sets the value of the optional_sint64 field.
336 * @param {string} value The value.
337 */
338 proto2.TestAllTypes.prototype.setOptionalSint64 = function(value) {
339 this.set$Value(6, value);
340 };
341
342
343 /**
344 * @return {boolean} Whether the optional_sint64 field has a value.
345 */
346 proto2.TestAllTypes.prototype.hasOptionalSint64 = function() {
347 return this.has$Value(6);
348 };
349
350
351 /**
352 * @return {number} The number of values in the optional_sint64 field.
353 */
354 proto2.TestAllTypes.prototype.optionalSint64Count = function() {
355 return this.count$Values(6);
356 };
357
358
359 /**
360 * Clears the values in the optional_sint64 field.
361 */
362 proto2.TestAllTypes.prototype.clearOptionalSint64 = function() {
363 this.clear$Field(6);
364 };
365
366
367 /**
368 * Gets the value of the optional_fixed32 field.
369 * @return {?number} The value.
370 */
371 proto2.TestAllTypes.prototype.getOptionalFixed32 = function() {
372 return /** @type {?number} */ (this.get$Value(7));
373 };
374
375
376 /**
377 * Gets the value of the optional_fixed32 field or the default value if not set.
378 * @return {number} The value.
379 */
380 proto2.TestAllTypes.prototype.getOptionalFixed32OrDefault = function() {
381 return /** @type {number} */ (this.get$ValueOrDefault(7));
382 };
383
384
385 /**
386 * Sets the value of the optional_fixed32 field.
387 * @param {number} value The value.
388 */
389 proto2.TestAllTypes.prototype.setOptionalFixed32 = function(value) {
390 this.set$Value(7, value);
391 };
392
393
394 /**
395 * @return {boolean} Whether the optional_fixed32 field has a value.
396 */
397 proto2.TestAllTypes.prototype.hasOptionalFixed32 = function() {
398 return this.has$Value(7);
399 };
400
401
402 /**
403 * @return {number} The number of values in the optional_fixed32 field.
404 */
405 proto2.TestAllTypes.prototype.optionalFixed32Count = function() {
406 return this.count$Values(7);
407 };
408
409
410 /**
411 * Clears the values in the optional_fixed32 field.
412 */
413 proto2.TestAllTypes.prototype.clearOptionalFixed32 = function() {
414 this.clear$Field(7);
415 };
416
417
418 /**
419 * Gets the value of the optional_fixed64 field.
420 * @return {?string} The value.
421 */
422 proto2.TestAllTypes.prototype.getOptionalFixed64 = function() {
423 return /** @type {?string} */ (this.get$Value(8));
424 };
425
426
427 /**
428 * Gets the value of the optional_fixed64 field or the default value if not set.
429 * @return {string} The value.
430 */
431 proto2.TestAllTypes.prototype.getOptionalFixed64OrDefault = function() {
432 return /** @type {string} */ (this.get$ValueOrDefault(8));
433 };
434
435
436 /**
437 * Sets the value of the optional_fixed64 field.
438 * @param {string} value The value.
439 */
440 proto2.TestAllTypes.prototype.setOptionalFixed64 = function(value) {
441 this.set$Value(8, value);
442 };
443
444
445 /**
446 * @return {boolean} Whether the optional_fixed64 field has a value.
447 */
448 proto2.TestAllTypes.prototype.hasOptionalFixed64 = function() {
449 return this.has$Value(8);
450 };
451
452
453 /**
454 * @return {number} The number of values in the optional_fixed64 field.
455 */
456 proto2.TestAllTypes.prototype.optionalFixed64Count = function() {
457 return this.count$Values(8);
458 };
459
460
461 /**
462 * Clears the values in the optional_fixed64 field.
463 */
464 proto2.TestAllTypes.prototype.clearOptionalFixed64 = function() {
465 this.clear$Field(8);
466 };
467
468
469 /**
470 * Gets the value of the optional_sfixed32 field.
471 * @return {?number} The value.
472 */
473 proto2.TestAllTypes.prototype.getOptionalSfixed32 = function() {
474 return /** @type {?number} */ (this.get$Value(9));
475 };
476
477
478 /**
479 * Gets the value of the optional_sfixed32 field or the default value if not set.
480 * @return {number} The value.
481 */
482 proto2.TestAllTypes.prototype.getOptionalSfixed32OrDefault = function() {
483 return /** @type {number} */ (this.get$ValueOrDefault(9));
484 };
485
486
487 /**
488 * Sets the value of the optional_sfixed32 field.
489 * @param {number} value The value.
490 */
491 proto2.TestAllTypes.prototype.setOptionalSfixed32 = function(value) {
492 this.set$Value(9, value);
493 };
494
495
496 /**
497 * @return {boolean} Whether the optional_sfixed32 field has a value.
498 */
499 proto2.TestAllTypes.prototype.hasOptionalSfixed32 = function() {
500 return this.has$Value(9);
501 };
502
503
504 /**
505 * @return {number} The number of values in the optional_sfixed32 field.
506 */
507 proto2.TestAllTypes.prototype.optionalSfixed32Count = function() {
508 return this.count$Values(9);
509 };
510
511
512 /**
513 * Clears the values in the optional_sfixed32 field.
514 */
515 proto2.TestAllTypes.prototype.clearOptionalSfixed32 = function() {
516 this.clear$Field(9);
517 };
518
519
520 /**
521 * Gets the value of the optional_sfixed64 field.
522 * @return {?string} The value.
523 */
524 proto2.TestAllTypes.prototype.getOptionalSfixed64 = function() {
525 return /** @type {?string} */ (this.get$Value(10));
526 };
527
528
529 /**
530 * Gets the value of the optional_sfixed64 field or the default value if not set.
531 * @return {string} The value.
532 */
533 proto2.TestAllTypes.prototype.getOptionalSfixed64OrDefault = function() {
534 return /** @type {string} */ (this.get$ValueOrDefault(10));
535 };
536
537
538 /**
539 * Sets the value of the optional_sfixed64 field.
540 * @param {string} value The value.
541 */
542 proto2.TestAllTypes.prototype.setOptionalSfixed64 = function(value) {
543 this.set$Value(10, value);
544 };
545
546
547 /**
548 * @return {boolean} Whether the optional_sfixed64 field has a value.
549 */
550 proto2.TestAllTypes.prototype.hasOptionalSfixed64 = function() {
551 return this.has$Value(10);
552 };
553
554
555 /**
556 * @return {number} The number of values in the optional_sfixed64 field.
557 */
558 proto2.TestAllTypes.prototype.optionalSfixed64Count = function() {
559 return this.count$Values(10);
560 };
561
562
563 /**
564 * Clears the values in the optional_sfixed64 field.
565 */
566 proto2.TestAllTypes.prototype.clearOptionalSfixed64 = function() {
567 this.clear$Field(10);
568 };
569
570
571 /**
572 * Gets the value of the optional_float field.
573 * @return {?number} The value.
574 */
575 proto2.TestAllTypes.prototype.getOptionalFloat = function() {
576 return /** @type {?number} */ (this.get$Value(11));
577 };
578
579
580 /**
581 * Gets the value of the optional_float field or the default value if not set.
582 * @return {number} The value.
583 */
584 proto2.TestAllTypes.prototype.getOptionalFloatOrDefault = function() {
585 return /** @type {number} */ (this.get$ValueOrDefault(11));
586 };
587
588
589 /**
590 * Sets the value of the optional_float field.
591 * @param {number} value The value.
592 */
593 proto2.TestAllTypes.prototype.setOptionalFloat = function(value) {
594 this.set$Value(11, value);
595 };
596
597
598 /**
599 * @return {boolean} Whether the optional_float field has a value.
600 */
601 proto2.TestAllTypes.prototype.hasOptionalFloat = function() {
602 return this.has$Value(11);
603 };
604
605
606 /**
607 * @return {number} The number of values in the optional_float field.
608 */
609 proto2.TestAllTypes.prototype.optionalFloatCount = function() {
610 return this.count$Values(11);
611 };
612
613
614 /**
615 * Clears the values in the optional_float field.
616 */
617 proto2.TestAllTypes.prototype.clearOptionalFloat = function() {
618 this.clear$Field(11);
619 };
620
621
622 /**
623 * Gets the value of the optional_double field.
624 * @return {?number} The value.
625 */
626 proto2.TestAllTypes.prototype.getOptionalDouble = function() {
627 return /** @type {?number} */ (this.get$Value(12));
628 };
629
630
631 /**
632 * Gets the value of the optional_double field or the default value if not set.
633 * @return {number} The value.
634 */
635 proto2.TestAllTypes.prototype.getOptionalDoubleOrDefault = function() {
636 return /** @type {number} */ (this.get$ValueOrDefault(12));
637 };
638
639
640 /**
641 * Sets the value of the optional_double field.
642 * @param {number} value The value.
643 */
644 proto2.TestAllTypes.prototype.setOptionalDouble = function(value) {
645 this.set$Value(12, value);
646 };
647
648
649 /**
650 * @return {boolean} Whether the optional_double field has a value.
651 */
652 proto2.TestAllTypes.prototype.hasOptionalDouble = function() {
653 return this.has$Value(12);
654 };
655
656
657 /**
658 * @return {number} The number of values in the optional_double field.
659 */
660 proto2.TestAllTypes.prototype.optionalDoubleCount = function() {
661 return this.count$Values(12);
662 };
663
664
665 /**
666 * Clears the values in the optional_double field.
667 */
668 proto2.TestAllTypes.prototype.clearOptionalDouble = function() {
669 this.clear$Field(12);
670 };
671
672
673 /**
674 * Gets the value of the optional_bool field.
675 * @return {?boolean} The value.
676 */
677 proto2.TestAllTypes.prototype.getOptionalBool = function() {
678 return /** @type {?boolean} */ (this.get$Value(13));
679 };
680
681
682 /**
683 * Gets the value of the optional_bool field or the default value if not set.
684 * @return {boolean} The value.
685 */
686 proto2.TestAllTypes.prototype.getOptionalBoolOrDefault = function() {
687 return /** @type {boolean} */ (this.get$ValueOrDefault(13));
688 };
689
690
691 /**
692 * Sets the value of the optional_bool field.
693 * @param {boolean} value The value.
694 */
695 proto2.TestAllTypes.prototype.setOptionalBool = function(value) {
696 this.set$Value(13, value);
697 };
698
699
700 /**
701 * @return {boolean} Whether the optional_bool field has a value.
702 */
703 proto2.TestAllTypes.prototype.hasOptionalBool = function() {
704 return this.has$Value(13);
705 };
706
707
708 /**
709 * @return {number} The number of values in the optional_bool field.
710 */
711 proto2.TestAllTypes.prototype.optionalBoolCount = function() {
712 return this.count$Values(13);
713 };
714
715
716 /**
717 * Clears the values in the optional_bool field.
718 */
719 proto2.TestAllTypes.prototype.clearOptionalBool = function() {
720 this.clear$Field(13);
721 };
722
723
724 /**
725 * Gets the value of the optional_string field.
726 * @return {?string} The value.
727 */
728 proto2.TestAllTypes.prototype.getOptionalString = function() {
729 return /** @type {?string} */ (this.get$Value(14));
730 };
731
732
733 /**
734 * Gets the value of the optional_string field or the default value if not set.
735 * @return {string} The value.
736 */
737 proto2.TestAllTypes.prototype.getOptionalStringOrDefault = function() {
738 return /** @type {string} */ (this.get$ValueOrDefault(14));
739 };
740
741
742 /**
743 * Sets the value of the optional_string field.
744 * @param {string} value The value.
745 */
746 proto2.TestAllTypes.prototype.setOptionalString = function(value) {
747 this.set$Value(14, value);
748 };
749
750
751 /**
752 * @return {boolean} Whether the optional_string field has a value.
753 */
754 proto2.TestAllTypes.prototype.hasOptionalString = function() {
755 return this.has$Value(14);
756 };
757
758
759 /**
760 * @return {number} The number of values in the optional_string field.
761 */
762 proto2.TestAllTypes.prototype.optionalStringCount = function() {
763 return this.count$Values(14);
764 };
765
766
767 /**
768 * Clears the values in the optional_string field.
769 */
770 proto2.TestAllTypes.prototype.clearOptionalString = function() {
771 this.clear$Field(14);
772 };
773
774
775 /**
776 * Gets the value of the optional_bytes field.
777 * @return {?string} The value.
778 */
779 proto2.TestAllTypes.prototype.getOptionalBytes = function() {
780 return /** @type {?string} */ (this.get$Value(15));
781 };
782
783
784 /**
785 * Gets the value of the optional_bytes field or the default value if not set.
786 * @return {string} The value.
787 */
788 proto2.TestAllTypes.prototype.getOptionalBytesOrDefault = function() {
789 return /** @type {string} */ (this.get$ValueOrDefault(15));
790 };
791
792
793 /**
794 * Sets the value of the optional_bytes field.
795 * @param {string} value The value.
796 */
797 proto2.TestAllTypes.prototype.setOptionalBytes = function(value) {
798 this.set$Value(15, value);
799 };
800
801
802 /**
803 * @return {boolean} Whether the optional_bytes field has a value.
804 */
805 proto2.TestAllTypes.prototype.hasOptionalBytes = function() {
806 return this.has$Value(15);
807 };
808
809
810 /**
811 * @return {number} The number of values in the optional_bytes field.
812 */
813 proto2.TestAllTypes.prototype.optionalBytesCount = function() {
814 return this.count$Values(15);
815 };
816
817
818 /**
819 * Clears the values in the optional_bytes field.
820 */
821 proto2.TestAllTypes.prototype.clearOptionalBytes = function() {
822 this.clear$Field(15);
823 };
824
825
826 /**
827 * Gets the value of the optionalgroup field.
828 * @return {?proto2.TestAllTypes.OptionalGroup} The value.
829 */
830 proto2.TestAllTypes.prototype.getOptionalgroup = function() {
831 return /** @type {?proto2.TestAllTypes.OptionalGroup} */ (this.get$Value(16));
832 };
833
834
835 /**
836 * Gets the value of the optionalgroup field or the default value if not set.
837 * @return {!proto2.TestAllTypes.OptionalGroup} The value.
838 */
839 proto2.TestAllTypes.prototype.getOptionalgroupOrDefault = function() {
840 return /** @type {!proto2.TestAllTypes.OptionalGroup} */ (this.get$ValueOrDefault(16));
841 };
842
843
844 /**
845 * Sets the value of the optionalgroup field.
846 * @param {!proto2.TestAllTypes.OptionalGroup} value The value.
847 */
848 proto2.TestAllTypes.prototype.setOptionalgroup = function(value) {
849 this.set$Value(16, value);
850 };
851
852
853 /**
854 * @return {boolean} Whether the optionalgroup field has a value.
855 */
856 proto2.TestAllTypes.prototype.hasOptionalgroup = function() {
857 return this.has$Value(16);
858 };
859
860
861 /**
862 * @return {number} The number of values in the optionalgroup field.
863 */
864 proto2.TestAllTypes.prototype.optionalgroupCount = function() {
865 return this.count$Values(16);
866 };
867
868
869 /**
870 * Clears the values in the optionalgroup field.
871 */
872 proto2.TestAllTypes.prototype.clearOptionalgroup = function() {
873 this.clear$Field(16);
874 };
875
876
877 /**
878 * Gets the value of the optional_nested_message field.
879 * @return {?proto2.TestAllTypes.NestedMessage} The value.
880 */
881 proto2.TestAllTypes.prototype.getOptionalNestedMessage = function() {
882 return /** @type {?proto2.TestAllTypes.NestedMessage} */ (this.get$Value(18));
883 };
884
885
886 /**
887 * Gets the value of the optional_nested_message field or the default value if not set.
888 * @return {!proto2.TestAllTypes.NestedMessage} The value.
889 */
890 proto2.TestAllTypes.prototype.getOptionalNestedMessageOrDefault = function() {
891 return /** @type {!proto2.TestAllTypes.NestedMessage} */ (this.get$ValueOrDefault(18));
892 };
893
894
895 /**
896 * Sets the value of the optional_nested_message field.
897 * @param {!proto2.TestAllTypes.NestedMessage} value The value.
898 */
899 proto2.TestAllTypes.prototype.setOptionalNestedMessage = function(value) {
900 this.set$Value(18, value);
901 };
902
903
904 /**
905 * @return {boolean} Whether the optional_nested_message field has a value.
906 */
907 proto2.TestAllTypes.prototype.hasOptionalNestedMessage = function() {
908 return this.has$Value(18);
909 };
910
911
912 /**
913 * @return {number} The number of values in the optional_nested_message field.
914 */
915 proto2.TestAllTypes.prototype.optionalNestedMessageCount = function() {
916 return this.count$Values(18);
917 };
918
919
920 /**
921 * Clears the values in the optional_nested_message field.
922 */
923 proto2.TestAllTypes.prototype.clearOptionalNestedMessage = function() {
924 this.clear$Field(18);
925 };
926
927
928 /**
929 * Gets the value of the optional_nested_enum field.
930 * @return {?proto2.TestAllTypes.NestedEnum} The value.
931 */
932 proto2.TestAllTypes.prototype.getOptionalNestedEnum = function() {
933 return /** @type {?proto2.TestAllTypes.NestedEnum} */ (this.get$Value(21));
934 };
935
936
937 /**
938 * Gets the value of the optional_nested_enum field or the default value if not set.
939 * @return {!proto2.TestAllTypes.NestedEnum} The value.
940 */
941 proto2.TestAllTypes.prototype.getOptionalNestedEnumOrDefault = function() {
942 return /** @type {!proto2.TestAllTypes.NestedEnum} */ (this.get$ValueOrDefault(21));
943 };
944
945
946 /**
947 * Sets the value of the optional_nested_enum field.
948 * @param {!proto2.TestAllTypes.NestedEnum} value The value.
949 */
950 proto2.TestAllTypes.prototype.setOptionalNestedEnum = function(value) {
951 this.set$Value(21, value);
952 };
953
954
955 /**
956 * @return {boolean} Whether the optional_nested_enum field has a value.
957 */
958 proto2.TestAllTypes.prototype.hasOptionalNestedEnum = function() {
959 return this.has$Value(21);
960 };
961
962
963 /**
964 * @return {number} The number of values in the optional_nested_enum field.
965 */
966 proto2.TestAllTypes.prototype.optionalNestedEnumCount = function() {
967 return this.count$Values(21);
968 };
969
970
971 /**
972 * Clears the values in the optional_nested_enum field.
973 */
974 proto2.TestAllTypes.prototype.clearOptionalNestedEnum = function() {
975 this.clear$Field(21);
976 };
977
978
979 /**
980 * Gets the value of the optional_int64_number field.
981 * @return {?number} The value.
982 */
983 proto2.TestAllTypes.prototype.getOptionalInt64Number = function() {
984 return /** @type {?number} */ (this.get$Value(50));
985 };
986
987
988 /**
989 * Gets the value of the optional_int64_number field or the default value if not set.
990 * @return {number} The value.
991 */
992 proto2.TestAllTypes.prototype.getOptionalInt64NumberOrDefault = function() {
993 return /** @type {number} */ (this.get$ValueOrDefault(50));
994 };
995
996
997 /**
998 * Sets the value of the optional_int64_number field.
999 * @param {number} value The value.
1000 */
1001 proto2.TestAllTypes.prototype.setOptionalInt64Number = function(value) {
1002 this.set$Value(50, value);
1003 };
1004
1005
1006 /**
1007 * @return {boolean} Whether the optional_int64_number field has a value.
1008 */
1009 proto2.TestAllTypes.prototype.hasOptionalInt64Number = function() {
1010 return this.has$Value(50);
1011 };
1012
1013
1014 /**
1015 * @return {number} The number of values in the optional_int64_number field.
1016 */
1017 proto2.TestAllTypes.prototype.optionalInt64NumberCount = function() {
1018 return this.count$Values(50);
1019 };
1020
1021
1022 /**
1023 * Clears the values in the optional_int64_number field.
1024 */
1025 proto2.TestAllTypes.prototype.clearOptionalInt64Number = function() {
1026 this.clear$Field(50);
1027 };
1028
1029
1030 /**
1031 * Gets the value of the optional_int64_string field.
1032 * @return {?string} The value.
1033 */
1034 proto2.TestAllTypes.prototype.getOptionalInt64String = function() {
1035 return /** @type {?string} */ (this.get$Value(51));
1036 };
1037
1038
1039 /**
1040 * Gets the value of the optional_int64_string field or the default value if not set.
1041 * @return {string} The value.
1042 */
1043 proto2.TestAllTypes.prototype.getOptionalInt64StringOrDefault = function() {
1044 return /** @type {string} */ (this.get$ValueOrDefault(51));
1045 };
1046
1047
1048 /**
1049 * Sets the value of the optional_int64_string field.
1050 * @param {string} value The value.
1051 */
1052 proto2.TestAllTypes.prototype.setOptionalInt64String = function(value) {
1053 this.set$Value(51, value);
1054 };
1055
1056
1057 /**
1058 * @return {boolean} Whether the optional_int64_string field has a value.
1059 */
1060 proto2.TestAllTypes.prototype.hasOptionalInt64String = function() {
1061 return this.has$Value(51);
1062 };
1063
1064
1065 /**
1066 * @return {number} The number of values in the optional_int64_string field.
1067 */
1068 proto2.TestAllTypes.prototype.optionalInt64StringCount = function() {
1069 return this.count$Values(51);
1070 };
1071
1072
1073 /**
1074 * Clears the values in the optional_int64_string field.
1075 */
1076 proto2.TestAllTypes.prototype.clearOptionalInt64String = function() {
1077 this.clear$Field(51);
1078 };
1079
1080
1081 /**
1082 * Gets the value of the repeated_int32 field at the index given.
1083 * @param {number} index The index to lookup.
1084 * @return {?number} The value.
1085 */
1086 proto2.TestAllTypes.prototype.getRepeatedInt32 = function(index) {
1087 return /** @type {?number} */ (this.get$Value(31, index));
1088 };
1089
1090
1091 /**
1092 * Gets the value of the repeated_int32 field at the index given or the default value if not set.
1093 * @param {number} index The index to lookup.
1094 * @return {number} The value.
1095 */
1096 proto2.TestAllTypes.prototype.getRepeatedInt32OrDefault = function(index) {
1097 return /** @type {number} */ (this.get$ValueOrDefault(31, index));
1098 };
1099
1100
1101 /**
1102 * Adds a value to the repeated_int32 field.
1103 * @param {number} value The value to add.
1104 */
1105 proto2.TestAllTypes.prototype.addRepeatedInt32 = function(value) {
1106 this.add$Value(31, value);
1107 };
1108
1109
1110 /**
1111 * Returns the array of values in the repeated_int32 field.
1112 * @return {!Array<number>} The values in the field.
1113 */
1114 proto2.TestAllTypes.prototype.repeatedInt32Array = function() {
1115 return /** @type {!Array<number>} */ (this.array$Values(31));
1116 };
1117
1118
1119 /**
1120 * @return {boolean} Whether the repeated_int32 field has a value.
1121 */
1122 proto2.TestAllTypes.prototype.hasRepeatedInt32 = function() {
1123 return this.has$Value(31);
1124 };
1125
1126
1127 /**
1128 * @return {number} The number of values in the repeated_int32 field.
1129 */
1130 proto2.TestAllTypes.prototype.repeatedInt32Count = function() {
1131 return this.count$Values(31);
1132 };
1133
1134
1135 /**
1136 * Clears the values in the repeated_int32 field.
1137 */
1138 proto2.TestAllTypes.prototype.clearRepeatedInt32 = function() {
1139 this.clear$Field(31);
1140 };
1141
1142
1143 /**
1144 * Gets the value of the repeated_int64 field at the index given.
1145 * @param {number} index The index to lookup.
1146 * @return {?string} The value.
1147 */
1148 proto2.TestAllTypes.prototype.getRepeatedInt64 = function(index) {
1149 return /** @type {?string} */ (this.get$Value(32, index));
1150 };
1151
1152
1153 /**
1154 * Gets the value of the repeated_int64 field at the index given or the default value if not set.
1155 * @param {number} index The index to lookup.
1156 * @return {string} The value.
1157 */
1158 proto2.TestAllTypes.prototype.getRepeatedInt64OrDefault = function(index) {
1159 return /** @type {string} */ (this.get$ValueOrDefault(32, index));
1160 };
1161
1162
1163 /**
1164 * Adds a value to the repeated_int64 field.
1165 * @param {string} value The value to add.
1166 */
1167 proto2.TestAllTypes.prototype.addRepeatedInt64 = function(value) {
1168 this.add$Value(32, value);
1169 };
1170
1171
1172 /**
1173 * Returns the array of values in the repeated_int64 field.
1174 * @return {!Array<string>} The values in the field.
1175 */
1176 proto2.TestAllTypes.prototype.repeatedInt64Array = function() {
1177 return /** @type {!Array<string>} */ (this.array$Values(32));
1178 };
1179
1180
1181 /**
1182 * @return {boolean} Whether the repeated_int64 field has a value.
1183 */
1184 proto2.TestAllTypes.prototype.hasRepeatedInt64 = function() {
1185 return this.has$Value(32);
1186 };
1187
1188
1189 /**
1190 * @return {number} The number of values in the repeated_int64 field.
1191 */
1192 proto2.TestAllTypes.prototype.repeatedInt64Count = function() {
1193 return this.count$Values(32);
1194 };
1195
1196
1197 /**
1198 * Clears the values in the repeated_int64 field.
1199 */
1200 proto2.TestAllTypes.prototype.clearRepeatedInt64 = function() {
1201 this.clear$Field(32);
1202 };
1203
1204
1205 /**
1206 * Gets the value of the repeated_uint32 field at the index given.
1207 * @param {number} index The index to lookup.
1208 * @return {?number} The value.
1209 */
1210 proto2.TestAllTypes.prototype.getRepeatedUint32 = function(index) {
1211 return /** @type {?number} */ (this.get$Value(33, index));
1212 };
1213
1214
1215 /**
1216 * Gets the value of the repeated_uint32 field at the index given or the default value if not set.
1217 * @param {number} index The index to lookup.
1218 * @return {number} The value.
1219 */
1220 proto2.TestAllTypes.prototype.getRepeatedUint32OrDefault = function(index) {
1221 return /** @type {number} */ (this.get$ValueOrDefault(33, index));
1222 };
1223
1224
1225 /**
1226 * Adds a value to the repeated_uint32 field.
1227 * @param {number} value The value to add.
1228 */
1229 proto2.TestAllTypes.prototype.addRepeatedUint32 = function(value) {
1230 this.add$Value(33, value);
1231 };
1232
1233
1234 /**
1235 * Returns the array of values in the repeated_uint32 field.
1236 * @return {!Array<number>} The values in the field.
1237 */
1238 proto2.TestAllTypes.prototype.repeatedUint32Array = function() {
1239 return /** @type {!Array<number>} */ (this.array$Values(33));
1240 };
1241
1242
1243 /**
1244 * @return {boolean} Whether the repeated_uint32 field has a value.
1245 */
1246 proto2.TestAllTypes.prototype.hasRepeatedUint32 = function() {
1247 return this.has$Value(33);
1248 };
1249
1250
1251 /**
1252 * @return {number} The number of values in the repeated_uint32 field.
1253 */
1254 proto2.TestAllTypes.prototype.repeatedUint32Count = function() {
1255 return this.count$Values(33);
1256 };
1257
1258
1259 /**
1260 * Clears the values in the repeated_uint32 field.
1261 */
1262 proto2.TestAllTypes.prototype.clearRepeatedUint32 = function() {
1263 this.clear$Field(33);
1264 };
1265
1266
1267 /**
1268 * Gets the value of the repeated_uint64 field at the index given.
1269 * @param {number} index The index to lookup.
1270 * @return {?string} The value.
1271 */
1272 proto2.TestAllTypes.prototype.getRepeatedUint64 = function(index) {
1273 return /** @type {?string} */ (this.get$Value(34, index));
1274 };
1275
1276
1277 /**
1278 * Gets the value of the repeated_uint64 field at the index given or the default value if not set.
1279 * @param {number} index The index to lookup.
1280 * @return {string} The value.
1281 */
1282 proto2.TestAllTypes.prototype.getRepeatedUint64OrDefault = function(index) {
1283 return /** @type {string} */ (this.get$ValueOrDefault(34, index));
1284 };
1285
1286
1287 /**
1288 * Adds a value to the repeated_uint64 field.
1289 * @param {string} value The value to add.
1290 */
1291 proto2.TestAllTypes.prototype.addRepeatedUint64 = function(value) {
1292 this.add$Value(34, value);
1293 };
1294
1295
1296 /**
1297 * Returns the array of values in the repeated_uint64 field.
1298 * @return {!Array<string>} The values in the field.
1299 */
1300 proto2.TestAllTypes.prototype.repeatedUint64Array = function() {
1301 return /** @type {!Array<string>} */ (this.array$Values(34));
1302 };
1303
1304
1305 /**
1306 * @return {boolean} Whether the repeated_uint64 field has a value.
1307 */
1308 proto2.TestAllTypes.prototype.hasRepeatedUint64 = function() {
1309 return this.has$Value(34);
1310 };
1311
1312
1313 /**
1314 * @return {number} The number of values in the repeated_uint64 field.
1315 */
1316 proto2.TestAllTypes.prototype.repeatedUint64Count = function() {
1317 return this.count$Values(34);
1318 };
1319
1320
1321 /**
1322 * Clears the values in the repeated_uint64 field.
1323 */
1324 proto2.TestAllTypes.prototype.clearRepeatedUint64 = function() {
1325 this.clear$Field(34);
1326 };
1327
1328
1329 /**
1330 * Gets the value of the repeated_sint32 field at the index given.
1331 * @param {number} index The index to lookup.
1332 * @return {?number} The value.
1333 */
1334 proto2.TestAllTypes.prototype.getRepeatedSint32 = function(index) {
1335 return /** @type {?number} */ (this.get$Value(35, index));
1336 };
1337
1338
1339 /**
1340 * Gets the value of the repeated_sint32 field at the index given or the default value if not set.
1341 * @param {number} index The index to lookup.
1342 * @return {number} The value.
1343 */
1344 proto2.TestAllTypes.prototype.getRepeatedSint32OrDefault = function(index) {
1345 return /** @type {number} */ (this.get$ValueOrDefault(35, index));
1346 };
1347
1348
1349 /**
1350 * Adds a value to the repeated_sint32 field.
1351 * @param {number} value The value to add.
1352 */
1353 proto2.TestAllTypes.prototype.addRepeatedSint32 = function(value) {
1354 this.add$Value(35, value);
1355 };
1356
1357
1358 /**
1359 * Returns the array of values in the repeated_sint32 field.
1360 * @return {!Array<number>} The values in the field.
1361 */
1362 proto2.TestAllTypes.prototype.repeatedSint32Array = function() {
1363 return /** @type {!Array<number>} */ (this.array$Values(35));
1364 };
1365
1366
1367 /**
1368 * @return {boolean} Whether the repeated_sint32 field has a value.
1369 */
1370 proto2.TestAllTypes.prototype.hasRepeatedSint32 = function() {
1371 return this.has$Value(35);
1372 };
1373
1374
1375 /**
1376 * @return {number} The number of values in the repeated_sint32 field.
1377 */
1378 proto2.TestAllTypes.prototype.repeatedSint32Count = function() {
1379 return this.count$Values(35);
1380 };
1381
1382
1383 /**
1384 * Clears the values in the repeated_sint32 field.
1385 */
1386 proto2.TestAllTypes.prototype.clearRepeatedSint32 = function() {
1387 this.clear$Field(35);
1388 };
1389
1390
1391 /**
1392 * Gets the value of the repeated_sint64 field at the index given.
1393 * @param {number} index The index to lookup.
1394 * @return {?string} The value.
1395 */
1396 proto2.TestAllTypes.prototype.getRepeatedSint64 = function(index) {
1397 return /** @type {?string} */ (this.get$Value(36, index));
1398 };
1399
1400
1401 /**
1402 * Gets the value of the repeated_sint64 field at the index given or the default value if not set.
1403 * @param {number} index The index to lookup.
1404 * @return {string} The value.
1405 */
1406 proto2.TestAllTypes.prototype.getRepeatedSint64OrDefault = function(index) {
1407 return /** @type {string} */ (this.get$ValueOrDefault(36, index));
1408 };
1409
1410
1411 /**
1412 * Adds a value to the repeated_sint64 field.
1413 * @param {string} value The value to add.
1414 */
1415 proto2.TestAllTypes.prototype.addRepeatedSint64 = function(value) {
1416 this.add$Value(36, value);
1417 };
1418
1419
1420 /**
1421 * Returns the array of values in the repeated_sint64 field.
1422 * @return {!Array<string>} The values in the field.
1423 */
1424 proto2.TestAllTypes.prototype.repeatedSint64Array = function() {
1425 return /** @type {!Array<string>} */ (this.array$Values(36));
1426 };
1427
1428
1429 /**
1430 * @return {boolean} Whether the repeated_sint64 field has a value.
1431 */
1432 proto2.TestAllTypes.prototype.hasRepeatedSint64 = function() {
1433 return this.has$Value(36);
1434 };
1435
1436
1437 /**
1438 * @return {number} The number of values in the repeated_sint64 field.
1439 */
1440 proto2.TestAllTypes.prototype.repeatedSint64Count = function() {
1441 return this.count$Values(36);
1442 };
1443
1444
1445 /**
1446 * Clears the values in the repeated_sint64 field.
1447 */
1448 proto2.TestAllTypes.prototype.clearRepeatedSint64 = function() {
1449 this.clear$Field(36);
1450 };
1451
1452
1453 /**
1454 * Gets the value of the repeated_fixed32 field at the index given.
1455 * @param {number} index The index to lookup.
1456 * @return {?number} The value.
1457 */
1458 proto2.TestAllTypes.prototype.getRepeatedFixed32 = function(index) {
1459 return /** @type {?number} */ (this.get$Value(37, index));
1460 };
1461
1462
1463 /**
1464 * Gets the value of the repeated_fixed32 field at the index given or the default value if not set.
1465 * @param {number} index The index to lookup.
1466 * @return {number} The value.
1467 */
1468 proto2.TestAllTypes.prototype.getRepeatedFixed32OrDefault = function(index) {
1469 return /** @type {number} */ (this.get$ValueOrDefault(37, index));
1470 };
1471
1472
1473 /**
1474 * Adds a value to the repeated_fixed32 field.
1475 * @param {number} value The value to add.
1476 */
1477 proto2.TestAllTypes.prototype.addRepeatedFixed32 = function(value) {
1478 this.add$Value(37, value);
1479 };
1480
1481
1482 /**
1483 * Returns the array of values in the repeated_fixed32 field.
1484 * @return {!Array<number>} The values in the field.
1485 */
1486 proto2.TestAllTypes.prototype.repeatedFixed32Array = function() {
1487 return /** @type {!Array<number>} */ (this.array$Values(37));
1488 };
1489
1490
1491 /**
1492 * @return {boolean} Whether the repeated_fixed32 field has a value.
1493 */
1494 proto2.TestAllTypes.prototype.hasRepeatedFixed32 = function() {
1495 return this.has$Value(37);
1496 };
1497
1498
1499 /**
1500 * @return {number} The number of values in the repeated_fixed32 field.
1501 */
1502 proto2.TestAllTypes.prototype.repeatedFixed32Count = function() {
1503 return this.count$Values(37);
1504 };
1505
1506
1507 /**
1508 * Clears the values in the repeated_fixed32 field.
1509 */
1510 proto2.TestAllTypes.prototype.clearRepeatedFixed32 = function() {
1511 this.clear$Field(37);
1512 };
1513
1514
1515 /**
1516 * Gets the value of the repeated_fixed64 field at the index given.
1517 * @param {number} index The index to lookup.
1518 * @return {?string} The value.
1519 */
1520 proto2.TestAllTypes.prototype.getRepeatedFixed64 = function(index) {
1521 return /** @type {?string} */ (this.get$Value(38, index));
1522 };
1523
1524
1525 /**
1526 * Gets the value of the repeated_fixed64 field at the index given or the default value if not set.
1527 * @param {number} index The index to lookup.
1528 * @return {string} The value.
1529 */
1530 proto2.TestAllTypes.prototype.getRepeatedFixed64OrDefault = function(index) {
1531 return /** @type {string} */ (this.get$ValueOrDefault(38, index));
1532 };
1533
1534
1535 /**
1536 * Adds a value to the repeated_fixed64 field.
1537 * @param {string} value The value to add.
1538 */
1539 proto2.TestAllTypes.prototype.addRepeatedFixed64 = function(value) {
1540 this.add$Value(38, value);
1541 };
1542
1543
1544 /**
1545 * Returns the array of values in the repeated_fixed64 field.
1546 * @return {!Array<string>} The values in the field.
1547 */
1548 proto2.TestAllTypes.prototype.repeatedFixed64Array = function() {
1549 return /** @type {!Array<string>} */ (this.array$Values(38));
1550 };
1551
1552
1553 /**
1554 * @return {boolean} Whether the repeated_fixed64 field has a value.
1555 */
1556 proto2.TestAllTypes.prototype.hasRepeatedFixed64 = function() {
1557 return this.has$Value(38);
1558 };
1559
1560
1561 /**
1562 * @return {number} The number of values in the repeated_fixed64 field.
1563 */
1564 proto2.TestAllTypes.prototype.repeatedFixed64Count = function() {
1565 return this.count$Values(38);
1566 };
1567
1568
1569 /**
1570 * Clears the values in the repeated_fixed64 field.
1571 */
1572 proto2.TestAllTypes.prototype.clearRepeatedFixed64 = function() {
1573 this.clear$Field(38);
1574 };
1575
1576
1577 /**
1578 * Gets the value of the repeated_sfixed32 field at the index given.
1579 * @param {number} index The index to lookup.
1580 * @return {?number} The value.
1581 */
1582 proto2.TestAllTypes.prototype.getRepeatedSfixed32 = function(index) {
1583 return /** @type {?number} */ (this.get$Value(39, index));
1584 };
1585
1586
1587 /**
1588 * Gets the value of the repeated_sfixed32 field at the index given or the default value if not set.
1589 * @param {number} index The index to lookup.
1590 * @return {number} The value.
1591 */
1592 proto2.TestAllTypes.prototype.getRepeatedSfixed32OrDefault = function(index) {
1593 return /** @type {number} */ (this.get$ValueOrDefault(39, index));
1594 };
1595
1596
1597 /**
1598 * Adds a value to the repeated_sfixed32 field.
1599 * @param {number} value The value to add.
1600 */
1601 proto2.TestAllTypes.prototype.addRepeatedSfixed32 = function(value) {
1602 this.add$Value(39, value);
1603 };
1604
1605
1606 /**
1607 * Returns the array of values in the repeated_sfixed32 field.
1608 * @return {!Array<number>} The values in the field.
1609 */
1610 proto2.TestAllTypes.prototype.repeatedSfixed32Array = function() {
1611 return /** @type {!Array<number>} */ (this.array$Values(39));
1612 };
1613
1614
1615 /**
1616 * @return {boolean} Whether the repeated_sfixed32 field has a value.
1617 */
1618 proto2.TestAllTypes.prototype.hasRepeatedSfixed32 = function() {
1619 return this.has$Value(39);
1620 };
1621
1622
1623 /**
1624 * @return {number} The number of values in the repeated_sfixed32 field.
1625 */
1626 proto2.TestAllTypes.prototype.repeatedSfixed32Count = function() {
1627 return this.count$Values(39);
1628 };
1629
1630
1631 /**
1632 * Clears the values in the repeated_sfixed32 field.
1633 */
1634 proto2.TestAllTypes.prototype.clearRepeatedSfixed32 = function() {
1635 this.clear$Field(39);
1636 };
1637
1638
1639 /**
1640 * Gets the value of the repeated_sfixed64 field at the index given.
1641 * @param {number} index The index to lookup.
1642 * @return {?string} The value.
1643 */
1644 proto2.TestAllTypes.prototype.getRepeatedSfixed64 = function(index) {
1645 return /** @type {?string} */ (this.get$Value(40, index));
1646 };
1647
1648
1649 /**
1650 * Gets the value of the repeated_sfixed64 field at the index given or the default value if not set.
1651 * @param {number} index The index to lookup.
1652 * @return {string} The value.
1653 */
1654 proto2.TestAllTypes.prototype.getRepeatedSfixed64OrDefault = function(index) {
1655 return /** @type {string} */ (this.get$ValueOrDefault(40, index));
1656 };
1657
1658
1659 /**
1660 * Adds a value to the repeated_sfixed64 field.
1661 * @param {string} value The value to add.
1662 */
1663 proto2.TestAllTypes.prototype.addRepeatedSfixed64 = function(value) {
1664 this.add$Value(40, value);
1665 };
1666
1667
1668 /**
1669 * Returns the array of values in the repeated_sfixed64 field.
1670 * @return {!Array<string>} The values in the field.
1671 */
1672 proto2.TestAllTypes.prototype.repeatedSfixed64Array = function() {
1673 return /** @type {!Array<string>} */ (this.array$Values(40));
1674 };
1675
1676
1677 /**
1678 * @return {boolean} Whether the repeated_sfixed64 field has a value.
1679 */
1680 proto2.TestAllTypes.prototype.hasRepeatedSfixed64 = function() {
1681 return this.has$Value(40);
1682 };
1683
1684
1685 /**
1686 * @return {number} The number of values in the repeated_sfixed64 field.
1687 */
1688 proto2.TestAllTypes.prototype.repeatedSfixed64Count = function() {
1689 return this.count$Values(40);
1690 };
1691
1692
1693 /**
1694 * Clears the values in the repeated_sfixed64 field.
1695 */
1696 proto2.TestAllTypes.prototype.clearRepeatedSfixed64 = function() {
1697 this.clear$Field(40);
1698 };
1699
1700
1701 /**
1702 * Gets the value of the repeated_float field at the index given.
1703 * @param {number} index The index to lookup.
1704 * @return {?number} The value.
1705 */
1706 proto2.TestAllTypes.prototype.getRepeatedFloat = function(index) {
1707 return /** @type {?number} */ (this.get$Value(41, index));
1708 };
1709
1710
1711 /**
1712 * Gets the value of the repeated_float field at the index given or the default value if not set.
1713 * @param {number} index The index to lookup.
1714 * @return {number} The value.
1715 */
1716 proto2.TestAllTypes.prototype.getRepeatedFloatOrDefault = function(index) {
1717 return /** @type {number} */ (this.get$ValueOrDefault(41, index));
1718 };
1719
1720
1721 /**
1722 * Adds a value to the repeated_float field.
1723 * @param {number} value The value to add.
1724 */
1725 proto2.TestAllTypes.prototype.addRepeatedFloat = function(value) {
1726 this.add$Value(41, value);
1727 };
1728
1729
1730 /**
1731 * Returns the array of values in the repeated_float field.
1732 * @return {!Array<number>} The values in the field.
1733 */
1734 proto2.TestAllTypes.prototype.repeatedFloatArray = function() {
1735 return /** @type {!Array<number>} */ (this.array$Values(41));
1736 };
1737
1738
1739 /**
1740 * @return {boolean} Whether the repeated_float field has a value.
1741 */
1742 proto2.TestAllTypes.prototype.hasRepeatedFloat = function() {
1743 return this.has$Value(41);
1744 };
1745
1746
1747 /**
1748 * @return {number} The number of values in the repeated_float field.
1749 */
1750 proto2.TestAllTypes.prototype.repeatedFloatCount = function() {
1751 return this.count$Values(41);
1752 };
1753
1754
1755 /**
1756 * Clears the values in the repeated_float field.
1757 */
1758 proto2.TestAllTypes.prototype.clearRepeatedFloat = function() {
1759 this.clear$Field(41);
1760 };
1761
1762
1763 /**
1764 * Gets the value of the repeated_double field at the index given.
1765 * @param {number} index The index to lookup.
1766 * @return {?number} The value.
1767 */
1768 proto2.TestAllTypes.prototype.getRepeatedDouble = function(index) {
1769 return /** @type {?number} */ (this.get$Value(42, index));
1770 };
1771
1772
1773 /**
1774 * Gets the value of the repeated_double field at the index given or the default value if not set.
1775 * @param {number} index The index to lookup.
1776 * @return {number} The value.
1777 */
1778 proto2.TestAllTypes.prototype.getRepeatedDoubleOrDefault = function(index) {
1779 return /** @type {number} */ (this.get$ValueOrDefault(42, index));
1780 };
1781
1782
1783 /**
1784 * Adds a value to the repeated_double field.
1785 * @param {number} value The value to add.
1786 */
1787 proto2.TestAllTypes.prototype.addRepeatedDouble = function(value) {
1788 this.add$Value(42, value);
1789 };
1790
1791
1792 /**
1793 * Returns the array of values in the repeated_double field.
1794 * @return {!Array<number>} The values in the field.
1795 */
1796 proto2.TestAllTypes.prototype.repeatedDoubleArray = function() {
1797 return /** @type {!Array<number>} */ (this.array$Values(42));
1798 };
1799
1800
1801 /**
1802 * @return {boolean} Whether the repeated_double field has a value.
1803 */
1804 proto2.TestAllTypes.prototype.hasRepeatedDouble = function() {
1805 return this.has$Value(42);
1806 };
1807
1808
1809 /**
1810 * @return {number} The number of values in the repeated_double field.
1811 */
1812 proto2.TestAllTypes.prototype.repeatedDoubleCount = function() {
1813 return this.count$Values(42);
1814 };
1815
1816
1817 /**
1818 * Clears the values in the repeated_double field.
1819 */
1820 proto2.TestAllTypes.prototype.clearRepeatedDouble = function() {
1821 this.clear$Field(42);
1822 };
1823
1824
1825 /**
1826 * Gets the value of the repeated_bool field at the index given.
1827 * @param {number} index The index to lookup.
1828 * @return {?boolean} The value.
1829 */
1830 proto2.TestAllTypes.prototype.getRepeatedBool = function(index) {
1831 return /** @type {?boolean} */ (this.get$Value(43, index));
1832 };
1833
1834
1835 /**
1836 * Gets the value of the repeated_bool field at the index given or the default value if not set.
1837 * @param {number} index The index to lookup.
1838 * @return {boolean} The value.
1839 */
1840 proto2.TestAllTypes.prototype.getRepeatedBoolOrDefault = function(index) {
1841 return /** @type {boolean} */ (this.get$ValueOrDefault(43, index));
1842 };
1843
1844
1845 /**
1846 * Adds a value to the repeated_bool field.
1847 * @param {boolean} value The value to add.
1848 */
1849 proto2.TestAllTypes.prototype.addRepeatedBool = function(value) {
1850 this.add$Value(43, value);
1851 };
1852
1853
1854 /**
1855 * Returns the array of values in the repeated_bool field.
1856 * @return {!Array<boolean>} The values in the field.
1857 */
1858 proto2.TestAllTypes.prototype.repeatedBoolArray = function() {
1859 return /** @type {!Array<boolean>} */ (this.array$Values(43));
1860 };
1861
1862
1863 /**
1864 * @return {boolean} Whether the repeated_bool field has a value.
1865 */
1866 proto2.TestAllTypes.prototype.hasRepeatedBool = function() {
1867 return this.has$Value(43);
1868 };
1869
1870
1871 /**
1872 * @return {number} The number of values in the repeated_bool field.
1873 */
1874 proto2.TestAllTypes.prototype.repeatedBoolCount = function() {
1875 return this.count$Values(43);
1876 };
1877
1878
1879 /**
1880 * Clears the values in the repeated_bool field.
1881 */
1882 proto2.TestAllTypes.prototype.clearRepeatedBool = function() {
1883 this.clear$Field(43);
1884 };
1885
1886
1887 /**
1888 * Gets the value of the repeated_string field at the index given.
1889 * @param {number} index The index to lookup.
1890 * @return {?string} The value.
1891 */
1892 proto2.TestAllTypes.prototype.getRepeatedString = function(index) {
1893 return /** @type {?string} */ (this.get$Value(44, index));
1894 };
1895
1896
1897 /**
1898 * Gets the value of the repeated_string field at the index given or the default value if not set.
1899 * @param {number} index The index to lookup.
1900 * @return {string} The value.
1901 */
1902 proto2.TestAllTypes.prototype.getRepeatedStringOrDefault = function(index) {
1903 return /** @type {string} */ (this.get$ValueOrDefault(44, index));
1904 };
1905
1906
1907 /**
1908 * Adds a value to the repeated_string field.
1909 * @param {string} value The value to add.
1910 */
1911 proto2.TestAllTypes.prototype.addRepeatedString = function(value) {
1912 this.add$Value(44, value);
1913 };
1914
1915
1916 /**
1917 * Returns the array of values in the repeated_string field.
1918 * @return {!Array<string>} The values in the field.
1919 */
1920 proto2.TestAllTypes.prototype.repeatedStringArray = function() {
1921 return /** @type {!Array<string>} */ (this.array$Values(44));
1922 };
1923
1924
1925 /**
1926 * @return {boolean} Whether the repeated_string field has a value.
1927 */
1928 proto2.TestAllTypes.prototype.hasRepeatedString = function() {
1929 return this.has$Value(44);
1930 };
1931
1932
1933 /**
1934 * @return {number} The number of values in the repeated_string field.
1935 */
1936 proto2.TestAllTypes.prototype.repeatedStringCount = function() {
1937 return this.count$Values(44);
1938 };
1939
1940
1941 /**
1942 * Clears the values in the repeated_string field.
1943 */
1944 proto2.TestAllTypes.prototype.clearRepeatedString = function() {
1945 this.clear$Field(44);
1946 };
1947
1948
1949 /**
1950 * Gets the value of the repeated_bytes field at the index given.
1951 * @param {number} index The index to lookup.
1952 * @return {?string} The value.
1953 */
1954 proto2.TestAllTypes.prototype.getRepeatedBytes = function(index) {
1955 return /** @type {?string} */ (this.get$Value(45, index));
1956 };
1957
1958
1959 /**
1960 * Gets the value of the repeated_bytes field at the index given or the default value if not set.
1961 * @param {number} index The index to lookup.
1962 * @return {string} The value.
1963 */
1964 proto2.TestAllTypes.prototype.getRepeatedBytesOrDefault = function(index) {
1965 return /** @type {string} */ (this.get$ValueOrDefault(45, index));
1966 };
1967
1968
1969 /**
1970 * Adds a value to the repeated_bytes field.
1971 * @param {string} value The value to add.
1972 */
1973 proto2.TestAllTypes.prototype.addRepeatedBytes = function(value) {
1974 this.add$Value(45, value);
1975 };
1976
1977
1978 /**
1979 * Returns the array of values in the repeated_bytes field.
1980 * @return {!Array<string>} The values in the field.
1981 */
1982 proto2.TestAllTypes.prototype.repeatedBytesArray = function() {
1983 return /** @type {!Array<string>} */ (this.array$Values(45));
1984 };
1985
1986
1987 /**
1988 * @return {boolean} Whether the repeated_bytes field has a value.
1989 */
1990 proto2.TestAllTypes.prototype.hasRepeatedBytes = function() {
1991 return this.has$Value(45);
1992 };
1993
1994
1995 /**
1996 * @return {number} The number of values in the repeated_bytes field.
1997 */
1998 proto2.TestAllTypes.prototype.repeatedBytesCount = function() {
1999 return this.count$Values(45);
2000 };
2001
2002
2003 /**
2004 * Clears the values in the repeated_bytes field.
2005 */
2006 proto2.TestAllTypes.prototype.clearRepeatedBytes = function() {
2007 this.clear$Field(45);
2008 };
2009
2010
2011 /**
2012 * Gets the value of the repeatedgroup field at the index given.
2013 * @param {number} index The index to lookup.
2014 * @return {?proto2.TestAllTypes.RepeatedGroup} The value.
2015 */
2016 proto2.TestAllTypes.prototype.getRepeatedgroup = function(index) {
2017 return /** @type {?proto2.TestAllTypes.RepeatedGroup} */ (this.get$Value(46, index));
2018 };
2019
2020
2021 /**
2022 * Gets the value of the repeatedgroup field at the index given or the default value if not set.
2023 * @param {number} index The index to lookup.
2024 * @return {!proto2.TestAllTypes.RepeatedGroup} The value.
2025 */
2026 proto2.TestAllTypes.prototype.getRepeatedgroupOrDefault = function(index) {
2027 return /** @type {!proto2.TestAllTypes.RepeatedGroup} */ (this.get$ValueOrDefault(46, index));
2028 };
2029
2030
2031 /**
2032 * Adds a value to the repeatedgroup field.
2033 * @param {!proto2.TestAllTypes.RepeatedGroup} value The value to add.
2034 */
2035 proto2.TestAllTypes.prototype.addRepeatedgroup = function(value) {
2036 this.add$Value(46, value);
2037 };
2038
2039
2040 /**
2041 * Returns the array of values in the repeatedgroup field.
2042 * @return {!Array<!proto2.TestAllTypes.RepeatedGroup>} The values in the field.
2043 */
2044 proto2.TestAllTypes.prototype.repeatedgroupArray = function() {
2045 return /** @type {!Array<!proto2.TestAllTypes.RepeatedGroup>} */ (this.array$Values(46));
2046 };
2047
2048
2049 /**
2050 * @return {boolean} Whether the repeatedgroup field has a value.
2051 */
2052 proto2.TestAllTypes.prototype.hasRepeatedgroup = function() {
2053 return this.has$Value(46);
2054 };
2055
2056
2057 /**
2058 * @return {number} The number of values in the repeatedgroup field.
2059 */
2060 proto2.TestAllTypes.prototype.repeatedgroupCount = function() {
2061 return this.count$Values(46);
2062 };
2063
2064
2065 /**
2066 * Clears the values in the repeatedgroup field.
2067 */
2068 proto2.TestAllTypes.prototype.clearRepeatedgroup = function() {
2069 this.clear$Field(46);
2070 };
2071
2072
2073 /**
2074 * Gets the value of the repeated_nested_message field at the index given.
2075 * @param {number} index The index to lookup.
2076 * @return {?proto2.TestAllTypes.NestedMessage} The value.
2077 */
2078 proto2.TestAllTypes.prototype.getRepeatedNestedMessage = function(index) {
2079 return /** @type {?proto2.TestAllTypes.NestedMessage} */ (this.get$Value(48, index));
2080 };
2081
2082
2083 /**
2084 * Gets the value of the repeated_nested_message field at the index given or the default value if not set.
2085 * @param {number} index The index to lookup.
2086 * @return {!proto2.TestAllTypes.NestedMessage} The value.
2087 */
2088 proto2.TestAllTypes.prototype.getRepeatedNestedMessageOrDefault = function(index) {
2089 return /** @type {!proto2.TestAllTypes.NestedMessage} */ (this.get$ValueOrDefault(48, index));
2090 };
2091
2092
2093 /**
2094 * Adds a value to the repeated_nested_message field.
2095 * @param {!proto2.TestAllTypes.NestedMessage} value The value to add.
2096 */
2097 proto2.TestAllTypes.prototype.addRepeatedNestedMessage = function(value) {
2098 this.add$Value(48, value);
2099 };
2100
2101
2102 /**
2103 * Returns the array of values in the repeated_nested_message field.
2104 * @return {!Array<!proto2.TestAllTypes.NestedMessage>} The values in the field.
2105 */
2106 proto2.TestAllTypes.prototype.repeatedNestedMessageArray = function() {
2107 return /** @type {!Array<!proto2.TestAllTypes.NestedMessage>} */ (this.array$Values(48));
2108 };
2109
2110
2111 /**
2112 * @return {boolean} Whether the repeated_nested_message field has a value.
2113 */
2114 proto2.TestAllTypes.prototype.hasRepeatedNestedMessage = function() {
2115 return this.has$Value(48);
2116 };
2117
2118
2119 /**
2120 * @return {number} The number of values in the repeated_nested_message field.
2121 */
2122 proto2.TestAllTypes.prototype.repeatedNestedMessageCount = function() {
2123 return this.count$Values(48);
2124 };
2125
2126
2127 /**
2128 * Clears the values in the repeated_nested_message field.
2129 */
2130 proto2.TestAllTypes.prototype.clearRepeatedNestedMessage = function() {
2131 this.clear$Field(48);
2132 };
2133
2134
2135 /**
2136 * Gets the value of the repeated_nested_enum field at the index given.
2137 * @param {number} index The index to lookup.
2138 * @return {?proto2.TestAllTypes.NestedEnum} The value.
2139 */
2140 proto2.TestAllTypes.prototype.getRepeatedNestedEnum = function(index) {
2141 return /** @type {?proto2.TestAllTypes.NestedEnum} */ (this.get$Value(49, index));
2142 };
2143
2144
2145 /**
2146 * Gets the value of the repeated_nested_enum field at the index given or the default value if not set.
2147 * @param {number} index The index to lookup.
2148 * @return {!proto2.TestAllTypes.NestedEnum} The value.
2149 */
2150 proto2.TestAllTypes.prototype.getRepeatedNestedEnumOrDefault = function(index) {
2151 return /** @type {!proto2.TestAllTypes.NestedEnum} */ (this.get$ValueOrDefault(49, index));
2152 };
2153
2154
2155 /**
2156 * Adds a value to the repeated_nested_enum field.
2157 * @param {!proto2.TestAllTypes.NestedEnum} value The value to add.
2158 */
2159 proto2.TestAllTypes.prototype.addRepeatedNestedEnum = function(value) {
2160 this.add$Value(49, value);
2161 };
2162
2163
2164 /**
2165 * Returns the array of values in the repeated_nested_enum field.
2166 * @return {!Array<!proto2.TestAllTypes.NestedEnum>} The values in the field.
2167 */
2168 proto2.TestAllTypes.prototype.repeatedNestedEnumArray = function() {
2169 return /** @type {!Array<!proto2.TestAllTypes.NestedEnum>} */ (this.array$Values(49));
2170 };
2171
2172
2173 /**
2174 * @return {boolean} Whether the repeated_nested_enum field has a value.
2175 */
2176 proto2.TestAllTypes.prototype.hasRepeatedNestedEnum = function() {
2177 return this.has$Value(49);
2178 };
2179
2180
2181 /**
2182 * @return {number} The number of values in the repeated_nested_enum field.
2183 */
2184 proto2.TestAllTypes.prototype.repeatedNestedEnumCount = function() {
2185 return this.count$Values(49);
2186 };
2187
2188
2189 /**
2190 * Clears the values in the repeated_nested_enum field.
2191 */
2192 proto2.TestAllTypes.prototype.clearRepeatedNestedEnum = function() {
2193 this.clear$Field(49);
2194 };
2195
2196
2197 /**
2198 * Gets the value of the repeated_int64_number field at the index given.
2199 * @param {number} index The index to lookup.
2200 * @return {?number} The value.
2201 */
2202 proto2.TestAllTypes.prototype.getRepeatedInt64Number = function(index) {
2203 return /** @type {?number} */ (this.get$Value(52, index));
2204 };
2205
2206
2207 /**
2208 * Gets the value of the repeated_int64_number field at the index given or the default value if not set.
2209 * @param {number} index The index to lookup.
2210 * @return {number} The value.
2211 */
2212 proto2.TestAllTypes.prototype.getRepeatedInt64NumberOrDefault = function(index) {
2213 return /** @type {number} */ (this.get$ValueOrDefault(52, index));
2214 };
2215
2216
2217 /**
2218 * Adds a value to the repeated_int64_number field.
2219 * @param {number} value The value to add.
2220 */
2221 proto2.TestAllTypes.prototype.addRepeatedInt64Number = function(value) {
2222 this.add$Value(52, value);
2223 };
2224
2225
2226 /**
2227 * Returns the array of values in the repeated_int64_number field.
2228 * @return {!Array<number>} The values in the field.
2229 */
2230 proto2.TestAllTypes.prototype.repeatedInt64NumberArray = function() {
2231 return /** @type {!Array<number>} */ (this.array$Values(52));
2232 };
2233
2234
2235 /**
2236 * @return {boolean} Whether the repeated_int64_number field has a value.
2237 */
2238 proto2.TestAllTypes.prototype.hasRepeatedInt64Number = function() {
2239 return this.has$Value(52);
2240 };
2241
2242
2243 /**
2244 * @return {number} The number of values in the repeated_int64_number field.
2245 */
2246 proto2.TestAllTypes.prototype.repeatedInt64NumberCount = function() {
2247 return this.count$Values(52);
2248 };
2249
2250
2251 /**
2252 * Clears the values in the repeated_int64_number field.
2253 */
2254 proto2.TestAllTypes.prototype.clearRepeatedInt64Number = function() {
2255 this.clear$Field(52);
2256 };
2257
2258
2259 /**
2260 * Gets the value of the repeated_int64_string field at the index given.
2261 * @param {number} index The index to lookup.
2262 * @return {?string} The value.
2263 */
2264 proto2.TestAllTypes.prototype.getRepeatedInt64String = function(index) {
2265 return /** @type {?string} */ (this.get$Value(53, index));
2266 };
2267
2268
2269 /**
2270 * Gets the value of the repeated_int64_string field at the index given or the default value if not set.
2271 * @param {number} index The index to lookup.
2272 * @return {string} The value.
2273 */
2274 proto2.TestAllTypes.prototype.getRepeatedInt64StringOrDefault = function(index) {
2275 return /** @type {string} */ (this.get$ValueOrDefault(53, index));
2276 };
2277
2278
2279 /**
2280 * Adds a value to the repeated_int64_string field.
2281 * @param {string} value The value to add.
2282 */
2283 proto2.TestAllTypes.prototype.addRepeatedInt64String = function(value) {
2284 this.add$Value(53, value);
2285 };
2286
2287
2288 /**
2289 * Returns the array of values in the repeated_int64_string field.
2290 * @return {!Array<string>} The values in the field.
2291 */
2292 proto2.TestAllTypes.prototype.repeatedInt64StringArray = function() {
2293 return /** @type {!Array<string>} */ (this.array$Values(53));
2294 };
2295
2296
2297 /**
2298 * @return {boolean} Whether the repeated_int64_string field has a value.
2299 */
2300 proto2.TestAllTypes.prototype.hasRepeatedInt64String = function() {
2301 return this.has$Value(53);
2302 };
2303
2304
2305 /**
2306 * @return {number} The number of values in the repeated_int64_string field.
2307 */
2308 proto2.TestAllTypes.prototype.repeatedInt64StringCount = function() {
2309 return this.count$Values(53);
2310 };
2311
2312
2313 /**
2314 * Clears the values in the repeated_int64_string field.
2315 */
2316 proto2.TestAllTypes.prototype.clearRepeatedInt64String = function() {
2317 this.clear$Field(53);
2318 };
2319
2320
2321 /**
2322 * Gets the value of the packed_int32 field at the index given.
2323 * @param {number} index The index to lookup.
2324 * @return {?number} The value.
2325 */
2326 proto2.TestAllTypes.prototype.getPackedInt32 = function(index) {
2327 return /** @type {?number} */ (this.get$Value(54, index));
2328 };
2329
2330
2331 /**
2332 * Gets the value of the packed_int32 field at the index given or the default value if not set.
2333 * @param {number} index The index to lookup.
2334 * @return {number} The value.
2335 */
2336 proto2.TestAllTypes.prototype.getPackedInt32OrDefault = function(index) {
2337 return /** @type {number} */ (this.get$ValueOrDefault(54, index));
2338 };
2339
2340
2341 /**
2342 * Adds a value to the packed_int32 field.
2343 * @param {number} value The value to add.
2344 */
2345 proto2.TestAllTypes.prototype.addPackedInt32 = function(value) {
2346 this.add$Value(54, value);
2347 };
2348
2349
2350 /**
2351 * Returns the array of values in the packed_int32 field.
2352 * @return {!Array<number>} The values in the field.
2353 */
2354 proto2.TestAllTypes.prototype.packedInt32Array = function() {
2355 return /** @type {!Array<number>} */ (this.array$Values(54));
2356 };
2357
2358
2359 /**
2360 * @return {boolean} Whether the packed_int32 field has a value.
2361 */
2362 proto2.TestAllTypes.prototype.hasPackedInt32 = function() {
2363 return this.has$Value(54);
2364 };
2365
2366
2367 /**
2368 * @return {number} The number of values in the packed_int32 field.
2369 */
2370 proto2.TestAllTypes.prototype.packedInt32Count = function() {
2371 return this.count$Values(54);
2372 };
2373
2374
2375 /**
2376 * Clears the values in the packed_int32 field.
2377 */
2378 proto2.TestAllTypes.prototype.clearPackedInt32 = function() {
2379 this.clear$Field(54);
2380 };
2381
2382
2383 /**
2384 * Gets the value of the packed_int64 field at the index given.
2385 * @param {number} index The index to lookup.
2386 * @return {?number} The value.
2387 */
2388 proto2.TestAllTypes.prototype.getPackedInt64 = function(index) {
2389 return /** @type {?number} */ (this.get$Value(55, index));
2390 };
2391
2392
2393 /**
2394 * Gets the value of the packed_int64 field at the index given or the default value if not set.
2395 * @param {number} index The index to lookup.
2396 * @return {number} The value.
2397 */
2398 proto2.TestAllTypes.prototype.getPackedInt64OrDefault = function(index) {
2399 return /** @type {number} */ (this.get$ValueOrDefault(55, index));
2400 };
2401
2402
2403 /**
2404 * Adds a value to the packed_int64 field.
2405 * @param {number} value The value to add.
2406 */
2407 proto2.TestAllTypes.prototype.addPackedInt64 = function(value) {
2408 this.add$Value(55, value);
2409 };
2410
2411
2412 /**
2413 * Returns the array of values in the packed_int64 field.
2414 * @return {!Array<number>} The values in the field.
2415 */
2416 proto2.TestAllTypes.prototype.packedInt64Array = function() {
2417 return /** @type {!Array<number>} */ (this.array$Values(55));
2418 };
2419
2420
2421 /**
2422 * @return {boolean} Whether the packed_int64 field has a value.
2423 */
2424 proto2.TestAllTypes.prototype.hasPackedInt64 = function() {
2425 return this.has$Value(55);
2426 };
2427
2428
2429 /**
2430 * @return {number} The number of values in the packed_int64 field.
2431 */
2432 proto2.TestAllTypes.prototype.packedInt64Count = function() {
2433 return this.count$Values(55);
2434 };
2435
2436
2437 /**
2438 * Clears the values in the packed_int64 field.
2439 */
2440 proto2.TestAllTypes.prototype.clearPackedInt64 = function() {
2441 this.clear$Field(55);
2442 };
2443
2444
2445 /**
2446 * Gets the value of the packed_uint32 field at the index given.
2447 * @param {number} index The index to lookup.
2448 * @return {?number} The value.
2449 */
2450 proto2.TestAllTypes.prototype.getPackedUint32 = function(index) {
2451 return /** @type {?number} */ (this.get$Value(56, index));
2452 };
2453
2454
2455 /**
2456 * Gets the value of the packed_uint32 field at the index given or the default value if not set.
2457 * @param {number} index The index to lookup.
2458 * @return {number} The value.
2459 */
2460 proto2.TestAllTypes.prototype.getPackedUint32OrDefault = function(index) {
2461 return /** @type {number} */ (this.get$ValueOrDefault(56, index));
2462 };
2463
2464
2465 /**
2466 * Adds a value to the packed_uint32 field.
2467 * @param {number} value The value to add.
2468 */
2469 proto2.TestAllTypes.prototype.addPackedUint32 = function(value) {
2470 this.add$Value(56, value);
2471 };
2472
2473
2474 /**
2475 * Returns the array of values in the packed_uint32 field.
2476 * @return {!Array<number>} The values in the field.
2477 */
2478 proto2.TestAllTypes.prototype.packedUint32Array = function() {
2479 return /** @type {!Array<number>} */ (this.array$Values(56));
2480 };
2481
2482
2483 /**
2484 * @return {boolean} Whether the packed_uint32 field has a value.
2485 */
2486 proto2.TestAllTypes.prototype.hasPackedUint32 = function() {
2487 return this.has$Value(56);
2488 };
2489
2490
2491 /**
2492 * @return {number} The number of values in the packed_uint32 field.
2493 */
2494 proto2.TestAllTypes.prototype.packedUint32Count = function() {
2495 return this.count$Values(56);
2496 };
2497
2498
2499 /**
2500 * Clears the values in the packed_uint32 field.
2501 */
2502 proto2.TestAllTypes.prototype.clearPackedUint32 = function() {
2503 this.clear$Field(56);
2504 };
2505
2506
2507 /**
2508 * Gets the value of the packed_uint64 field at the index given.
2509 * @param {number} index The index to lookup.
2510 * @return {?number} The value.
2511 */
2512 proto2.TestAllTypes.prototype.getPackedUint64 = function(index) {
2513 return /** @type {?number} */ (this.get$Value(57, index));
2514 };
2515
2516
2517 /**
2518 * Gets the value of the packed_uint64 field at the index given or the default value if not set.
2519 * @param {number} index The index to lookup.
2520 * @return {number} The value.
2521 */
2522 proto2.TestAllTypes.prototype.getPackedUint64OrDefault = function(index) {
2523 return /** @type {number} */ (this.get$ValueOrDefault(57, index));
2524 };
2525
2526
2527 /**
2528 * Adds a value to the packed_uint64 field.
2529 * @param {number} value The value to add.
2530 */
2531 proto2.TestAllTypes.prototype.addPackedUint64 = function(value) {
2532 this.add$Value(57, value);
2533 };
2534
2535
2536 /**
2537 * Returns the array of values in the packed_uint64 field.
2538 * @return {!Array<number>} The values in the field.
2539 */
2540 proto2.TestAllTypes.prototype.packedUint64Array = function() {
2541 return /** @type {!Array<number>} */ (this.array$Values(57));
2542 };
2543
2544
2545 /**
2546 * @return {boolean} Whether the packed_uint64 field has a value.
2547 */
2548 proto2.TestAllTypes.prototype.hasPackedUint64 = function() {
2549 return this.has$Value(57);
2550 };
2551
2552
2553 /**
2554 * @return {number} The number of values in the packed_uint64 field.
2555 */
2556 proto2.TestAllTypes.prototype.packedUint64Count = function() {
2557 return this.count$Values(57);
2558 };
2559
2560
2561 /**
2562 * Clears the values in the packed_uint64 field.
2563 */
2564 proto2.TestAllTypes.prototype.clearPackedUint64 = function() {
2565 this.clear$Field(57);
2566 };
2567
2568
2569 /**
2570 * Gets the value of the packed_sint32 field at the index given.
2571 * @param {number} index The index to lookup.
2572 * @return {?number} The value.
2573 */
2574 proto2.TestAllTypes.prototype.getPackedSint32 = function(index) {
2575 return /** @type {?number} */ (this.get$Value(58, index));
2576 };
2577
2578
2579 /**
2580 * Gets the value of the packed_sint32 field at the index given or the default value if not set.
2581 * @param {number} index The index to lookup.
2582 * @return {number} The value.
2583 */
2584 proto2.TestAllTypes.prototype.getPackedSint32OrDefault = function(index) {
2585 return /** @type {number} */ (this.get$ValueOrDefault(58, index));
2586 };
2587
2588
2589 /**
2590 * Adds a value to the packed_sint32 field.
2591 * @param {number} value The value to add.
2592 */
2593 proto2.TestAllTypes.prototype.addPackedSint32 = function(value) {
2594 this.add$Value(58, value);
2595 };
2596
2597
2598 /**
2599 * Returns the array of values in the packed_sint32 field.
2600 * @return {!Array<number>} The values in the field.
2601 */
2602 proto2.TestAllTypes.prototype.packedSint32Array = function() {
2603 return /** @type {!Array<number>} */ (this.array$Values(58));
2604 };
2605
2606
2607 /**
2608 * @return {boolean} Whether the packed_sint32 field has a value.
2609 */
2610 proto2.TestAllTypes.prototype.hasPackedSint32 = function() {
2611 return this.has$Value(58);
2612 };
2613
2614
2615 /**
2616 * @return {number} The number of values in the packed_sint32 field.
2617 */
2618 proto2.TestAllTypes.prototype.packedSint32Count = function() {
2619 return this.count$Values(58);
2620 };
2621
2622
2623 /**
2624 * Clears the values in the packed_sint32 field.
2625 */
2626 proto2.TestAllTypes.prototype.clearPackedSint32 = function() {
2627 this.clear$Field(58);
2628 };
2629
2630
2631 /**
2632 * Gets the value of the packed_sint64 field at the index given.
2633 * @param {number} index The index to lookup.
2634 * @return {?number} The value.
2635 */
2636 proto2.TestAllTypes.prototype.getPackedSint64 = function(index) {
2637 return /** @type {?number} */ (this.get$Value(59, index));
2638 };
2639
2640
2641 /**
2642 * Gets the value of the packed_sint64 field at the index given or the default value if not set.
2643 * @param {number} index The index to lookup.
2644 * @return {number} The value.
2645 */
2646 proto2.TestAllTypes.prototype.getPackedSint64OrDefault = function(index) {
2647 return /** @type {number} */ (this.get$ValueOrDefault(59, index));
2648 };
2649
2650
2651 /**
2652 * Adds a value to the packed_sint64 field.
2653 * @param {number} value The value to add.
2654 */
2655 proto2.TestAllTypes.prototype.addPackedSint64 = function(value) {
2656 this.add$Value(59, value);
2657 };
2658
2659
2660 /**
2661 * Returns the array of values in the packed_sint64 field.
2662 * @return {!Array<number>} The values in the field.
2663 */
2664 proto2.TestAllTypes.prototype.packedSint64Array = function() {
2665 return /** @type {!Array<number>} */ (this.array$Values(59));
2666 };
2667
2668
2669 /**
2670 * @return {boolean} Whether the packed_sint64 field has a value.
2671 */
2672 proto2.TestAllTypes.prototype.hasPackedSint64 = function() {
2673 return this.has$Value(59);
2674 };
2675
2676
2677 /**
2678 * @return {number} The number of values in the packed_sint64 field.
2679 */
2680 proto2.TestAllTypes.prototype.packedSint64Count = function() {
2681 return this.count$Values(59);
2682 };
2683
2684
2685 /**
2686 * Clears the values in the packed_sint64 field.
2687 */
2688 proto2.TestAllTypes.prototype.clearPackedSint64 = function() {
2689 this.clear$Field(59);
2690 };
2691
2692
2693 /**
2694 * Gets the value of the packed_fixed32 field at the index given.
2695 * @param {number} index The index to lookup.
2696 * @return {?number} The value.
2697 */
2698 proto2.TestAllTypes.prototype.getPackedFixed32 = function(index) {
2699 return /** @type {?number} */ (this.get$Value(60, index));
2700 };
2701
2702
2703 /**
2704 * Gets the value of the packed_fixed32 field at the index given or the default value if not set.
2705 * @param {number} index The index to lookup.
2706 * @return {number} The value.
2707 */
2708 proto2.TestAllTypes.prototype.getPackedFixed32OrDefault = function(index) {
2709 return /** @type {number} */ (this.get$ValueOrDefault(60, index));
2710 };
2711
2712
2713 /**
2714 * Adds a value to the packed_fixed32 field.
2715 * @param {number} value The value to add.
2716 */
2717 proto2.TestAllTypes.prototype.addPackedFixed32 = function(value) {
2718 this.add$Value(60, value);
2719 };
2720
2721
2722 /**
2723 * Returns the array of values in the packed_fixed32 field.
2724 * @return {!Array<number>} The values in the field.
2725 */
2726 proto2.TestAllTypes.prototype.packedFixed32Array = function() {
2727 return /** @type {!Array<number>} */ (this.array$Values(60));
2728 };
2729
2730
2731 /**
2732 * @return {boolean} Whether the packed_fixed32 field has a value.
2733 */
2734 proto2.TestAllTypes.prototype.hasPackedFixed32 = function() {
2735 return this.has$Value(60);
2736 };
2737
2738
2739 /**
2740 * @return {number} The number of values in the packed_fixed32 field.
2741 */
2742 proto2.TestAllTypes.prototype.packedFixed32Count = function() {
2743 return this.count$Values(60);
2744 };
2745
2746
2747 /**
2748 * Clears the values in the packed_fixed32 field.
2749 */
2750 proto2.TestAllTypes.prototype.clearPackedFixed32 = function() {
2751 this.clear$Field(60);
2752 };
2753
2754
2755 /**
2756 * Gets the value of the packed_fixed64 field at the index given.
2757 * @param {number} index The index to lookup.
2758 * @return {?number} The value.
2759 */
2760 proto2.TestAllTypes.prototype.getPackedFixed64 = function(index) {
2761 return /** @type {?number} */ (this.get$Value(61, index));
2762 };
2763
2764
2765 /**
2766 * Gets the value of the packed_fixed64 field at the index given or the default value if not set.
2767 * @param {number} index The index to lookup.
2768 * @return {number} The value.
2769 */
2770 proto2.TestAllTypes.prototype.getPackedFixed64OrDefault = function(index) {
2771 return /** @type {number} */ (this.get$ValueOrDefault(61, index));
2772 };
2773
2774
2775 /**
2776 * Adds a value to the packed_fixed64 field.
2777 * @param {number} value The value to add.
2778 */
2779 proto2.TestAllTypes.prototype.addPackedFixed64 = function(value) {
2780 this.add$Value(61, value);
2781 };
2782
2783
2784 /**
2785 * Returns the array of values in the packed_fixed64 field.
2786 * @return {!Array<number>} The values in the field.
2787 */
2788 proto2.TestAllTypes.prototype.packedFixed64Array = function() {
2789 return /** @type {!Array<number>} */ (this.array$Values(61));
2790 };
2791
2792
2793 /**
2794 * @return {boolean} Whether the packed_fixed64 field has a value.
2795 */
2796 proto2.TestAllTypes.prototype.hasPackedFixed64 = function() {
2797 return this.has$Value(61);
2798 };
2799
2800
2801 /**
2802 * @return {number} The number of values in the packed_fixed64 field.
2803 */
2804 proto2.TestAllTypes.prototype.packedFixed64Count = function() {
2805 return this.count$Values(61);
2806 };
2807
2808
2809 /**
2810 * Clears the values in the packed_fixed64 field.
2811 */
2812 proto2.TestAllTypes.prototype.clearPackedFixed64 = function() {
2813 this.clear$Field(61);
2814 };
2815
2816
2817 /**
2818 * Gets the value of the packed_sfixed32 field at the index given.
2819 * @param {number} index The index to lookup.
2820 * @return {?number} The value.
2821 */
2822 proto2.TestAllTypes.prototype.getPackedSfixed32 = function(index) {
2823 return /** @type {?number} */ (this.get$Value(62, index));
2824 };
2825
2826
2827 /**
2828 * Gets the value of the packed_sfixed32 field at the index given or the default value if not set.
2829 * @param {number} index The index to lookup.
2830 * @return {number} The value.
2831 */
2832 proto2.TestAllTypes.prototype.getPackedSfixed32OrDefault = function(index) {
2833 return /** @type {number} */ (this.get$ValueOrDefault(62, index));
2834 };
2835
2836
2837 /**
2838 * Adds a value to the packed_sfixed32 field.
2839 * @param {number} value The value to add.
2840 */
2841 proto2.TestAllTypes.prototype.addPackedSfixed32 = function(value) {
2842 this.add$Value(62, value);
2843 };
2844
2845
2846 /**
2847 * Returns the array of values in the packed_sfixed32 field.
2848 * @return {!Array<number>} The values in the field.
2849 */
2850 proto2.TestAllTypes.prototype.packedSfixed32Array = function() {
2851 return /** @type {!Array<number>} */ (this.array$Values(62));
2852 };
2853
2854
2855 /**
2856 * @return {boolean} Whether the packed_sfixed32 field has a value.
2857 */
2858 proto2.TestAllTypes.prototype.hasPackedSfixed32 = function() {
2859 return this.has$Value(62);
2860 };
2861
2862
2863 /**
2864 * @return {number} The number of values in the packed_sfixed32 field.
2865 */
2866 proto2.TestAllTypes.prototype.packedSfixed32Count = function() {
2867 return this.count$Values(62);
2868 };
2869
2870
2871 /**
2872 * Clears the values in the packed_sfixed32 field.
2873 */
2874 proto2.TestAllTypes.prototype.clearPackedSfixed32 = function() {
2875 this.clear$Field(62);
2876 };
2877
2878
2879 /**
2880 * Gets the value of the packed_sfixed64 field at the index given.
2881 * @param {number} index The index to lookup.
2882 * @return {?number} The value.
2883 */
2884 proto2.TestAllTypes.prototype.getPackedSfixed64 = function(index) {
2885 return /** @type {?number} */ (this.get$Value(63, index));
2886 };
2887
2888
2889 /**
2890 * Gets the value of the packed_sfixed64 field at the index given or the default value if not set.
2891 * @param {number} index The index to lookup.
2892 * @return {number} The value.
2893 */
2894 proto2.TestAllTypes.prototype.getPackedSfixed64OrDefault = function(index) {
2895 return /** @type {number} */ (this.get$ValueOrDefault(63, index));
2896 };
2897
2898
2899 /**
2900 * Adds a value to the packed_sfixed64 field.
2901 * @param {number} value The value to add.
2902 */
2903 proto2.TestAllTypes.prototype.addPackedSfixed64 = function(value) {
2904 this.add$Value(63, value);
2905 };
2906
2907
2908 /**
2909 * Returns the array of values in the packed_sfixed64 field.
2910 * @return {!Array<number>} The values in the field.
2911 */
2912 proto2.TestAllTypes.prototype.packedSfixed64Array = function() {
2913 return /** @type {!Array<number>} */ (this.array$Values(63));
2914 };
2915
2916
2917 /**
2918 * @return {boolean} Whether the packed_sfixed64 field has a value.
2919 */
2920 proto2.TestAllTypes.prototype.hasPackedSfixed64 = function() {
2921 return this.has$Value(63);
2922 };
2923
2924
2925 /**
2926 * @return {number} The number of values in the packed_sfixed64 field.
2927 */
2928 proto2.TestAllTypes.prototype.packedSfixed64Count = function() {
2929 return this.count$Values(63);
2930 };
2931
2932
2933 /**
2934 * Clears the values in the packed_sfixed64 field.
2935 */
2936 proto2.TestAllTypes.prototype.clearPackedSfixed64 = function() {
2937 this.clear$Field(63);
2938 };
2939
2940
2941 /**
2942 * Gets the value of the packed_float field at the index given.
2943 * @param {number} index The index to lookup.
2944 * @return {?number} The value.
2945 */
2946 proto2.TestAllTypes.prototype.getPackedFloat = function(index) {
2947 return /** @type {?number} */ (this.get$Value(64, index));
2948 };
2949
2950
2951 /**
2952 * Gets the value of the packed_float field at the index given or the default value if not set.
2953 * @param {number} index The index to lookup.
2954 * @return {number} The value.
2955 */
2956 proto2.TestAllTypes.prototype.getPackedFloatOrDefault = function(index) {
2957 return /** @type {number} */ (this.get$ValueOrDefault(64, index));
2958 };
2959
2960
2961 /**
2962 * Adds a value to the packed_float field.
2963 * @param {number} value The value to add.
2964 */
2965 proto2.TestAllTypes.prototype.addPackedFloat = function(value) {
2966 this.add$Value(64, value);
2967 };
2968
2969
2970 /**
2971 * Returns the array of values in the packed_float field.
2972 * @return {!Array<number>} The values in the field.
2973 */
2974 proto2.TestAllTypes.prototype.packedFloatArray = function() {
2975 return /** @type {!Array<number>} */ (this.array$Values(64));
2976 };
2977
2978
2979 /**
2980 * @return {boolean} Whether the packed_float field has a value.
2981 */
2982 proto2.TestAllTypes.prototype.hasPackedFloat = function() {
2983 return this.has$Value(64);
2984 };
2985
2986
2987 /**
2988 * @return {number} The number of values in the packed_float field.
2989 */
2990 proto2.TestAllTypes.prototype.packedFloatCount = function() {
2991 return this.count$Values(64);
2992 };
2993
2994
2995 /**
2996 * Clears the values in the packed_float field.
2997 */
2998 proto2.TestAllTypes.prototype.clearPackedFloat = function() {
2999 this.clear$Field(64);
3000 };
3001
3002
3003 /**
3004 * Gets the value of the packed_double field at the index given.
3005 * @param {number} index The index to lookup.
3006 * @return {?number} The value.
3007 */
3008 proto2.TestAllTypes.prototype.getPackedDouble = function(index) {
3009 return /** @type {?number} */ (this.get$Value(65, index));
3010 };
3011
3012
3013 /**
3014 * Gets the value of the packed_double field at the index given or the default value if not set.
3015 * @param {number} index The index to lookup.
3016 * @return {number} The value.
3017 */
3018 proto2.TestAllTypes.prototype.getPackedDoubleOrDefault = function(index) {
3019 return /** @type {number} */ (this.get$ValueOrDefault(65, index));
3020 };
3021
3022
3023 /**
3024 * Adds a value to the packed_double field.
3025 * @param {number} value The value to add.
3026 */
3027 proto2.TestAllTypes.prototype.addPackedDouble = function(value) {
3028 this.add$Value(65, value);
3029 };
3030
3031
3032 /**
3033 * Returns the array of values in the packed_double field.
3034 * @return {!Array<number>} The values in the field.
3035 */
3036 proto2.TestAllTypes.prototype.packedDoubleArray = function() {
3037 return /** @type {!Array<number>} */ (this.array$Values(65));
3038 };
3039
3040
3041 /**
3042 * @return {boolean} Whether the packed_double field has a value.
3043 */
3044 proto2.TestAllTypes.prototype.hasPackedDouble = function() {
3045 return this.has$Value(65);
3046 };
3047
3048
3049 /**
3050 * @return {number} The number of values in the packed_double field.
3051 */
3052 proto2.TestAllTypes.prototype.packedDoubleCount = function() {
3053 return this.count$Values(65);
3054 };
3055
3056
3057 /**
3058 * Clears the values in the packed_double field.
3059 */
3060 proto2.TestAllTypes.prototype.clearPackedDouble = function() {
3061 this.clear$Field(65);
3062 };
3063
3064
3065 /**
3066 * Gets the value of the packed_bool field at the index given.
3067 * @param {number} index The index to lookup.
3068 * @return {?boolean} The value.
3069 */
3070 proto2.TestAllTypes.prototype.getPackedBool = function(index) {
3071 return /** @type {?boolean} */ (this.get$Value(66, index));
3072 };
3073
3074
3075 /**
3076 * Gets the value of the packed_bool field at the index given or the default value if not set.
3077 * @param {number} index The index to lookup.
3078 * @return {boolean} The value.
3079 */
3080 proto2.TestAllTypes.prototype.getPackedBoolOrDefault = function(index) {
3081 return /** @type {boolean} */ (this.get$ValueOrDefault(66, index));
3082 };
3083
3084
3085 /**
3086 * Adds a value to the packed_bool field.
3087 * @param {boolean} value The value to add.
3088 */
3089 proto2.TestAllTypes.prototype.addPackedBool = function(value) {
3090 this.add$Value(66, value);
3091 };
3092
3093
3094 /**
3095 * Returns the array of values in the packed_bool field.
3096 * @return {!Array<boolean>} The values in the field.
3097 */
3098 proto2.TestAllTypes.prototype.packedBoolArray = function() {
3099 return /** @type {!Array<boolean>} */ (this.array$Values(66));
3100 };
3101
3102
3103 /**
3104 * @return {boolean} Whether the packed_bool field has a value.
3105 */
3106 proto2.TestAllTypes.prototype.hasPackedBool = function() {
3107 return this.has$Value(66);
3108 };
3109
3110
3111 /**
3112 * @return {number} The number of values in the packed_bool field.
3113 */
3114 proto2.TestAllTypes.prototype.packedBoolCount = function() {
3115 return this.count$Values(66);
3116 };
3117
3118
3119 /**
3120 * Clears the values in the packed_bool field.
3121 */
3122 proto2.TestAllTypes.prototype.clearPackedBool = function() {
3123 this.clear$Field(66);
3124 };
3125
3126
3127 /**
3128 * Enumeration NestedEnum.
3129 * @enum {number}
3130 */
3131 proto2.TestAllTypes.NestedEnum = {
3132 FOO: 0,
3133 OOF: 1,
3134 BAR: 2,
3135 BAZ: 3
3136 };
3137
3138
3139
3140 /**
3141 * Message NestedMessage.
3142 * @constructor
3143 * @extends {goog.proto2.Message}
3144 * @final
3145 */
3146 proto2.TestAllTypes.NestedMessage = function() {
3147 goog.proto2.Message.call(this);
3148 };
3149 goog.inherits(proto2.TestAllTypes.NestedMessage, goog.proto2.Message);
3150
3151
3152 /**
3153 * Descriptor for this message, deserialized lazily in getDescriptor().
3154 * @private {?goog.proto2.Descriptor}
3155 */
3156 proto2.TestAllTypes.NestedMessage.descriptor_ = null;
3157
3158
3159 /**
3160 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3161 * @return {!proto2.TestAllTypes.NestedMessage} The cloned message.
3162 * @override
3163 */
3164 proto2.TestAllTypes.NestedMessage.prototype.clone;
3165
3166
3167 /**
3168 * Gets the value of the b field.
3169 * @return {?number} The value.
3170 */
3171 proto2.TestAllTypes.NestedMessage.prototype.getB = function() {
3172 return /** @type {?number} */ (this.get$Value(1));
3173 };
3174
3175
3176 /**
3177 * Gets the value of the b field or the default value if not set.
3178 * @return {number} The value.
3179 */
3180 proto2.TestAllTypes.NestedMessage.prototype.getBOrDefault = function() {
3181 return /** @type {number} */ (this.get$ValueOrDefault(1));
3182 };
3183
3184
3185 /**
3186 * Sets the value of the b field.
3187 * @param {number} value The value.
3188 */
3189 proto2.TestAllTypes.NestedMessage.prototype.setB = function(value) {
3190 this.set$Value(1, value);
3191 };
3192
3193
3194 /**
3195 * @return {boolean} Whether the b field has a value.
3196 */
3197 proto2.TestAllTypes.NestedMessage.prototype.hasB = function() {
3198 return this.has$Value(1);
3199 };
3200
3201
3202 /**
3203 * @return {number} The number of values in the b field.
3204 */
3205 proto2.TestAllTypes.NestedMessage.prototype.bCount = function() {
3206 return this.count$Values(1);
3207 };
3208
3209
3210 /**
3211 * Clears the values in the b field.
3212 */
3213 proto2.TestAllTypes.NestedMessage.prototype.clearB = function() {
3214 this.clear$Field(1);
3215 };
3216
3217
3218 /**
3219 * Gets the value of the c field.
3220 * @return {?number} The value.
3221 */
3222 proto2.TestAllTypes.NestedMessage.prototype.getC = function() {
3223 return /** @type {?number} */ (this.get$Value(2));
3224 };
3225
3226
3227 /**
3228 * Gets the value of the c field or the default value if not set.
3229 * @return {number} The value.
3230 */
3231 proto2.TestAllTypes.NestedMessage.prototype.getCOrDefault = function() {
3232 return /** @type {number} */ (this.get$ValueOrDefault(2));
3233 };
3234
3235
3236 /**
3237 * Sets the value of the c field.
3238 * @param {number} value The value.
3239 */
3240 proto2.TestAllTypes.NestedMessage.prototype.setC = function(value) {
3241 this.set$Value(2, value);
3242 };
3243
3244
3245 /**
3246 * @return {boolean} Whether the c field has a value.
3247 */
3248 proto2.TestAllTypes.NestedMessage.prototype.hasC = function() {
3249 return this.has$Value(2);
3250 };
3251
3252
3253 /**
3254 * @return {number} The number of values in the c field.
3255 */
3256 proto2.TestAllTypes.NestedMessage.prototype.cCount = function() {
3257 return this.count$Values(2);
3258 };
3259
3260
3261 /**
3262 * Clears the values in the c field.
3263 */
3264 proto2.TestAllTypes.NestedMessage.prototype.clearC = function() {
3265 this.clear$Field(2);
3266 };
3267
3268
3269
3270 /**
3271 * Message OptionalGroup.
3272 * @constructor
3273 * @extends {goog.proto2.Message}
3274 * @final
3275 */
3276 proto2.TestAllTypes.OptionalGroup = function() {
3277 goog.proto2.Message.call(this);
3278 };
3279 goog.inherits(proto2.TestAllTypes.OptionalGroup, goog.proto2.Message);
3280
3281
3282 /**
3283 * Descriptor for this message, deserialized lazily in getDescriptor().
3284 * @private {?goog.proto2.Descriptor}
3285 */
3286 proto2.TestAllTypes.OptionalGroup.descriptor_ = null;
3287
3288
3289 /**
3290 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3291 * @return {!proto2.TestAllTypes.OptionalGroup} The cloned message.
3292 * @override
3293 */
3294 proto2.TestAllTypes.OptionalGroup.prototype.clone;
3295
3296
3297 /**
3298 * Gets the value of the a field.
3299 * @return {?number} The value.
3300 */
3301 proto2.TestAllTypes.OptionalGroup.prototype.getA = function() {
3302 return /** @type {?number} */ (this.get$Value(17));
3303 };
3304
3305
3306 /**
3307 * Gets the value of the a field or the default value if not set.
3308 * @return {number} The value.
3309 */
3310 proto2.TestAllTypes.OptionalGroup.prototype.getAOrDefault = function() {
3311 return /** @type {number} */ (this.get$ValueOrDefault(17));
3312 };
3313
3314
3315 /**
3316 * Sets the value of the a field.
3317 * @param {number} value The value.
3318 */
3319 proto2.TestAllTypes.OptionalGroup.prototype.setA = function(value) {
3320 this.set$Value(17, value);
3321 };
3322
3323
3324 /**
3325 * @return {boolean} Whether the a field has a value.
3326 */
3327 proto2.TestAllTypes.OptionalGroup.prototype.hasA = function() {
3328 return this.has$Value(17);
3329 };
3330
3331
3332 /**
3333 * @return {number} The number of values in the a field.
3334 */
3335 proto2.TestAllTypes.OptionalGroup.prototype.aCount = function() {
3336 return this.count$Values(17);
3337 };
3338
3339
3340 /**
3341 * Clears the values in the a field.
3342 */
3343 proto2.TestAllTypes.OptionalGroup.prototype.clearA = function() {
3344 this.clear$Field(17);
3345 };
3346
3347
3348
3349 /**
3350 * Message RepeatedGroup.
3351 * @constructor
3352 * @extends {goog.proto2.Message}
3353 * @final
3354 */
3355 proto2.TestAllTypes.RepeatedGroup = function() {
3356 goog.proto2.Message.call(this);
3357 };
3358 goog.inherits(proto2.TestAllTypes.RepeatedGroup, goog.proto2.Message);
3359
3360
3361 /**
3362 * Descriptor for this message, deserialized lazily in getDescriptor().
3363 * @private {?goog.proto2.Descriptor}
3364 */
3365 proto2.TestAllTypes.RepeatedGroup.descriptor_ = null;
3366
3367
3368 /**
3369 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3370 * @return {!proto2.TestAllTypes.RepeatedGroup} The cloned message.
3371 * @override
3372 */
3373 proto2.TestAllTypes.RepeatedGroup.prototype.clone;
3374
3375
3376 /**
3377 * Gets the value of the a field at the index given.
3378 * @param {number} index The index to lookup.
3379 * @return {?number} The value.
3380 */
3381 proto2.TestAllTypes.RepeatedGroup.prototype.getA = function(index) {
3382 return /** @type {?number} */ (this.get$Value(47, index));
3383 };
3384
3385
3386 /**
3387 * Gets the value of the a field at the index given or the default value if not set.
3388 * @param {number} index The index to lookup.
3389 * @return {number} The value.
3390 */
3391 proto2.TestAllTypes.RepeatedGroup.prototype.getAOrDefault = function(index) {
3392 return /** @type {number} */ (this.get$ValueOrDefault(47, index));
3393 };
3394
3395
3396 /**
3397 * Adds a value to the a field.
3398 * @param {number} value The value to add.
3399 */
3400 proto2.TestAllTypes.RepeatedGroup.prototype.addA = function(value) {
3401 this.add$Value(47, value);
3402 };
3403
3404
3405 /**
3406 * Returns the array of values in the a field.
3407 * @return {!Array<number>} The values in the field.
3408 */
3409 proto2.TestAllTypes.RepeatedGroup.prototype.aArray = function() {
3410 return /** @type {!Array<number>} */ (this.array$Values(47));
3411 };
3412
3413
3414 /**
3415 * @return {boolean} Whether the a field has a value.
3416 */
3417 proto2.TestAllTypes.RepeatedGroup.prototype.hasA = function() {
3418 return this.has$Value(47);
3419 };
3420
3421
3422 /**
3423 * @return {number} The number of values in the a field.
3424 */
3425 proto2.TestAllTypes.RepeatedGroup.prototype.aCount = function() {
3426 return this.count$Values(47);
3427 };
3428
3429
3430 /**
3431 * Clears the values in the a field.
3432 */
3433 proto2.TestAllTypes.RepeatedGroup.prototype.clearA = function() {
3434 this.clear$Field(47);
3435 };
3436
3437
3438
3439 /**
3440 * Message TestDefaultParent.
3441 * @constructor
3442 * @extends {goog.proto2.Message}
3443 * @final
3444 */
3445 proto2.TestDefaultParent = function() {
3446 goog.proto2.Message.call(this);
3447 };
3448 goog.inherits(proto2.TestDefaultParent, goog.proto2.Message);
3449
3450
3451 /**
3452 * Descriptor for this message, deserialized lazily in getDescriptor().
3453 * @private {?goog.proto2.Descriptor}
3454 */
3455 proto2.TestDefaultParent.descriptor_ = null;
3456
3457
3458 /**
3459 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3460 * @return {!proto2.TestDefaultParent} The cloned message.
3461 * @override
3462 */
3463 proto2.TestDefaultParent.prototype.clone;
3464
3465
3466 /**
3467 * Gets the value of the child field.
3468 * @return {?proto2.TestDefaultChild} The value.
3469 */
3470 proto2.TestDefaultParent.prototype.getChild = function() {
3471 return /** @type {?proto2.TestDefaultChild} */ (this.get$Value(1));
3472 };
3473
3474
3475 /**
3476 * Gets the value of the child field or the default value if not set.
3477 * @return {!proto2.TestDefaultChild} The value.
3478 */
3479 proto2.TestDefaultParent.prototype.getChildOrDefault = function() {
3480 return /** @type {!proto2.TestDefaultChild} */ (this.get$ValueOrDefault(1));
3481 };
3482
3483
3484 /**
3485 * Sets the value of the child field.
3486 * @param {!proto2.TestDefaultChild} value The value.
3487 */
3488 proto2.TestDefaultParent.prototype.setChild = function(value) {
3489 this.set$Value(1, value);
3490 };
3491
3492
3493 /**
3494 * @return {boolean} Whether the child field has a value.
3495 */
3496 proto2.TestDefaultParent.prototype.hasChild = function() {
3497 return this.has$Value(1);
3498 };
3499
3500
3501 /**
3502 * @return {number} The number of values in the child field.
3503 */
3504 proto2.TestDefaultParent.prototype.childCount = function() {
3505 return this.count$Values(1);
3506 };
3507
3508
3509 /**
3510 * Clears the values in the child field.
3511 */
3512 proto2.TestDefaultParent.prototype.clearChild = function() {
3513 this.clear$Field(1);
3514 };
3515
3516
3517
3518 /**
3519 * Message TestDefaultChild.
3520 * @constructor
3521 * @extends {goog.proto2.Message}
3522 * @final
3523 */
3524 proto2.TestDefaultChild = function() {
3525 goog.proto2.Message.call(this);
3526 };
3527 goog.inherits(proto2.TestDefaultChild, goog.proto2.Message);
3528
3529
3530 /**
3531 * Descriptor for this message, deserialized lazily in getDescriptor().
3532 * @private {?goog.proto2.Descriptor}
3533 */
3534 proto2.TestDefaultChild.descriptor_ = null;
3535
3536
3537 /**
3538 * Overrides {@link goog.proto2.Message#clone} to specify its exact return type.
3539 * @return {!proto2.TestDefaultChild} The cloned message.
3540 * @override
3541 */
3542 proto2.TestDefaultChild.prototype.clone;
3543
3544
3545 /**
3546 * Gets the value of the foo field.
3547 * @return {?boolean} The value.
3548 */
3549 proto2.TestDefaultChild.prototype.getFoo = function() {
3550 return /** @type {?boolean} */ (this.get$Value(1));
3551 };
3552
3553
3554 /**
3555 * Gets the value of the foo field or the default value if not set.
3556 * @return {boolean} The value.
3557 */
3558 proto2.TestDefaultChild.prototype.getFooOrDefault = function() {
3559 return /** @type {boolean} */ (this.get$ValueOrDefault(1));
3560 };
3561
3562
3563 /**
3564 * Sets the value of the foo field.
3565 * @param {boolean} value The value.
3566 */
3567 proto2.TestDefaultChild.prototype.setFoo = function(value) {
3568 this.set$Value(1, value);
3569 };
3570
3571
3572 /**
3573 * @return {boolean} Whether the foo field has a value.
3574 */
3575 proto2.TestDefaultChild.prototype.hasFoo = function() {
3576 return this.has$Value(1);
3577 };
3578
3579
3580 /**
3581 * @return {number} The number of values in the foo field.
3582 */
3583 proto2.TestDefaultChild.prototype.fooCount = function() {
3584 return this.count$Values(1);
3585 };
3586
3587
3588 /**
3589 * Clears the values in the foo field.
3590 */
3591 proto2.TestDefaultChild.prototype.clearFoo = function() {
3592 this.clear$Field(1);
3593 };
3594
3595
3596 /** @override */
3597 proto2.TestAllTypes.prototype.getDescriptor = function() {
3598 var descriptor = proto2.TestAllTypes.descriptor_;
3599 if (!descriptor) {
3600 // The descriptor is created lazily when we instantiate a new instance.
3601 var descriptorObj = {
3602 0: {
3603 name: 'TestAllTypes',
3604 fullName: 'TestAllTypes'
3605 },
3606 1: {
3607 name: 'optional_int32',
3608 fieldType: goog.proto2.Message.FieldType.INT32,
3609 type: Number
3610 },
3611 2: {
3612 name: 'optional_int64',
3613 fieldType: goog.proto2.Message.FieldType.INT64,
3614 defaultValue: '1',
3615 type: String
3616 },
3617 3: {
3618 name: 'optional_uint32',
3619 fieldType: goog.proto2.Message.FieldType.UINT32,
3620 type: Number
3621 },
3622 4: {
3623 name: 'optional_uint64',
3624 fieldType: goog.proto2.Message.FieldType.UINT64,
3625 type: String
3626 },
3627 5: {
3628 name: 'optional_sint32',
3629 fieldType: goog.proto2.Message.FieldType.SINT32,
3630 type: Number
3631 },
3632 6: {
3633 name: 'optional_sint64',
3634 fieldType: goog.proto2.Message.FieldType.SINT64,
3635 type: String
3636 },
3637 7: {
3638 name: 'optional_fixed32',
3639 fieldType: goog.proto2.Message.FieldType.FIXED32,
3640 type: Number
3641 },
3642 8: {
3643 name: 'optional_fixed64',
3644 fieldType: goog.proto2.Message.FieldType.FIXED64,
3645 type: String
3646 },
3647 9: {
3648 name: 'optional_sfixed32',
3649 fieldType: goog.proto2.Message.FieldType.SFIXED32,
3650 type: Number
3651 },
3652 10: {
3653 name: 'optional_sfixed64',
3654 fieldType: goog.proto2.Message.FieldType.SFIXED64,
3655 type: String
3656 },
3657 11: {
3658 name: 'optional_float',
3659 fieldType: goog.proto2.Message.FieldType.FLOAT,
3660 defaultValue: 1.5,
3661 type: Number
3662 },
3663 12: {
3664 name: 'optional_double',
3665 fieldType: goog.proto2.Message.FieldType.DOUBLE,
3666 type: Number
3667 },
3668 13: {
3669 name: 'optional_bool',
3670 fieldType: goog.proto2.Message.FieldType.BOOL,
3671 type: Boolean
3672 },
3673 14: {
3674 name: 'optional_string',
3675 fieldType: goog.proto2.Message.FieldType.STRING,
3676 type: String
3677 },
3678 15: {
3679 name: 'optional_bytes',
3680 fieldType: goog.proto2.Message.FieldType.BYTES,
3681 defaultValue: 'moo',
3682 type: String
3683 },
3684 16: {
3685 name: 'optionalgroup',
3686 fieldType: goog.proto2.Message.FieldType.GROUP,
3687 type: proto2.TestAllTypes.OptionalGroup
3688 },
3689 18: {
3690 name: 'optional_nested_message',
3691 fieldType: goog.proto2.Message.FieldType.MESSAGE,
3692 type: proto2.TestAllTypes.NestedMessage
3693 },
3694 21: {
3695 name: 'optional_nested_enum',
3696 fieldType: goog.proto2.Message.FieldType.ENUM,
3697 defaultValue: proto2.TestAllTypes.NestedEnum.FOO,
3698 type: proto2.TestAllTypes.NestedEnum
3699 },
3700 50: {
3701 name: 'optional_int64_number',
3702 fieldType: goog.proto2.Message.FieldType.INT64,
3703 defaultValue: 1000000000000000001,
3704 type: Number
3705 },
3706 51: {
3707 name: 'optional_int64_string',
3708 fieldType: goog.proto2.Message.FieldType.INT64,
3709 defaultValue: '1000000000000000001',
3710 type: String
3711 },
3712 31: {
3713 name: 'repeated_int32',
3714 repeated: true,
3715 fieldType: goog.proto2.Message.FieldType.INT32,
3716 type: Number
3717 },
3718 32: {
3719 name: 'repeated_int64',
3720 repeated: true,
3721 fieldType: goog.proto2.Message.FieldType.INT64,
3722 type: String
3723 },
3724 33: {
3725 name: 'repeated_uint32',
3726 repeated: true,
3727 fieldType: goog.proto2.Message.FieldType.UINT32,
3728 type: Number
3729 },
3730 34: {
3731 name: 'repeated_uint64',
3732 repeated: true,
3733 fieldType: goog.proto2.Message.FieldType.UINT64,
3734 type: String
3735 },
3736 35: {
3737 name: 'repeated_sint32',
3738 repeated: true,
3739 fieldType: goog.proto2.Message.FieldType.SINT32,
3740 type: Number
3741 },
3742 36: {
3743 name: 'repeated_sint64',
3744 repeated: true,
3745 fieldType: goog.proto2.Message.FieldType.SINT64,
3746 type: String
3747 },
3748 37: {
3749 name: 'repeated_fixed32',
3750 repeated: true,
3751 fieldType: goog.proto2.Message.FieldType.FIXED32,
3752 type: Number
3753 },
3754 38: {
3755 name: 'repeated_fixed64',
3756 repeated: true,
3757 fieldType: goog.proto2.Message.FieldType.FIXED64,
3758 type: String
3759 },
3760 39: {
3761 name: 'repeated_sfixed32',
3762 repeated: true,
3763 fieldType: goog.proto2.Message.FieldType.SFIXED32,
3764 type: Number
3765 },
3766 40: {
3767 name: 'repeated_sfixed64',
3768 repeated: true,
3769 fieldType: goog.proto2.Message.FieldType.SFIXED64,
3770 type: String
3771 },
3772 41: {
3773 name: 'repeated_float',
3774 repeated: true,
3775 fieldType: goog.proto2.Message.FieldType.FLOAT,
3776 type: Number
3777 },
3778 42: {
3779 name: 'repeated_double',
3780 repeated: true,
3781 fieldType: goog.proto2.Message.FieldType.DOUBLE,
3782 type: Number
3783 },
3784 43: {
3785 name: 'repeated_bool',
3786 repeated: true,
3787 fieldType: goog.proto2.Message.FieldType.BOOL,
3788 type: Boolean
3789 },
3790 44: {
3791 name: 'repeated_string',
3792 repeated: true,
3793 fieldType: goog.proto2.Message.FieldType.STRING,
3794 type: String
3795 },
3796 45: {
3797 name: 'repeated_bytes',
3798 repeated: true,
3799 fieldType: goog.proto2.Message.FieldType.BYTES,
3800 type: String
3801 },
3802 46: {
3803 name: 'repeatedgroup',
3804 repeated: true,
3805 fieldType: goog.proto2.Message.FieldType.GROUP,
3806 type: proto2.TestAllTypes.RepeatedGroup
3807 },
3808 48: {
3809 name: 'repeated_nested_message',
3810 repeated: true,
3811 fieldType: goog.proto2.Message.FieldType.MESSAGE,
3812 type: proto2.TestAllTypes.NestedMessage
3813 },
3814 49: {
3815 name: 'repeated_nested_enum',
3816 repeated: true,
3817 fieldType: goog.proto2.Message.FieldType.ENUM,
3818 defaultValue: proto2.TestAllTypes.NestedEnum.FOO,
3819 type: proto2.TestAllTypes.NestedEnum
3820 },
3821 52: {
3822 name: 'repeated_int64_number',
3823 repeated: true,
3824 fieldType: goog.proto2.Message.FieldType.INT64,
3825 type: Number
3826 },
3827 53: {
3828 name: 'repeated_int64_string',
3829 repeated: true,
3830 fieldType: goog.proto2.Message.FieldType.INT64,
3831 type: String
3832 },
3833 54: {
3834 name: 'packed_int32',
3835 repeated: true,
3836 packed: true,
3837 fieldType: goog.proto2.Message.FieldType.INT32,
3838 type: Number
3839 },
3840 55: {
3841 name: 'packed_int64',
3842 repeated: true,
3843 packed: true,
3844 fieldType: goog.proto2.Message.FieldType.INT64,
3845 type: Number
3846 },
3847 56: {
3848 name: 'packed_uint32',
3849 repeated: true,
3850 packed: true,
3851 fieldType: goog.proto2.Message.FieldType.UINT32,
3852 type: Number
3853 },
3854 57: {
3855 name: 'packed_uint64',
3856 repeated: true,
3857 packed: true,
3858 fieldType: goog.proto2.Message.FieldType.UINT64,
3859 type: Number
3860 },
3861 58: {
3862 name: 'packed_sint32',
3863 repeated: true,
3864 packed: true,
3865 fieldType: goog.proto2.Message.FieldType.SINT32,
3866 type: Number
3867 },
3868 59: {
3869 name: 'packed_sint64',
3870 repeated: true,
3871 packed: true,
3872 fieldType: goog.proto2.Message.FieldType.SINT64,
3873 type: Number
3874 },
3875 60: {
3876 name: 'packed_fixed32',
3877 repeated: true,
3878 packed: true,
3879 fieldType: goog.proto2.Message.FieldType.FIXED32,
3880 type: Number
3881 },
3882 61: {
3883 name: 'packed_fixed64',
3884 repeated: true,
3885 packed: true,
3886 fieldType: goog.proto2.Message.FieldType.FIXED64,
3887 type: Number
3888 },
3889 62: {
3890 name: 'packed_sfixed32',
3891 repeated: true,
3892 packed: true,
3893 fieldType: goog.proto2.Message.FieldType.SFIXED32,
3894 type: Number
3895 },
3896 63: {
3897 name: 'packed_sfixed64',
3898 repeated: true,
3899 packed: true,
3900 fieldType: goog.proto2.Message.FieldType.SFIXED64,
3901 type: Number
3902 },
3903 64: {
3904 name: 'packed_float',
3905 repeated: true,
3906 packed: true,
3907 fieldType: goog.proto2.Message.FieldType.FLOAT,
3908 type: Number
3909 },
3910 65: {
3911 name: 'packed_double',
3912 repeated: true,
3913 packed: true,
3914 fieldType: goog.proto2.Message.FieldType.DOUBLE,
3915 type: Number
3916 },
3917 66: {
3918 name: 'packed_bool',
3919 repeated: true,
3920 packed: true,
3921 fieldType: goog.proto2.Message.FieldType.BOOL,
3922 type: Boolean
3923 }
3924 };
3925 proto2.TestAllTypes.descriptor_ = descriptor =
3926 goog.proto2.Message.createDescriptor(
3927 proto2.TestAllTypes, descriptorObj);
3928 }
3929 return descriptor;
3930 };
3931
3932
3933 /** @nocollapse */
3934 proto2.TestAllTypes.getDescriptor =
3935 proto2.TestAllTypes.prototype.getDescriptor;
3936
3937
3938 /** @override */
3939 proto2.TestAllTypes.NestedMessage.prototype.getDescriptor = function() {
3940 var descriptor = proto2.TestAllTypes.NestedMessage.descriptor_;
3941 if (!descriptor) {
3942 // The descriptor is created lazily when we instantiate a new instance.
3943 var descriptorObj = {
3944 0: {
3945 name: 'NestedMessage',
3946 containingType: proto2.TestAllTypes,
3947 fullName: 'TestAllTypes.NestedMessage'
3948 },
3949 1: {
3950 name: 'b',
3951 fieldType: goog.proto2.Message.FieldType.INT32,
3952 type: Number
3953 },
3954 2: {
3955 name: 'c',
3956 fieldType: goog.proto2.Message.FieldType.INT32,
3957 type: Number
3958 }
3959 };
3960 proto2.TestAllTypes.NestedMessage.descriptor_ = descriptor =
3961 goog.proto2.Message.createDescriptor(
3962 proto2.TestAllTypes.NestedMessage, descriptorObj);
3963 }
3964 return descriptor;
3965 };
3966
3967
3968 /** @nocollapse */
3969 proto2.TestAllTypes.NestedMessage.getDescriptor =
3970 proto2.TestAllTypes.NestedMessage.prototype.getDescriptor;
3971
3972
3973 /** @override */
3974 proto2.TestAllTypes.OptionalGroup.prototype.getDescriptor = function() {
3975 var descriptor = proto2.TestAllTypes.OptionalGroup.descriptor_;
3976 if (!descriptor) {
3977 // The descriptor is created lazily when we instantiate a new instance.
3978 var descriptorObj = {
3979 0: {
3980 name: 'OptionalGroup',
3981 containingType: proto2.TestAllTypes,
3982 fullName: 'TestAllTypes.OptionalGroup'
3983 },
3984 17: {
3985 name: 'a',
3986 fieldType: goog.proto2.Message.FieldType.INT32,
3987 type: Number
3988 }
3989 };
3990 proto2.TestAllTypes.OptionalGroup.descriptor_ = descriptor =
3991 goog.proto2.Message.createDescriptor(
3992 proto2.TestAllTypes.OptionalGroup, descriptorObj);
3993 }
3994 return descriptor;
3995 };
3996
3997
3998 /** @nocollapse */
3999 proto2.TestAllTypes.OptionalGroup.getDescriptor =
4000 proto2.TestAllTypes.OptionalGroup.prototype.getDescriptor;
4001
4002
4003 /** @override */
4004 proto2.TestAllTypes.RepeatedGroup.prototype.getDescriptor = function() {
4005 var descriptor = proto2.TestAllTypes.RepeatedGroup.descriptor_;
4006 if (!descriptor) {
4007 // The descriptor is created lazily when we instantiate a new instance.
4008 var descriptorObj = {
4009 0: {
4010 name: 'RepeatedGroup',
4011 containingType: proto2.TestAllTypes,
4012 fullName: 'TestAllTypes.RepeatedGroup'
4013 },
4014 47: {
4015 name: 'a',
4016 repeated: true,
4017 fieldType: goog.proto2.Message.FieldType.INT32,
4018 type: Number
4019 }
4020 };
4021 proto2.TestAllTypes.RepeatedGroup.descriptor_ = descriptor =
4022 goog.proto2.Message.createDescriptor(
4023 proto2.TestAllTypes.RepeatedGroup, descriptorObj);
4024 }
4025 return descriptor;
4026 };
4027
4028
4029 /** @nocollapse */
4030 proto2.TestAllTypes.RepeatedGroup.getDescriptor =
4031 proto2.TestAllTypes.RepeatedGroup.prototype.getDescriptor;
4032
4033
4034 /** @override */
4035 proto2.TestDefaultParent.prototype.getDescriptor = function() {
4036 var descriptor = proto2.TestDefaultParent.descriptor_;
4037 if (!descriptor) {
4038 // The descriptor is created lazily when we instantiate a new instance.
4039 var descriptorObj = {
4040 0: {
4041 name: 'TestDefaultParent',
4042 fullName: 'TestDefaultParent'
4043 },
4044 1: {
4045 name: 'child',
4046 fieldType: goog.proto2.Message.FieldType.MESSAGE,
4047 type: proto2.TestDefaultChild
4048 }
4049 };
4050 proto2.TestDefaultParent.descriptor_ = descriptor =
4051 goog.proto2.Message.createDescriptor(
4052 proto2.TestDefaultParent, descriptorObj);
4053 }
4054 return descriptor;
4055 };
4056
4057
4058 /** @nocollapse */
4059 proto2.TestDefaultParent.getDescriptor =
4060 proto2.TestDefaultParent.prototype.getDescriptor;
4061
4062
4063 /** @override */
4064 proto2.TestDefaultChild.prototype.getDescriptor = function() {
4065 var descriptor = proto2.TestDefaultChild.descriptor_;
4066 if (!descriptor) {
4067 // The descriptor is created lazily when we instantiate a new instance.
4068 var descriptorObj = {
4069 0: {
4070 name: 'TestDefaultChild',
4071 fullName: 'TestDefaultChild'
4072 },
4073 1: {
4074 name: 'foo',
4075 fieldType: goog.proto2.Message.FieldType.BOOL,
4076 defaultValue: true,
4077 type: Boolean
4078 }
4079 };
4080 proto2.TestDefaultChild.descriptor_ = descriptor =
4081 goog.proto2.Message.createDescriptor(
4082 proto2.TestDefaultChild, descriptorObj);
4083 }
4084 return descriptor;
4085 };
4086
4087
4088 /** @nocollapse */
4089 proto2.TestDefaultChild.getDescriptor =
4090 proto2.TestDefaultChild.prototype.getDescriptor;