001 //
002 // Generated by protoc, do not edit by hand.
003 //
004 package protobuf_unittest;
005
006 public class UnittestProto {
007
008 public static enum ForeignEnum {
009
010 FOREIGN_FOO("FOREIGN_FOO", 4),
011 FOREIGN_BAR("FOREIGN_BAR", 5),
012 FOREIGN_BAZ("FOREIGN_BAZ", 6);
013
014 private final String name;
015 private final int value;
016
017 private ForeignEnum(String name, int value) {
018 this.name = name;
019 this.value = value;
020 }
021
022 public final int getNumber() {
023 return value;
024 }
025
026 public final String toString() {
027 return name;
028 }
029
030 public static ForeignEnum valueOf(int value) {
031 switch (value) {
032 case 4:
033 return FOREIGN_FOO;
034 case 5:
035 return FOREIGN_BAR;
036 case 6:
037 return FOREIGN_BAZ;
038 default:
039 return null;
040 }
041 }
042
043 }
044
045
046 public static enum TestEnumWithDupValue {
047
048 FOO1("FOO1", 1),
049 BAR1("BAR1", 2),
050 BAZ("BAZ", 3),
051 FOO2("FOO2", 1),
052 BAR2("BAR2", 2);
053
054 private final String name;
055 private final int value;
056
057 private TestEnumWithDupValue(String name, int value) {
058 this.name = name;
059 this.value = value;
060 }
061
062 public final int getNumber() {
063 return value;
064 }
065
066 public final String toString() {
067 return name;
068 }
069
070 public static TestEnumWithDupValue valueOf(int value) {
071 switch (value) {
072 case 1:
073 return FOO1;
074 case 2:
075 return BAR1;
076 case 3:
077 return BAZ;
078 default:
079 return null;
080 }
081 }
082
083 }
084
085
086 public static enum TestSparseEnum {
087
088 SPARSE_A("SPARSE_A", 123),
089 SPARSE_B("SPARSE_B", 62374),
090 SPARSE_C("SPARSE_C", 12589234),
091 SPARSE_D("SPARSE_D", -15),
092 SPARSE_E("SPARSE_E", -53452),
093 SPARSE_F("SPARSE_F", 0),
094 SPARSE_G("SPARSE_G", 2);
095
096 private final String name;
097 private final int value;
098
099 private TestSparseEnum(String name, int value) {
100 this.name = name;
101 this.value = value;
102 }
103
104 public final int getNumber() {
105 return value;
106 }
107
108 public final String toString() {
109 return name;
110 }
111
112 public static TestSparseEnum valueOf(int value) {
113 switch (value) {
114 case 123:
115 return SPARSE_A;
116 case 62374:
117 return SPARSE_B;
118 case 12589234:
119 return SPARSE_C;
120 case -15:
121 return SPARSE_D;
122 case -53452:
123 return SPARSE_E;
124 case 0:
125 return SPARSE_F;
126 case 2:
127 return SPARSE_G;
128 default:
129 return null;
130 }
131 }
132
133 }
134
135
136 static public final class TestAllTypes extends TestAllTypesBase<TestAllTypes> {
137
138
139 public static enum NestedEnum {
140
141 FOO("FOO", 1),
142 BAR("BAR", 2),
143 BAZ("BAZ", 3);
144
145 private final String name;
146 private final int value;
147
148 private NestedEnum(String name, int value) {
149 this.name = name;
150 this.value = value;
151 }
152
153 public final int getNumber() {
154 return value;
155 }
156
157 public final String toString() {
158 return name;
159 }
160
161 public static NestedEnum valueOf(int value) {
162 switch (value) {
163 case 1:
164 return FOO;
165 case 2:
166 return BAR;
167 case 3:
168 return BAZ;
169 default:
170 return null;
171 }
172 }
173
174 }
175
176
177 static public final class NestedMessage extends NestedMessageBase<NestedMessage> {
178
179 public java.util.ArrayList<String> missingFields() {
180 java.util.ArrayList<String> missingFields = super.missingFields();
181 return missingFields;
182 }
183
184 public void clear() {
185 super.clear();
186 clearBb();
187 }
188
189 public NestedMessage clone() {
190 return new NestedMessage().mergeFrom(this);
191 }
192
193 public NestedMessage mergeFrom(NestedMessage other) {
194 if (other.hasBb()) {
195 setBb(other.getBb());
196 }
197 return this;
198 }
199
200 public int serializedSizeUnframed() {
201 if (memoizedSerializedSize != -1)
202 return memoizedSerializedSize;
203
204 int size = 0;
205 if (hasBb()) {
206 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getBb());
207 }
208 memoizedSerializedSize = size;
209 return size;
210 }
211
212 public NestedMessage mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
213 while (true) {
214 int tag = input.readTag();
215 if ((tag & 0x07) == 4) {
216 return this;
217 }
218 switch (tag) {
219 case 0:
220 return this;
221 default: {
222 break;
223 }
224 case 8:
225 setBb(input.readInt32());
226 break;
227 }
228 }
229 }
230 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
231 if (hasBb()) {
232 output.writeInt32(1, getBb());
233 }
234 }
235
236 public static NestedMessage parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
237 return new NestedMessage().mergeUnframed(data).checktInitialized();
238 }
239
240 public static NestedMessage parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
241 return new NestedMessage().mergeUnframed(data).checktInitialized();
242 }
243
244 public static NestedMessage parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
245 return new NestedMessage().mergeUnframed(data).checktInitialized();
246 }
247
248 public static NestedMessage parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
249 return new NestedMessage().mergeUnframed(data).checktInitialized();
250 }
251
252 public static NestedMessage parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
253 return new NestedMessage().mergeFramed(data).checktInitialized();
254 }
255
256 public static NestedMessage parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
257 return new NestedMessage().mergeFramed(data).checktInitialized();
258 }
259
260 public static NestedMessage parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
261 return new NestedMessage().mergeFramed(data).checktInitialized();
262 }
263
264 public static NestedMessage parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
265 return new NestedMessage().mergeFramed(data).checktInitialized();
266 }
267
268 public String toString() {
269 return toString(new java.lang.StringBuilder(), "").toString();
270 }
271
272 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
273 if( hasBb() ) {
274 sb.append(prefix+"bb: ");
275 sb.append(getBb());
276 sb.append("\n");
277 }
278 return sb;
279 }
280
281 public boolean equals(Object obj) {
282 if( obj==this )
283 return true;
284
285 if( obj==null || obj.getClass()!=NestedMessage.class )
286 return false;
287
288 return equals((NestedMessage)obj);
289 }
290
291 public boolean equals(NestedMessage obj) {
292 if (hasBb() ^ obj.hasBb() )
293 return false;
294 if (hasBb() && ( getBb()!=obj.getBb() ))
295 return false;
296 return true;
297 }
298
299 public int hashCode() {
300 int rc=-132205840;
301 if (hasBb()) {
302 rc ^= ( 2144^getBb() );
303 }
304 return rc;
305 }
306
307 }
308
309 static abstract class NestedMessageBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
310
311 // optional int32 bb = 1;
312 private int f_bb = 0;
313 private boolean b_bb;
314
315 public boolean hasBb() {
316 return this.b_bb;
317 }
318
319 public int getBb() {
320 return this.f_bb;
321 }
322
323 public T setBb(int bb) {
324 loadAndClear();
325 this.b_bb = true;
326 this.f_bb = bb;
327 return (T)this;
328 }
329
330 public void clearBb() {
331 loadAndClear();
332 this.b_bb = false;
333 this.f_bb = 0;
334 }
335
336 }
337
338
339 static public final class OptionalGroup extends OptionalGroupBase<OptionalGroup> {
340
341 public java.util.ArrayList<String> missingFields() {
342 java.util.ArrayList<String> missingFields = super.missingFields();
343 return missingFields;
344 }
345
346 public void clear() {
347 super.clear();
348 clearA();
349 }
350
351 public OptionalGroup clone() {
352 return new OptionalGroup().mergeFrom(this);
353 }
354
355 public OptionalGroup mergeFrom(OptionalGroup other) {
356 if (other.hasA()) {
357 setA(other.getA());
358 }
359 return this;
360 }
361
362 public int serializedSizeUnframed() {
363 if (memoizedSerializedSize != -1)
364 return memoizedSerializedSize;
365
366 int size = 0;
367 if (hasA()) {
368 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(17, getA());
369 }
370 memoizedSerializedSize = size;
371 return size;
372 }
373
374 public OptionalGroup mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
375 while (true) {
376 int tag = input.readTag();
377 if ((tag & 0x07) == 4) {
378 return this;
379 }
380 switch (tag) {
381 case 0:
382 return this;
383 default: {
384 break;
385 }
386 case 136:
387 setA(input.readInt32());
388 break;
389 }
390 }
391 }
392 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
393 if (hasA()) {
394 output.writeInt32(17, getA());
395 }
396 }
397
398 public static OptionalGroup parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
399 return new OptionalGroup().mergeUnframed(data).checktInitialized();
400 }
401
402 public static OptionalGroup parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
403 return new OptionalGroup().mergeUnframed(data).checktInitialized();
404 }
405
406 public static OptionalGroup parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
407 return new OptionalGroup().mergeUnframed(data).checktInitialized();
408 }
409
410 public static OptionalGroup parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
411 return new OptionalGroup().mergeUnframed(data).checktInitialized();
412 }
413
414 public static OptionalGroup parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
415 return new OptionalGroup().mergeFramed(data).checktInitialized();
416 }
417
418 public static OptionalGroup parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
419 return new OptionalGroup().mergeFramed(data).checktInitialized();
420 }
421
422 public static OptionalGroup parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
423 return new OptionalGroup().mergeFramed(data).checktInitialized();
424 }
425
426 public static OptionalGroup parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
427 return new OptionalGroup().mergeFramed(data).checktInitialized();
428 }
429
430 public String toString() {
431 return toString(new java.lang.StringBuilder(), "").toString();
432 }
433
434 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
435 if( hasA() ) {
436 sb.append(prefix+"a: ");
437 sb.append(getA());
438 sb.append("\n");
439 }
440 return sb;
441 }
442
443 public boolean equals(Object obj) {
444 if( obj==this )
445 return true;
446
447 if( obj==null || obj.getClass()!=OptionalGroup.class )
448 return false;
449
450 return equals((OptionalGroup)obj);
451 }
452
453 public boolean equals(OptionalGroup obj) {
454 if (hasA() ^ obj.hasA() )
455 return false;
456 if (hasA() && ( getA()!=obj.getA() ))
457 return false;
458 return true;
459 }
460
461 public int hashCode() {
462 int rc=1442514655;
463 if (hasA()) {
464 rc ^= ( 65^getA() );
465 }
466 return rc;
467 }
468
469 }
470
471 static abstract class OptionalGroupBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
472
473 // optional int32 a = 17;
474 private int f_a = 0;
475 private boolean b_a;
476
477 public boolean hasA() {
478 return this.b_a;
479 }
480
481 public int getA() {
482 return this.f_a;
483 }
484
485 public T setA(int a) {
486 loadAndClear();
487 this.b_a = true;
488 this.f_a = a;
489 return (T)this;
490 }
491
492 public void clearA() {
493 loadAndClear();
494 this.b_a = false;
495 this.f_a = 0;
496 }
497
498 }
499
500
501 static public final class RepeatedGroup extends RepeatedGroupBase<RepeatedGroup> {
502
503 public java.util.ArrayList<String> missingFields() {
504 java.util.ArrayList<String> missingFields = super.missingFields();
505 return missingFields;
506 }
507
508 public void clear() {
509 super.clear();
510 clearA();
511 }
512
513 public RepeatedGroup clone() {
514 return new RepeatedGroup().mergeFrom(this);
515 }
516
517 public RepeatedGroup mergeFrom(RepeatedGroup other) {
518 if (other.hasA()) {
519 setA(other.getA());
520 }
521 return this;
522 }
523
524 public int serializedSizeUnframed() {
525 if (memoizedSerializedSize != -1)
526 return memoizedSerializedSize;
527
528 int size = 0;
529 if (hasA()) {
530 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(47, getA());
531 }
532 memoizedSerializedSize = size;
533 return size;
534 }
535
536 public RepeatedGroup mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
537 while (true) {
538 int tag = input.readTag();
539 if ((tag & 0x07) == 4) {
540 return this;
541 }
542 switch (tag) {
543 case 0:
544 return this;
545 default: {
546 break;
547 }
548 case 376:
549 setA(input.readInt32());
550 break;
551 }
552 }
553 }
554 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
555 if (hasA()) {
556 output.writeInt32(47, getA());
557 }
558 }
559
560 public static RepeatedGroup parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
561 return new RepeatedGroup().mergeUnframed(data).checktInitialized();
562 }
563
564 public static RepeatedGroup parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
565 return new RepeatedGroup().mergeUnframed(data).checktInitialized();
566 }
567
568 public static RepeatedGroup parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
569 return new RepeatedGroup().mergeUnframed(data).checktInitialized();
570 }
571
572 public static RepeatedGroup parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
573 return new RepeatedGroup().mergeUnframed(data).checktInitialized();
574 }
575
576 public static RepeatedGroup parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
577 return new RepeatedGroup().mergeFramed(data).checktInitialized();
578 }
579
580 public static RepeatedGroup parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
581 return new RepeatedGroup().mergeFramed(data).checktInitialized();
582 }
583
584 public static RepeatedGroup parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
585 return new RepeatedGroup().mergeFramed(data).checktInitialized();
586 }
587
588 public static RepeatedGroup parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
589 return new RepeatedGroup().mergeFramed(data).checktInitialized();
590 }
591
592 public String toString() {
593 return toString(new java.lang.StringBuilder(), "").toString();
594 }
595
596 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
597 if( hasA() ) {
598 sb.append(prefix+"a: ");
599 sb.append(getA());
600 sb.append("\n");
601 }
602 return sb;
603 }
604
605 public boolean equals(Object obj) {
606 if( obj==this )
607 return true;
608
609 if( obj==null || obj.getClass()!=RepeatedGroup.class )
610 return false;
611
612 return equals((RepeatedGroup)obj);
613 }
614
615 public boolean equals(RepeatedGroup obj) {
616 if (hasA() ^ obj.hasA() )
617 return false;
618 if (hasA() && ( getA()!=obj.getA() ))
619 return false;
620 return true;
621 }
622
623 public int hashCode() {
624 int rc=-1046179067;
625 if (hasA()) {
626 rc ^= ( 65^getA() );
627 }
628 return rc;
629 }
630
631 }
632
633 static abstract class RepeatedGroupBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
634
635 // optional int32 a = 47;
636 private int f_a = 0;
637 private boolean b_a;
638
639 public boolean hasA() {
640 return this.b_a;
641 }
642
643 public int getA() {
644 return this.f_a;
645 }
646
647 public T setA(int a) {
648 loadAndClear();
649 this.b_a = true;
650 this.f_a = a;
651 return (T)this;
652 }
653
654 public void clearA() {
655 loadAndClear();
656 this.b_a = false;
657 this.f_a = 0;
658 }
659
660 }
661
662 public java.util.ArrayList<String> missingFields() {
663 java.util.ArrayList<String> missingFields = super.missingFields();
664 if( hasOptionalGroup() ) {
665 try {
666 getOptionalGroup().assertInitialized();
667 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
668 missingFields.addAll(prefix(e.getMissingFields(),"OptionalGroup."));
669 }
670 }
671 if( hasOptionalNestedMessage() ) {
672 try {
673 getOptionalNestedMessage().assertInitialized();
674 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
675 missingFields.addAll(prefix(e.getMissingFields(),"optional_nested_message."));
676 }
677 }
678 if( hasOptionalForeignMessage() ) {
679 try {
680 getOptionalForeignMessage().assertInitialized();
681 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
682 missingFields.addAll(prefix(e.getMissingFields(),"optional_foreign_message."));
683 }
684 }
685 if( hasOptionalImportMessage() ) {
686 try {
687 getOptionalImportMessage().assertInitialized();
688 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
689 missingFields.addAll(prefix(e.getMissingFields(),"optional_import_message."));
690 }
691 }
692 if( hasRepeatedGroup() ) {
693 java.util.List<TestAllTypes.RepeatedGroup> l = getRepeatedGroupList();
694 for( int i=0; i < l.size(); i++ ) {
695 try {
696 l.get(i).assertInitialized();
697 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
698 missingFields.addAll(prefix(e.getMissingFields(),"RepeatedGroup["+i+"]"));
699 }
700 }
701 }
702 if( hasRepeatedNestedMessage() ) {
703 java.util.List<TestAllTypes.NestedMessage> l = getRepeatedNestedMessageList();
704 for( int i=0; i < l.size(); i++ ) {
705 try {
706 l.get(i).assertInitialized();
707 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
708 missingFields.addAll(prefix(e.getMissingFields(),"repeated_nested_message["+i+"]"));
709 }
710 }
711 }
712 if( hasRepeatedForeignMessage() ) {
713 java.util.List<ForeignMessage> l = getRepeatedForeignMessageList();
714 for( int i=0; i < l.size(); i++ ) {
715 try {
716 l.get(i).assertInitialized();
717 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
718 missingFields.addAll(prefix(e.getMissingFields(),"repeated_foreign_message["+i+"]"));
719 }
720 }
721 }
722 if( hasRepeatedImportMessage() ) {
723 java.util.List<com.google.protobuf.test.UnittestImport.ImportMessage> l = getRepeatedImportMessageList();
724 for( int i=0; i < l.size(); i++ ) {
725 try {
726 l.get(i).assertInitialized();
727 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
728 missingFields.addAll(prefix(e.getMissingFields(),"repeated_import_message["+i+"]"));
729 }
730 }
731 }
732 return missingFields;
733 }
734
735 public void clear() {
736 super.clear();
737 clearOptionalInt32();
738 clearOptionalInt64();
739 clearOptionalUint32();
740 clearOptionalUint64();
741 clearOptionalSint32();
742 clearOptionalSint64();
743 clearOptionalFixed32();
744 clearOptionalFixed64();
745 clearOptionalSfixed32();
746 clearOptionalSfixed64();
747 clearOptionalFloat();
748 clearOptionalDouble();
749 clearOptionalBool();
750 clearOptionalString();
751 clearOptionalBytes();
752 clearOptionalGroup();
753 clearOptionalNestedMessage();
754 clearOptionalForeignMessage();
755 clearOptionalImportMessage();
756 clearOptionalNestedEnum();
757 clearOptionalForeignEnum();
758 clearOptionalImportEnum();
759 clearOptionalStringPiece();
760 clearOptionalCord();
761 clearRepeatedInt32();
762 clearRepeatedInt64();
763 clearRepeatedUint32();
764 clearRepeatedUint64();
765 clearRepeatedSint32();
766 clearRepeatedSint64();
767 clearRepeatedFixed32();
768 clearRepeatedFixed64();
769 clearRepeatedSfixed32();
770 clearRepeatedSfixed64();
771 clearRepeatedFloat();
772 clearRepeatedDouble();
773 clearRepeatedBool();
774 clearRepeatedString();
775 clearRepeatedBytes();
776 clearRepeatedGroup();
777 clearRepeatedNestedMessage();
778 clearRepeatedForeignMessage();
779 clearRepeatedImportMessage();
780 clearRepeatedNestedEnum();
781 clearRepeatedForeignEnum();
782 clearRepeatedImportEnum();
783 clearRepeatedStringPiece();
784 clearRepeatedCord();
785 clearDefaultInt32();
786 clearDefaultInt64();
787 clearDefaultUint32();
788 clearDefaultUint64();
789 clearDefaultSint32();
790 clearDefaultSint64();
791 clearDefaultFixed32();
792 clearDefaultFixed64();
793 clearDefaultSfixed32();
794 clearDefaultSfixed64();
795 clearDefaultFloat();
796 clearDefaultDouble();
797 clearDefaultBool();
798 clearDefaultString();
799 clearDefaultBytes();
800 clearDefaultNestedEnum();
801 clearDefaultForeignEnum();
802 clearDefaultImportEnum();
803 clearDefaultStringPiece();
804 clearDefaultCord();
805 }
806
807 public TestAllTypes clone() {
808 return new TestAllTypes().mergeFrom(this);
809 }
810
811 public TestAllTypes mergeFrom(TestAllTypes other) {
812 if (other.hasOptionalInt32()) {
813 setOptionalInt32(other.getOptionalInt32());
814 }
815 if (other.hasOptionalInt64()) {
816 setOptionalInt64(other.getOptionalInt64());
817 }
818 if (other.hasOptionalUint32()) {
819 setOptionalUint32(other.getOptionalUint32());
820 }
821 if (other.hasOptionalUint64()) {
822 setOptionalUint64(other.getOptionalUint64());
823 }
824 if (other.hasOptionalSint32()) {
825 setOptionalSint32(other.getOptionalSint32());
826 }
827 if (other.hasOptionalSint64()) {
828 setOptionalSint64(other.getOptionalSint64());
829 }
830 if (other.hasOptionalFixed32()) {
831 setOptionalFixed32(other.getOptionalFixed32());
832 }
833 if (other.hasOptionalFixed64()) {
834 setOptionalFixed64(other.getOptionalFixed64());
835 }
836 if (other.hasOptionalSfixed32()) {
837 setOptionalSfixed32(other.getOptionalSfixed32());
838 }
839 if (other.hasOptionalSfixed64()) {
840 setOptionalSfixed64(other.getOptionalSfixed64());
841 }
842 if (other.hasOptionalFloat()) {
843 setOptionalFloat(other.getOptionalFloat());
844 }
845 if (other.hasOptionalDouble()) {
846 setOptionalDouble(other.getOptionalDouble());
847 }
848 if (other.hasOptionalBool()) {
849 setOptionalBool(other.getOptionalBool());
850 }
851 if (other.hasOptionalString()) {
852 setOptionalString(other.getOptionalString());
853 }
854 if (other.hasOptionalBytes()) {
855 setOptionalBytes(other.getOptionalBytes());
856 }
857 if (other.hasOptionalGroup()) {
858 if (hasOptionalGroup()) {
859 getOptionalGroup().mergeFrom(other.getOptionalGroup());
860 } else {
861 setOptionalGroup(other.getOptionalGroup().clone());
862 }
863 }
864 if (other.hasOptionalNestedMessage()) {
865 if (hasOptionalNestedMessage()) {
866 getOptionalNestedMessage().mergeFrom(other.getOptionalNestedMessage());
867 } else {
868 setOptionalNestedMessage(other.getOptionalNestedMessage().clone());
869 }
870 }
871 if (other.hasOptionalForeignMessage()) {
872 if (hasOptionalForeignMessage()) {
873 getOptionalForeignMessage().mergeFrom(other.getOptionalForeignMessage());
874 } else {
875 setOptionalForeignMessage(other.getOptionalForeignMessage().clone());
876 }
877 }
878 if (other.hasOptionalImportMessage()) {
879 if (hasOptionalImportMessage()) {
880 getOptionalImportMessage().mergeFrom(other.getOptionalImportMessage());
881 } else {
882 setOptionalImportMessage(other.getOptionalImportMessage().clone());
883 }
884 }
885 if (other.hasOptionalNestedEnum()) {
886 setOptionalNestedEnum(other.getOptionalNestedEnum());
887 }
888 if (other.hasOptionalForeignEnum()) {
889 setOptionalForeignEnum(other.getOptionalForeignEnum());
890 }
891 if (other.hasOptionalImportEnum()) {
892 setOptionalImportEnum(other.getOptionalImportEnum());
893 }
894 if (other.hasOptionalStringPiece()) {
895 setOptionalStringPiece(other.getOptionalStringPiece());
896 }
897 if (other.hasOptionalCord()) {
898 setOptionalCord(other.getOptionalCord());
899 }
900 if (other.hasRepeatedInt32()) {
901 getRepeatedInt32List().addAll(other.getRepeatedInt32List());
902 }
903 if (other.hasRepeatedInt64()) {
904 getRepeatedInt64List().addAll(other.getRepeatedInt64List());
905 }
906 if (other.hasRepeatedUint32()) {
907 getRepeatedUint32List().addAll(other.getRepeatedUint32List());
908 }
909 if (other.hasRepeatedUint64()) {
910 getRepeatedUint64List().addAll(other.getRepeatedUint64List());
911 }
912 if (other.hasRepeatedSint32()) {
913 getRepeatedSint32List().addAll(other.getRepeatedSint32List());
914 }
915 if (other.hasRepeatedSint64()) {
916 getRepeatedSint64List().addAll(other.getRepeatedSint64List());
917 }
918 if (other.hasRepeatedFixed32()) {
919 getRepeatedFixed32List().addAll(other.getRepeatedFixed32List());
920 }
921 if (other.hasRepeatedFixed64()) {
922 getRepeatedFixed64List().addAll(other.getRepeatedFixed64List());
923 }
924 if (other.hasRepeatedSfixed32()) {
925 getRepeatedSfixed32List().addAll(other.getRepeatedSfixed32List());
926 }
927 if (other.hasRepeatedSfixed64()) {
928 getRepeatedSfixed64List().addAll(other.getRepeatedSfixed64List());
929 }
930 if (other.hasRepeatedFloat()) {
931 getRepeatedFloatList().addAll(other.getRepeatedFloatList());
932 }
933 if (other.hasRepeatedDouble()) {
934 getRepeatedDoubleList().addAll(other.getRepeatedDoubleList());
935 }
936 if (other.hasRepeatedBool()) {
937 getRepeatedBoolList().addAll(other.getRepeatedBoolList());
938 }
939 if (other.hasRepeatedString()) {
940 getRepeatedStringList().addAll(other.getRepeatedStringList());
941 }
942 if (other.hasRepeatedBytes()) {
943 getRepeatedBytesList().addAll(other.getRepeatedBytesList());
944 }
945 if (other.hasRepeatedGroup()) {
946 for(TestAllTypes.RepeatedGroup element: other.getRepeatedGroupList() ) {
947 getRepeatedGroupList().add(element.clone());
948 }
949 }
950 if (other.hasRepeatedNestedMessage()) {
951 for(TestAllTypes.NestedMessage element: other.getRepeatedNestedMessageList() ) {
952 getRepeatedNestedMessageList().add(element.clone());
953 }
954 }
955 if (other.hasRepeatedForeignMessage()) {
956 for(ForeignMessage element: other.getRepeatedForeignMessageList() ) {
957 getRepeatedForeignMessageList().add(element.clone());
958 }
959 }
960 if (other.hasRepeatedImportMessage()) {
961 for(com.google.protobuf.test.UnittestImport.ImportMessage element: other.getRepeatedImportMessageList() ) {
962 getRepeatedImportMessageList().add(element.clone());
963 }
964 }
965 if (other.hasRepeatedNestedEnum()) {
966 getRepeatedNestedEnumList().addAll(other.getRepeatedNestedEnumList());
967 }
968 if (other.hasRepeatedForeignEnum()) {
969 getRepeatedForeignEnumList().addAll(other.getRepeatedForeignEnumList());
970 }
971 if (other.hasRepeatedImportEnum()) {
972 getRepeatedImportEnumList().addAll(other.getRepeatedImportEnumList());
973 }
974 if (other.hasRepeatedStringPiece()) {
975 getRepeatedStringPieceList().addAll(other.getRepeatedStringPieceList());
976 }
977 if (other.hasRepeatedCord()) {
978 getRepeatedCordList().addAll(other.getRepeatedCordList());
979 }
980 if (other.hasDefaultInt32()) {
981 setDefaultInt32(other.getDefaultInt32());
982 }
983 if (other.hasDefaultInt64()) {
984 setDefaultInt64(other.getDefaultInt64());
985 }
986 if (other.hasDefaultUint32()) {
987 setDefaultUint32(other.getDefaultUint32());
988 }
989 if (other.hasDefaultUint64()) {
990 setDefaultUint64(other.getDefaultUint64());
991 }
992 if (other.hasDefaultSint32()) {
993 setDefaultSint32(other.getDefaultSint32());
994 }
995 if (other.hasDefaultSint64()) {
996 setDefaultSint64(other.getDefaultSint64());
997 }
998 if (other.hasDefaultFixed32()) {
999 setDefaultFixed32(other.getDefaultFixed32());
1000 }
1001 if (other.hasDefaultFixed64()) {
1002 setDefaultFixed64(other.getDefaultFixed64());
1003 }
1004 if (other.hasDefaultSfixed32()) {
1005 setDefaultSfixed32(other.getDefaultSfixed32());
1006 }
1007 if (other.hasDefaultSfixed64()) {
1008 setDefaultSfixed64(other.getDefaultSfixed64());
1009 }
1010 if (other.hasDefaultFloat()) {
1011 setDefaultFloat(other.getDefaultFloat());
1012 }
1013 if (other.hasDefaultDouble()) {
1014 setDefaultDouble(other.getDefaultDouble());
1015 }
1016 if (other.hasDefaultBool()) {
1017 setDefaultBool(other.getDefaultBool());
1018 }
1019 if (other.hasDefaultString()) {
1020 setDefaultString(other.getDefaultString());
1021 }
1022 if (other.hasDefaultBytes()) {
1023 setDefaultBytes(other.getDefaultBytes());
1024 }
1025 if (other.hasDefaultNestedEnum()) {
1026 setDefaultNestedEnum(other.getDefaultNestedEnum());
1027 }
1028 if (other.hasDefaultForeignEnum()) {
1029 setDefaultForeignEnum(other.getDefaultForeignEnum());
1030 }
1031 if (other.hasDefaultImportEnum()) {
1032 setDefaultImportEnum(other.getDefaultImportEnum());
1033 }
1034 if (other.hasDefaultStringPiece()) {
1035 setDefaultStringPiece(other.getDefaultStringPiece());
1036 }
1037 if (other.hasDefaultCord()) {
1038 setDefaultCord(other.getDefaultCord());
1039 }
1040 return this;
1041 }
1042
1043 public int serializedSizeUnframed() {
1044 if (memoizedSerializedSize != -1)
1045 return memoizedSerializedSize;
1046
1047 int size = 0;
1048 if (hasOptionalInt32()) {
1049 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getOptionalInt32());
1050 }
1051 if (hasOptionalInt64()) {
1052 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt64Size(2, getOptionalInt64());
1053 }
1054 if (hasOptionalUint32()) {
1055 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt32Size(3, getOptionalUint32());
1056 }
1057 if (hasOptionalUint64()) {
1058 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt64Size(4, getOptionalUint64());
1059 }
1060 if (hasOptionalSint32()) {
1061 size += org.apache.activemq.protobuf.CodedOutputStream.computeSInt32Size(5, getOptionalSint32());
1062 }
1063 if (hasOptionalSint64()) {
1064 size += org.apache.activemq.protobuf.CodedOutputStream.computeSInt64Size(6, getOptionalSint64());
1065 }
1066 if (hasOptionalFixed32()) {
1067 size += org.apache.activemq.protobuf.CodedOutputStream.computeFixed32Size(7, getOptionalFixed32());
1068 }
1069 if (hasOptionalFixed64()) {
1070 size += org.apache.activemq.protobuf.CodedOutputStream.computeFixed64Size(8, getOptionalFixed64());
1071 }
1072 if (hasOptionalSfixed32()) {
1073 size += org.apache.activemq.protobuf.CodedOutputStream.computeSFixed32Size(9, getOptionalSfixed32());
1074 }
1075 if (hasOptionalSfixed64()) {
1076 size += org.apache.activemq.protobuf.CodedOutputStream.computeSFixed64Size(10, getOptionalSfixed64());
1077 }
1078 if (hasOptionalFloat()) {
1079 size += org.apache.activemq.protobuf.CodedOutputStream.computeFloatSize(11, getOptionalFloat());
1080 }
1081 if (hasOptionalDouble()) {
1082 size += org.apache.activemq.protobuf.CodedOutputStream.computeDoubleSize(12, getOptionalDouble());
1083 }
1084 if (hasOptionalBool()) {
1085 size += org.apache.activemq.protobuf.CodedOutputStream.computeBoolSize(13, getOptionalBool());
1086 }
1087 if (hasOptionalString()) {
1088 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(14, getOptionalString());
1089 }
1090 if (hasOptionalBytes()) {
1091 size += org.apache.activemq.protobuf.CodedOutputStream.computeBytesSize(15, getOptionalBytes());
1092 }
1093 if (hasOptionalGroup()) {
1094 size += computeGroupSize(16, getOptionalGroup());
1095 }
1096 if (hasOptionalNestedMessage()) {
1097 size += computeMessageSize(18, getOptionalNestedMessage());
1098 }
1099 if (hasOptionalForeignMessage()) {
1100 size += computeMessageSize(19, getOptionalForeignMessage());
1101 }
1102 if (hasOptionalImportMessage()) {
1103 size += computeMessageSize(20, getOptionalImportMessage());
1104 }
1105 if (hasOptionalNestedEnum()) {
1106 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(21, getOptionalNestedEnum().getNumber());
1107 }
1108 if (hasOptionalForeignEnum()) {
1109 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(22, getOptionalForeignEnum().getNumber());
1110 }
1111 if (hasOptionalImportEnum()) {
1112 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(23, getOptionalImportEnum().getNumber());
1113 }
1114 if (hasOptionalStringPiece()) {
1115 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(24, getOptionalStringPiece());
1116 }
1117 if (hasOptionalCord()) {
1118 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(25, getOptionalCord());
1119 }
1120 if (hasRepeatedInt32()) {
1121 for (int i : getRepeatedInt32List()) {
1122 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(31, i);
1123 }
1124 }
1125 if (hasRepeatedInt64()) {
1126 for (long i : getRepeatedInt64List()) {
1127 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt64Size(32, i);
1128 }
1129 }
1130 if (hasRepeatedUint32()) {
1131 for (int i : getRepeatedUint32List()) {
1132 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt32Size(33, i);
1133 }
1134 }
1135 if (hasRepeatedUint64()) {
1136 for (long i : getRepeatedUint64List()) {
1137 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt64Size(34, i);
1138 }
1139 }
1140 if (hasRepeatedSint32()) {
1141 for (int i : getRepeatedSint32List()) {
1142 size += org.apache.activemq.protobuf.CodedOutputStream.computeSInt32Size(35, i);
1143 }
1144 }
1145 if (hasRepeatedSint64()) {
1146 for (long i : getRepeatedSint64List()) {
1147 size += org.apache.activemq.protobuf.CodedOutputStream.computeSInt64Size(36, i);
1148 }
1149 }
1150 if (hasRepeatedFixed32()) {
1151 for (int i : getRepeatedFixed32List()) {
1152 size += org.apache.activemq.protobuf.CodedOutputStream.computeFixed32Size(37, i);
1153 }
1154 }
1155 if (hasRepeatedFixed64()) {
1156 for (long i : getRepeatedFixed64List()) {
1157 size += org.apache.activemq.protobuf.CodedOutputStream.computeFixed64Size(38, i);
1158 }
1159 }
1160 if (hasRepeatedSfixed32()) {
1161 for (int i : getRepeatedSfixed32List()) {
1162 size += org.apache.activemq.protobuf.CodedOutputStream.computeSFixed32Size(39, i);
1163 }
1164 }
1165 if (hasRepeatedSfixed64()) {
1166 for (long i : getRepeatedSfixed64List()) {
1167 size += org.apache.activemq.protobuf.CodedOutputStream.computeSFixed64Size(40, i);
1168 }
1169 }
1170 if (hasRepeatedFloat()) {
1171 for (float i : getRepeatedFloatList()) {
1172 size += org.apache.activemq.protobuf.CodedOutputStream.computeFloatSize(41, i);
1173 }
1174 }
1175 if (hasRepeatedDouble()) {
1176 for (double i : getRepeatedDoubleList()) {
1177 size += org.apache.activemq.protobuf.CodedOutputStream.computeDoubleSize(42, i);
1178 }
1179 }
1180 if (hasRepeatedBool()) {
1181 for (boolean i : getRepeatedBoolList()) {
1182 size += org.apache.activemq.protobuf.CodedOutputStream.computeBoolSize(43, i);
1183 }
1184 }
1185 if (hasRepeatedString()) {
1186 for (java.lang.String i : getRepeatedStringList()) {
1187 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(44, i);
1188 }
1189 }
1190 if (hasRepeatedBytes()) {
1191 for (org.apache.activemq.protobuf.Buffer i : getRepeatedBytesList()) {
1192 size += org.apache.activemq.protobuf.CodedOutputStream.computeBytesSize(45, i);
1193 }
1194 }
1195 if (hasRepeatedGroup()) {
1196 for (TestAllTypes.RepeatedGroup i : getRepeatedGroupList()) {
1197 size += computeGroupSize(46, i);
1198 }
1199 }
1200 if (hasRepeatedNestedMessage()) {
1201 for (TestAllTypes.NestedMessage i : getRepeatedNestedMessageList()) {
1202 size += computeMessageSize(48, i);
1203 }
1204 }
1205 if (hasRepeatedForeignMessage()) {
1206 for (ForeignMessage i : getRepeatedForeignMessageList()) {
1207 size += computeMessageSize(49, i);
1208 }
1209 }
1210 if (hasRepeatedImportMessage()) {
1211 for (com.google.protobuf.test.UnittestImport.ImportMessage i : getRepeatedImportMessageList()) {
1212 size += computeMessageSize(50, i);
1213 }
1214 }
1215 if (hasRepeatedNestedEnum()) {
1216 for (TestAllTypes.NestedEnum i : getRepeatedNestedEnumList()) {
1217 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(51, i.getNumber());
1218 }
1219 }
1220 if (hasRepeatedForeignEnum()) {
1221 for (ForeignEnum i : getRepeatedForeignEnumList()) {
1222 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(52, i.getNumber());
1223 }
1224 }
1225 if (hasRepeatedImportEnum()) {
1226 for (com.google.protobuf.test.UnittestImport.ImportEnum i : getRepeatedImportEnumList()) {
1227 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(53, i.getNumber());
1228 }
1229 }
1230 if (hasRepeatedStringPiece()) {
1231 for (java.lang.String i : getRepeatedStringPieceList()) {
1232 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(54, i);
1233 }
1234 }
1235 if (hasRepeatedCord()) {
1236 for (java.lang.String i : getRepeatedCordList()) {
1237 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(55, i);
1238 }
1239 }
1240 if (hasDefaultInt32()) {
1241 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(61, getDefaultInt32());
1242 }
1243 if (hasDefaultInt64()) {
1244 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt64Size(62, getDefaultInt64());
1245 }
1246 if (hasDefaultUint32()) {
1247 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt32Size(63, getDefaultUint32());
1248 }
1249 if (hasDefaultUint64()) {
1250 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt64Size(64, getDefaultUint64());
1251 }
1252 if (hasDefaultSint32()) {
1253 size += org.apache.activemq.protobuf.CodedOutputStream.computeSInt32Size(65, getDefaultSint32());
1254 }
1255 if (hasDefaultSint64()) {
1256 size += org.apache.activemq.protobuf.CodedOutputStream.computeSInt64Size(66, getDefaultSint64());
1257 }
1258 if (hasDefaultFixed32()) {
1259 size += org.apache.activemq.protobuf.CodedOutputStream.computeFixed32Size(67, getDefaultFixed32());
1260 }
1261 if (hasDefaultFixed64()) {
1262 size += org.apache.activemq.protobuf.CodedOutputStream.computeFixed64Size(68, getDefaultFixed64());
1263 }
1264 if (hasDefaultSfixed32()) {
1265 size += org.apache.activemq.protobuf.CodedOutputStream.computeSFixed32Size(69, getDefaultSfixed32());
1266 }
1267 if (hasDefaultSfixed64()) {
1268 size += org.apache.activemq.protobuf.CodedOutputStream.computeSFixed64Size(70, getDefaultSfixed64());
1269 }
1270 if (hasDefaultFloat()) {
1271 size += org.apache.activemq.protobuf.CodedOutputStream.computeFloatSize(71, getDefaultFloat());
1272 }
1273 if (hasDefaultDouble()) {
1274 size += org.apache.activemq.protobuf.CodedOutputStream.computeDoubleSize(72, getDefaultDouble());
1275 }
1276 if (hasDefaultBool()) {
1277 size += org.apache.activemq.protobuf.CodedOutputStream.computeBoolSize(73, getDefaultBool());
1278 }
1279 if (hasDefaultString()) {
1280 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(74, getDefaultString());
1281 }
1282 if (hasDefaultBytes()) {
1283 size += org.apache.activemq.protobuf.CodedOutputStream.computeBytesSize(75, getDefaultBytes());
1284 }
1285 if (hasDefaultNestedEnum()) {
1286 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(81, getDefaultNestedEnum().getNumber());
1287 }
1288 if (hasDefaultForeignEnum()) {
1289 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(82, getDefaultForeignEnum().getNumber());
1290 }
1291 if (hasDefaultImportEnum()) {
1292 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(83, getDefaultImportEnum().getNumber());
1293 }
1294 if (hasDefaultStringPiece()) {
1295 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(84, getDefaultStringPiece());
1296 }
1297 if (hasDefaultCord()) {
1298 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(85, getDefaultCord());
1299 }
1300 memoizedSerializedSize = size;
1301 return size;
1302 }
1303
1304 public TestAllTypes mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
1305 while (true) {
1306 int tag = input.readTag();
1307 if ((tag & 0x07) == 4) {
1308 return this;
1309 }
1310 switch (tag) {
1311 case 0:
1312 return this;
1313 default: {
1314 break;
1315 }
1316 case 8:
1317 setOptionalInt32(input.readInt32());
1318 break;
1319 case 16:
1320 setOptionalInt64(input.readInt64());
1321 break;
1322 case 24:
1323 setOptionalUint32(input.readUInt32());
1324 break;
1325 case 32:
1326 setOptionalUint64(input.readUInt64());
1327 break;
1328 case 40:
1329 setOptionalSint32(input.readSInt32());
1330 break;
1331 case 48:
1332 setOptionalSint64(input.readSInt64());
1333 break;
1334 case 61:
1335 setOptionalFixed32(input.readFixed32());
1336 break;
1337 case 65:
1338 setOptionalFixed64(input.readFixed64());
1339 break;
1340 case 77:
1341 setOptionalSfixed32(input.readSFixed32());
1342 break;
1343 case 81:
1344 setOptionalSfixed64(input.readSFixed64());
1345 break;
1346 case 93:
1347 setOptionalFloat(input.readFloat());
1348 break;
1349 case 97:
1350 setOptionalDouble(input.readDouble());
1351 break;
1352 case 104:
1353 setOptionalBool(input.readBool());
1354 break;
1355 case 114:
1356 setOptionalString(input.readString());
1357 break;
1358 case 122:
1359 setOptionalBytes(input.readBytes());
1360 break;
1361 case 131:
1362 if (hasOptionalGroup()) {
1363 readGroup(input, 16, getOptionalGroup());
1364 } else {
1365 setOptionalGroup(readGroup(input, 16,new TestAllTypes.OptionalGroup()));
1366 }
1367
1368 break;
1369 case 146:
1370 if (hasOptionalNestedMessage()) {
1371 getOptionalNestedMessage().mergeFramed(input);
1372 } else {
1373 setOptionalNestedMessage(new TestAllTypes.NestedMessage().mergeFramed(input));
1374 }
1375 break;
1376 case 154:
1377 if (hasOptionalForeignMessage()) {
1378 getOptionalForeignMessage().mergeFramed(input);
1379 } else {
1380 setOptionalForeignMessage(new ForeignMessage().mergeFramed(input));
1381 }
1382 break;
1383 case 162:
1384 if (hasOptionalImportMessage()) {
1385 getOptionalImportMessage().mergeFramed(input);
1386 } else {
1387 setOptionalImportMessage(new com.google.protobuf.test.UnittestImport.ImportMessage().mergeFramed(input));
1388 }
1389 break;
1390 case 168:
1391 {
1392 int t = input.readEnum();
1393 TestAllTypes.NestedEnum value = TestAllTypes.NestedEnum.valueOf(t);
1394 if( value !=null ) {
1395 setOptionalNestedEnum(value);
1396 }
1397 }
1398 break;
1399 case 176:
1400 {
1401 int t = input.readEnum();
1402 ForeignEnum value = ForeignEnum.valueOf(t);
1403 if( value !=null ) {
1404 setOptionalForeignEnum(value);
1405 }
1406 }
1407 break;
1408 case 184:
1409 {
1410 int t = input.readEnum();
1411 com.google.protobuf.test.UnittestImport.ImportEnum value = com.google.protobuf.test.UnittestImport.ImportEnum.valueOf(t);
1412 if( value !=null ) {
1413 setOptionalImportEnum(value);
1414 }
1415 }
1416 break;
1417 case 194:
1418 setOptionalStringPiece(input.readString());
1419 break;
1420 case 202:
1421 setOptionalCord(input.readString());
1422 break;
1423 case 248:
1424 getRepeatedInt32List().add(input.readInt32());
1425 break;
1426 case 256:
1427 getRepeatedInt64List().add(input.readInt64());
1428 break;
1429 case 264:
1430 getRepeatedUint32List().add(input.readUInt32());
1431 break;
1432 case 272:
1433 getRepeatedUint64List().add(input.readUInt64());
1434 break;
1435 case 280:
1436 getRepeatedSint32List().add(input.readSInt32());
1437 break;
1438 case 288:
1439 getRepeatedSint64List().add(input.readSInt64());
1440 break;
1441 case 301:
1442 getRepeatedFixed32List().add(input.readFixed32());
1443 break;
1444 case 305:
1445 getRepeatedFixed64List().add(input.readFixed64());
1446 break;
1447 case 317:
1448 getRepeatedSfixed32List().add(input.readSFixed32());
1449 break;
1450 case 321:
1451 getRepeatedSfixed64List().add(input.readSFixed64());
1452 break;
1453 case 333:
1454 getRepeatedFloatList().add(input.readFloat());
1455 break;
1456 case 337:
1457 getRepeatedDoubleList().add(input.readDouble());
1458 break;
1459 case 344:
1460 getRepeatedBoolList().add(input.readBool());
1461 break;
1462 case 354:
1463 getRepeatedStringList().add(input.readString());
1464 break;
1465 case 362:
1466 getRepeatedBytesList().add(input.readBytes());
1467 break;
1468 case 371:
1469 getRepeatedGroupList().add(readGroup(input, 46, new TestAllTypes.RepeatedGroup()));
1470
1471 break;
1472 case 386:
1473 getRepeatedNestedMessageList().add(new TestAllTypes.NestedMessage().mergeFramed(input));
1474 break;
1475 case 394:
1476 getRepeatedForeignMessageList().add(new ForeignMessage().mergeFramed(input));
1477 break;
1478 case 402:
1479 getRepeatedImportMessageList().add(new com.google.protobuf.test.UnittestImport.ImportMessage().mergeFramed(input));
1480 break;
1481 case 408:
1482 {
1483 int t = input.readEnum();
1484 TestAllTypes.NestedEnum value = TestAllTypes.NestedEnum.valueOf(t);
1485 if( value !=null ) {
1486 getRepeatedNestedEnumList().add(value);
1487 }
1488 }
1489 break;
1490 case 416:
1491 {
1492 int t = input.readEnum();
1493 ForeignEnum value = ForeignEnum.valueOf(t);
1494 if( value !=null ) {
1495 getRepeatedForeignEnumList().add(value);
1496 }
1497 }
1498 break;
1499 case 424:
1500 {
1501 int t = input.readEnum();
1502 com.google.protobuf.test.UnittestImport.ImportEnum value = com.google.protobuf.test.UnittestImport.ImportEnum.valueOf(t);
1503 if( value !=null ) {
1504 getRepeatedImportEnumList().add(value);
1505 }
1506 }
1507 break;
1508 case 434:
1509 getRepeatedStringPieceList().add(input.readString());
1510 break;
1511 case 442:
1512 getRepeatedCordList().add(input.readString());
1513 break;
1514 case 488:
1515 setDefaultInt32(input.readInt32());
1516 break;
1517 case 496:
1518 setDefaultInt64(input.readInt64());
1519 break;
1520 case 504:
1521 setDefaultUint32(input.readUInt32());
1522 break;
1523 case 512:
1524 setDefaultUint64(input.readUInt64());
1525 break;
1526 case 520:
1527 setDefaultSint32(input.readSInt32());
1528 break;
1529 case 528:
1530 setDefaultSint64(input.readSInt64());
1531 break;
1532 case 541:
1533 setDefaultFixed32(input.readFixed32());
1534 break;
1535 case 545:
1536 setDefaultFixed64(input.readFixed64());
1537 break;
1538 case 557:
1539 setDefaultSfixed32(input.readSFixed32());
1540 break;
1541 case 561:
1542 setDefaultSfixed64(input.readSFixed64());
1543 break;
1544 case 573:
1545 setDefaultFloat(input.readFloat());
1546 break;
1547 case 577:
1548 setDefaultDouble(input.readDouble());
1549 break;
1550 case 584:
1551 setDefaultBool(input.readBool());
1552 break;
1553 case 594:
1554 setDefaultString(input.readString());
1555 break;
1556 case 602:
1557 setDefaultBytes(input.readBytes());
1558 break;
1559 case 648:
1560 {
1561 int t = input.readEnum();
1562 TestAllTypes.NestedEnum value = TestAllTypes.NestedEnum.valueOf(t);
1563 if( value !=null ) {
1564 setDefaultNestedEnum(value);
1565 }
1566 }
1567 break;
1568 case 656:
1569 {
1570 int t = input.readEnum();
1571 ForeignEnum value = ForeignEnum.valueOf(t);
1572 if( value !=null ) {
1573 setDefaultForeignEnum(value);
1574 }
1575 }
1576 break;
1577 case 664:
1578 {
1579 int t = input.readEnum();
1580 com.google.protobuf.test.UnittestImport.ImportEnum value = com.google.protobuf.test.UnittestImport.ImportEnum.valueOf(t);
1581 if( value !=null ) {
1582 setDefaultImportEnum(value);
1583 }
1584 }
1585 break;
1586 case 674:
1587 setDefaultStringPiece(input.readString());
1588 break;
1589 case 682:
1590 setDefaultCord(input.readString());
1591 break;
1592 }
1593 }
1594 }
1595 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
1596 if (hasOptionalInt32()) {
1597 output.writeInt32(1, getOptionalInt32());
1598 }
1599 if (hasOptionalInt64()) {
1600 output.writeInt64(2, getOptionalInt64());
1601 }
1602 if (hasOptionalUint32()) {
1603 output.writeUInt32(3, getOptionalUint32());
1604 }
1605 if (hasOptionalUint64()) {
1606 output.writeUInt64(4, getOptionalUint64());
1607 }
1608 if (hasOptionalSint32()) {
1609 output.writeSInt32(5, getOptionalSint32());
1610 }
1611 if (hasOptionalSint64()) {
1612 output.writeSInt64(6, getOptionalSint64());
1613 }
1614 if (hasOptionalFixed32()) {
1615 output.writeFixed32(7, getOptionalFixed32());
1616 }
1617 if (hasOptionalFixed64()) {
1618 output.writeFixed64(8, getOptionalFixed64());
1619 }
1620 if (hasOptionalSfixed32()) {
1621 output.writeSFixed32(9, getOptionalSfixed32());
1622 }
1623 if (hasOptionalSfixed64()) {
1624 output.writeSFixed64(10, getOptionalSfixed64());
1625 }
1626 if (hasOptionalFloat()) {
1627 output.writeFloat(11, getOptionalFloat());
1628 }
1629 if (hasOptionalDouble()) {
1630 output.writeDouble(12, getOptionalDouble());
1631 }
1632 if (hasOptionalBool()) {
1633 output.writeBool(13, getOptionalBool());
1634 }
1635 if (hasOptionalString()) {
1636 output.writeString(14, getOptionalString());
1637 }
1638 if (hasOptionalBytes()) {
1639 output.writeBytes(15, getOptionalBytes());
1640 }
1641 if (hasOptionalGroup()) {
1642 writeGroup(output, 16, getOptionalGroup());
1643 }
1644 if (hasOptionalNestedMessage()) {
1645 writeMessage(output, 18, getOptionalNestedMessage());
1646 }
1647 if (hasOptionalForeignMessage()) {
1648 writeMessage(output, 19, getOptionalForeignMessage());
1649 }
1650 if (hasOptionalImportMessage()) {
1651 writeMessage(output, 20, getOptionalImportMessage());
1652 }
1653 if (hasOptionalNestedEnum()) {
1654 output.writeEnum(21, getOptionalNestedEnum().getNumber());
1655 }
1656 if (hasOptionalForeignEnum()) {
1657 output.writeEnum(22, getOptionalForeignEnum().getNumber());
1658 }
1659 if (hasOptionalImportEnum()) {
1660 output.writeEnum(23, getOptionalImportEnum().getNumber());
1661 }
1662 if (hasOptionalStringPiece()) {
1663 output.writeString(24, getOptionalStringPiece());
1664 }
1665 if (hasOptionalCord()) {
1666 output.writeString(25, getOptionalCord());
1667 }
1668 if (hasRepeatedInt32()) {
1669 for (int i : getRepeatedInt32List()) {
1670 output.writeInt32(31, i);
1671 }
1672 }
1673 if (hasRepeatedInt64()) {
1674 for (long i : getRepeatedInt64List()) {
1675 output.writeInt64(32, i);
1676 }
1677 }
1678 if (hasRepeatedUint32()) {
1679 for (int i : getRepeatedUint32List()) {
1680 output.writeUInt32(33, i);
1681 }
1682 }
1683 if (hasRepeatedUint64()) {
1684 for (long i : getRepeatedUint64List()) {
1685 output.writeUInt64(34, i);
1686 }
1687 }
1688 if (hasRepeatedSint32()) {
1689 for (int i : getRepeatedSint32List()) {
1690 output.writeSInt32(35, i);
1691 }
1692 }
1693 if (hasRepeatedSint64()) {
1694 for (long i : getRepeatedSint64List()) {
1695 output.writeSInt64(36, i);
1696 }
1697 }
1698 if (hasRepeatedFixed32()) {
1699 for (int i : getRepeatedFixed32List()) {
1700 output.writeFixed32(37, i);
1701 }
1702 }
1703 if (hasRepeatedFixed64()) {
1704 for (long i : getRepeatedFixed64List()) {
1705 output.writeFixed64(38, i);
1706 }
1707 }
1708 if (hasRepeatedSfixed32()) {
1709 for (int i : getRepeatedSfixed32List()) {
1710 output.writeSFixed32(39, i);
1711 }
1712 }
1713 if (hasRepeatedSfixed64()) {
1714 for (long i : getRepeatedSfixed64List()) {
1715 output.writeSFixed64(40, i);
1716 }
1717 }
1718 if (hasRepeatedFloat()) {
1719 for (float i : getRepeatedFloatList()) {
1720 output.writeFloat(41, i);
1721 }
1722 }
1723 if (hasRepeatedDouble()) {
1724 for (double i : getRepeatedDoubleList()) {
1725 output.writeDouble(42, i);
1726 }
1727 }
1728 if (hasRepeatedBool()) {
1729 for (boolean i : getRepeatedBoolList()) {
1730 output.writeBool(43, i);
1731 }
1732 }
1733 if (hasRepeatedString()) {
1734 for (java.lang.String i : getRepeatedStringList()) {
1735 output.writeString(44, i);
1736 }
1737 }
1738 if (hasRepeatedBytes()) {
1739 for (org.apache.activemq.protobuf.Buffer i : getRepeatedBytesList()) {
1740 output.writeBytes(45, i);
1741 }
1742 }
1743 if (hasRepeatedGroup()) {
1744 for (TestAllTypes.RepeatedGroup i : getRepeatedGroupList()) {
1745 writeGroup(output, 46, i);
1746 }
1747 }
1748 if (hasRepeatedNestedMessage()) {
1749 for (TestAllTypes.NestedMessage i : getRepeatedNestedMessageList()) {
1750 writeMessage(output, 48, i);
1751 }
1752 }
1753 if (hasRepeatedForeignMessage()) {
1754 for (ForeignMessage i : getRepeatedForeignMessageList()) {
1755 writeMessage(output, 49, i);
1756 }
1757 }
1758 if (hasRepeatedImportMessage()) {
1759 for (com.google.protobuf.test.UnittestImport.ImportMessage i : getRepeatedImportMessageList()) {
1760 writeMessage(output, 50, i);
1761 }
1762 }
1763 if (hasRepeatedNestedEnum()) {
1764 for (TestAllTypes.NestedEnum i : getRepeatedNestedEnumList()) {
1765 output.writeEnum(51, i.getNumber());
1766 }
1767 }
1768 if (hasRepeatedForeignEnum()) {
1769 for (ForeignEnum i : getRepeatedForeignEnumList()) {
1770 output.writeEnum(52, i.getNumber());
1771 }
1772 }
1773 if (hasRepeatedImportEnum()) {
1774 for (com.google.protobuf.test.UnittestImport.ImportEnum i : getRepeatedImportEnumList()) {
1775 output.writeEnum(53, i.getNumber());
1776 }
1777 }
1778 if (hasRepeatedStringPiece()) {
1779 for (java.lang.String i : getRepeatedStringPieceList()) {
1780 output.writeString(54, i);
1781 }
1782 }
1783 if (hasRepeatedCord()) {
1784 for (java.lang.String i : getRepeatedCordList()) {
1785 output.writeString(55, i);
1786 }
1787 }
1788 if (hasDefaultInt32()) {
1789 output.writeInt32(61, getDefaultInt32());
1790 }
1791 if (hasDefaultInt64()) {
1792 output.writeInt64(62, getDefaultInt64());
1793 }
1794 if (hasDefaultUint32()) {
1795 output.writeUInt32(63, getDefaultUint32());
1796 }
1797 if (hasDefaultUint64()) {
1798 output.writeUInt64(64, getDefaultUint64());
1799 }
1800 if (hasDefaultSint32()) {
1801 output.writeSInt32(65, getDefaultSint32());
1802 }
1803 if (hasDefaultSint64()) {
1804 output.writeSInt64(66, getDefaultSint64());
1805 }
1806 if (hasDefaultFixed32()) {
1807 output.writeFixed32(67, getDefaultFixed32());
1808 }
1809 if (hasDefaultFixed64()) {
1810 output.writeFixed64(68, getDefaultFixed64());
1811 }
1812 if (hasDefaultSfixed32()) {
1813 output.writeSFixed32(69, getDefaultSfixed32());
1814 }
1815 if (hasDefaultSfixed64()) {
1816 output.writeSFixed64(70, getDefaultSfixed64());
1817 }
1818 if (hasDefaultFloat()) {
1819 output.writeFloat(71, getDefaultFloat());
1820 }
1821 if (hasDefaultDouble()) {
1822 output.writeDouble(72, getDefaultDouble());
1823 }
1824 if (hasDefaultBool()) {
1825 output.writeBool(73, getDefaultBool());
1826 }
1827 if (hasDefaultString()) {
1828 output.writeString(74, getDefaultString());
1829 }
1830 if (hasDefaultBytes()) {
1831 output.writeBytes(75, getDefaultBytes());
1832 }
1833 if (hasDefaultNestedEnum()) {
1834 output.writeEnum(81, getDefaultNestedEnum().getNumber());
1835 }
1836 if (hasDefaultForeignEnum()) {
1837 output.writeEnum(82, getDefaultForeignEnum().getNumber());
1838 }
1839 if (hasDefaultImportEnum()) {
1840 output.writeEnum(83, getDefaultImportEnum().getNumber());
1841 }
1842 if (hasDefaultStringPiece()) {
1843 output.writeString(84, getDefaultStringPiece());
1844 }
1845 if (hasDefaultCord()) {
1846 output.writeString(85, getDefaultCord());
1847 }
1848 }
1849
1850 public static TestAllTypes parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
1851 return new TestAllTypes().mergeUnframed(data).checktInitialized();
1852 }
1853
1854 public static TestAllTypes parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
1855 return new TestAllTypes().mergeUnframed(data).checktInitialized();
1856 }
1857
1858 public static TestAllTypes parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
1859 return new TestAllTypes().mergeUnframed(data).checktInitialized();
1860 }
1861
1862 public static TestAllTypes parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
1863 return new TestAllTypes().mergeUnframed(data).checktInitialized();
1864 }
1865
1866 public static TestAllTypes parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
1867 return new TestAllTypes().mergeFramed(data).checktInitialized();
1868 }
1869
1870 public static TestAllTypes parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
1871 return new TestAllTypes().mergeFramed(data).checktInitialized();
1872 }
1873
1874 public static TestAllTypes parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
1875 return new TestAllTypes().mergeFramed(data).checktInitialized();
1876 }
1877
1878 public static TestAllTypes parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
1879 return new TestAllTypes().mergeFramed(data).checktInitialized();
1880 }
1881
1882 public String toString() {
1883 return toString(new java.lang.StringBuilder(), "").toString();
1884 }
1885
1886 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
1887 if( hasOptionalInt32() ) {
1888 sb.append(prefix+"optional_int32: ");
1889 sb.append(getOptionalInt32());
1890 sb.append("\n");
1891 }
1892 if( hasOptionalInt64() ) {
1893 sb.append(prefix+"optional_int64: ");
1894 sb.append(getOptionalInt64());
1895 sb.append("\n");
1896 }
1897 if( hasOptionalUint32() ) {
1898 sb.append(prefix+"optional_uint32: ");
1899 sb.append(getOptionalUint32());
1900 sb.append("\n");
1901 }
1902 if( hasOptionalUint64() ) {
1903 sb.append(prefix+"optional_uint64: ");
1904 sb.append(getOptionalUint64());
1905 sb.append("\n");
1906 }
1907 if( hasOptionalSint32() ) {
1908 sb.append(prefix+"optional_sint32: ");
1909 sb.append(getOptionalSint32());
1910 sb.append("\n");
1911 }
1912 if( hasOptionalSint64() ) {
1913 sb.append(prefix+"optional_sint64: ");
1914 sb.append(getOptionalSint64());
1915 sb.append("\n");
1916 }
1917 if( hasOptionalFixed32() ) {
1918 sb.append(prefix+"optional_fixed32: ");
1919 sb.append(getOptionalFixed32());
1920 sb.append("\n");
1921 }
1922 if( hasOptionalFixed64() ) {
1923 sb.append(prefix+"optional_fixed64: ");
1924 sb.append(getOptionalFixed64());
1925 sb.append("\n");
1926 }
1927 if( hasOptionalSfixed32() ) {
1928 sb.append(prefix+"optional_sfixed32: ");
1929 sb.append(getOptionalSfixed32());
1930 sb.append("\n");
1931 }
1932 if( hasOptionalSfixed64() ) {
1933 sb.append(prefix+"optional_sfixed64: ");
1934 sb.append(getOptionalSfixed64());
1935 sb.append("\n");
1936 }
1937 if( hasOptionalFloat() ) {
1938 sb.append(prefix+"optional_float: ");
1939 sb.append(getOptionalFloat());
1940 sb.append("\n");
1941 }
1942 if( hasOptionalDouble() ) {
1943 sb.append(prefix+"optional_double: ");
1944 sb.append(getOptionalDouble());
1945 sb.append("\n");
1946 }
1947 if( hasOptionalBool() ) {
1948 sb.append(prefix+"optional_bool: ");
1949 sb.append(getOptionalBool());
1950 sb.append("\n");
1951 }
1952 if( hasOptionalString() ) {
1953 sb.append(prefix+"optional_string: ");
1954 sb.append(getOptionalString());
1955 sb.append("\n");
1956 }
1957 if( hasOptionalBytes() ) {
1958 sb.append(prefix+"optional_bytes: ");
1959 sb.append(getOptionalBytes());
1960 sb.append("\n");
1961 }
1962 if( hasOptionalGroup() ) {
1963 sb.append(prefix+"OptionalGroup {\n");
1964 getOptionalGroup().toString(sb, prefix+" ");
1965 sb.append(prefix+"}\n");
1966 }
1967 if( hasOptionalNestedMessage() ) {
1968 sb.append(prefix+"optional_nested_message {\n");
1969 getOptionalNestedMessage().toString(sb, prefix+" ");
1970 sb.append(prefix+"}\n");
1971 }
1972 if( hasOptionalForeignMessage() ) {
1973 sb.append(prefix+"optional_foreign_message {\n");
1974 getOptionalForeignMessage().toString(sb, prefix+" ");
1975 sb.append(prefix+"}\n");
1976 }
1977 if( hasOptionalImportMessage() ) {
1978 sb.append(prefix+"optional_import_message {\n");
1979 getOptionalImportMessage().toString(sb, prefix+" ");
1980 sb.append(prefix+"}\n");
1981 }
1982 if( hasOptionalNestedEnum() ) {
1983 sb.append(prefix+"optional_nested_enum: ");
1984 sb.append(getOptionalNestedEnum());
1985 sb.append("\n");
1986 }
1987 if( hasOptionalForeignEnum() ) {
1988 sb.append(prefix+"optional_foreign_enum: ");
1989 sb.append(getOptionalForeignEnum());
1990 sb.append("\n");
1991 }
1992 if( hasOptionalImportEnum() ) {
1993 sb.append(prefix+"optional_import_enum: ");
1994 sb.append(getOptionalImportEnum());
1995 sb.append("\n");
1996 }
1997 if( hasOptionalStringPiece() ) {
1998 sb.append(prefix+"optional_string_piece: ");
1999 sb.append(getOptionalStringPiece());
2000 sb.append("\n");
2001 }
2002 if( hasOptionalCord() ) {
2003 sb.append(prefix+"optional_cord: ");
2004 sb.append(getOptionalCord());
2005 sb.append("\n");
2006 }
2007 if( hasRepeatedInt32() ) {
2008 java.util.List<java.lang.Integer> l = getRepeatedInt32List();
2009 for( int i=0; i < l.size(); i++ ) {
2010 sb.append(prefix+"repeated_int32["+i+"]: ");
2011 sb.append(l.get(i));
2012 sb.append("\n");
2013 }
2014 }
2015 if( hasRepeatedInt64() ) {
2016 java.util.List<java.lang.Long> l = getRepeatedInt64List();
2017 for( int i=0; i < l.size(); i++ ) {
2018 sb.append(prefix+"repeated_int64["+i+"]: ");
2019 sb.append(l.get(i));
2020 sb.append("\n");
2021 }
2022 }
2023 if( hasRepeatedUint32() ) {
2024 java.util.List<java.lang.Integer> l = getRepeatedUint32List();
2025 for( int i=0; i < l.size(); i++ ) {
2026 sb.append(prefix+"repeated_uint32["+i+"]: ");
2027 sb.append(l.get(i));
2028 sb.append("\n");
2029 }
2030 }
2031 if( hasRepeatedUint64() ) {
2032 java.util.List<java.lang.Long> l = getRepeatedUint64List();
2033 for( int i=0; i < l.size(); i++ ) {
2034 sb.append(prefix+"repeated_uint64["+i+"]: ");
2035 sb.append(l.get(i));
2036 sb.append("\n");
2037 }
2038 }
2039 if( hasRepeatedSint32() ) {
2040 java.util.List<java.lang.Integer> l = getRepeatedSint32List();
2041 for( int i=0; i < l.size(); i++ ) {
2042 sb.append(prefix+"repeated_sint32["+i+"]: ");
2043 sb.append(l.get(i));
2044 sb.append("\n");
2045 }
2046 }
2047 if( hasRepeatedSint64() ) {
2048 java.util.List<java.lang.Long> l = getRepeatedSint64List();
2049 for( int i=0; i < l.size(); i++ ) {
2050 sb.append(prefix+"repeated_sint64["+i+"]: ");
2051 sb.append(l.get(i));
2052 sb.append("\n");
2053 }
2054 }
2055 if( hasRepeatedFixed32() ) {
2056 java.util.List<java.lang.Integer> l = getRepeatedFixed32List();
2057 for( int i=0; i < l.size(); i++ ) {
2058 sb.append(prefix+"repeated_fixed32["+i+"]: ");
2059 sb.append(l.get(i));
2060 sb.append("\n");
2061 }
2062 }
2063 if( hasRepeatedFixed64() ) {
2064 java.util.List<java.lang.Long> l = getRepeatedFixed64List();
2065 for( int i=0; i < l.size(); i++ ) {
2066 sb.append(prefix+"repeated_fixed64["+i+"]: ");
2067 sb.append(l.get(i));
2068 sb.append("\n");
2069 }
2070 }
2071 if( hasRepeatedSfixed32() ) {
2072 java.util.List<java.lang.Integer> l = getRepeatedSfixed32List();
2073 for( int i=0; i < l.size(); i++ ) {
2074 sb.append(prefix+"repeated_sfixed32["+i+"]: ");
2075 sb.append(l.get(i));
2076 sb.append("\n");
2077 }
2078 }
2079 if( hasRepeatedSfixed64() ) {
2080 java.util.List<java.lang.Long> l = getRepeatedSfixed64List();
2081 for( int i=0; i < l.size(); i++ ) {
2082 sb.append(prefix+"repeated_sfixed64["+i+"]: ");
2083 sb.append(l.get(i));
2084 sb.append("\n");
2085 }
2086 }
2087 if( hasRepeatedFloat() ) {
2088 java.util.List<java.lang.Float> l = getRepeatedFloatList();
2089 for( int i=0; i < l.size(); i++ ) {
2090 sb.append(prefix+"repeated_float["+i+"]: ");
2091 sb.append(l.get(i));
2092 sb.append("\n");
2093 }
2094 }
2095 if( hasRepeatedDouble() ) {
2096 java.util.List<java.lang.Double> l = getRepeatedDoubleList();
2097 for( int i=0; i < l.size(); i++ ) {
2098 sb.append(prefix+"repeated_double["+i+"]: ");
2099 sb.append(l.get(i));
2100 sb.append("\n");
2101 }
2102 }
2103 if( hasRepeatedBool() ) {
2104 java.util.List<java.lang.Boolean> l = getRepeatedBoolList();
2105 for( int i=0; i < l.size(); i++ ) {
2106 sb.append(prefix+"repeated_bool["+i+"]: ");
2107 sb.append(l.get(i));
2108 sb.append("\n");
2109 }
2110 }
2111 if( hasRepeatedString() ) {
2112 java.util.List<java.lang.String> l = getRepeatedStringList();
2113 for( int i=0; i < l.size(); i++ ) {
2114 sb.append(prefix+"repeated_string["+i+"]: ");
2115 sb.append(l.get(i));
2116 sb.append("\n");
2117 }
2118 }
2119 if( hasRepeatedBytes() ) {
2120 java.util.List<org.apache.activemq.protobuf.Buffer> l = getRepeatedBytesList();
2121 for( int i=0; i < l.size(); i++ ) {
2122 sb.append(prefix+"repeated_bytes["+i+"]: ");
2123 sb.append(l.get(i));
2124 sb.append("\n");
2125 }
2126 }
2127 if( hasRepeatedGroup() ) {
2128 java.util.List<TestAllTypes.RepeatedGroup> l = getRepeatedGroupList();
2129 for( int i=0; i < l.size(); i++ ) {
2130 sb.append(prefix+"RepeatedGroup["+i+"] {\n");
2131 l.get(i).toString(sb, prefix+" ");
2132 sb.append(prefix+"}\n");
2133 }
2134 }
2135 if( hasRepeatedNestedMessage() ) {
2136 java.util.List<TestAllTypes.NestedMessage> l = getRepeatedNestedMessageList();
2137 for( int i=0; i < l.size(); i++ ) {
2138 sb.append(prefix+"repeated_nested_message["+i+"] {\n");
2139 l.get(i).toString(sb, prefix+" ");
2140 sb.append(prefix+"}\n");
2141 }
2142 }
2143 if( hasRepeatedForeignMessage() ) {
2144 java.util.List<ForeignMessage> l = getRepeatedForeignMessageList();
2145 for( int i=0; i < l.size(); i++ ) {
2146 sb.append(prefix+"repeated_foreign_message["+i+"] {\n");
2147 l.get(i).toString(sb, prefix+" ");
2148 sb.append(prefix+"}\n");
2149 }
2150 }
2151 if( hasRepeatedImportMessage() ) {
2152 java.util.List<com.google.protobuf.test.UnittestImport.ImportMessage> l = getRepeatedImportMessageList();
2153 for( int i=0; i < l.size(); i++ ) {
2154 sb.append(prefix+"repeated_import_message["+i+"] {\n");
2155 l.get(i).toString(sb, prefix+" ");
2156 sb.append(prefix+"}\n");
2157 }
2158 }
2159 if( hasRepeatedNestedEnum() ) {
2160 java.util.List<TestAllTypes.NestedEnum> l = getRepeatedNestedEnumList();
2161 for( int i=0; i < l.size(); i++ ) {
2162 sb.append(prefix+"repeated_nested_enum["+i+"]: ");
2163 sb.append(l.get(i));
2164 sb.append("\n");
2165 }
2166 }
2167 if( hasRepeatedForeignEnum() ) {
2168 java.util.List<ForeignEnum> l = getRepeatedForeignEnumList();
2169 for( int i=0; i < l.size(); i++ ) {
2170 sb.append(prefix+"repeated_foreign_enum["+i+"]: ");
2171 sb.append(l.get(i));
2172 sb.append("\n");
2173 }
2174 }
2175 if( hasRepeatedImportEnum() ) {
2176 java.util.List<com.google.protobuf.test.UnittestImport.ImportEnum> l = getRepeatedImportEnumList();
2177 for( int i=0; i < l.size(); i++ ) {
2178 sb.append(prefix+"repeated_import_enum["+i+"]: ");
2179 sb.append(l.get(i));
2180 sb.append("\n");
2181 }
2182 }
2183 if( hasRepeatedStringPiece() ) {
2184 java.util.List<java.lang.String> l = getRepeatedStringPieceList();
2185 for( int i=0; i < l.size(); i++ ) {
2186 sb.append(prefix+"repeated_string_piece["+i+"]: ");
2187 sb.append(l.get(i));
2188 sb.append("\n");
2189 }
2190 }
2191 if( hasRepeatedCord() ) {
2192 java.util.List<java.lang.String> l = getRepeatedCordList();
2193 for( int i=0; i < l.size(); i++ ) {
2194 sb.append(prefix+"repeated_cord["+i+"]: ");
2195 sb.append(l.get(i));
2196 sb.append("\n");
2197 }
2198 }
2199 if( hasDefaultInt32() ) {
2200 sb.append(prefix+"default_int32: ");
2201 sb.append(getDefaultInt32());
2202 sb.append("\n");
2203 }
2204 if( hasDefaultInt64() ) {
2205 sb.append(prefix+"default_int64: ");
2206 sb.append(getDefaultInt64());
2207 sb.append("\n");
2208 }
2209 if( hasDefaultUint32() ) {
2210 sb.append(prefix+"default_uint32: ");
2211 sb.append(getDefaultUint32());
2212 sb.append("\n");
2213 }
2214 if( hasDefaultUint64() ) {
2215 sb.append(prefix+"default_uint64: ");
2216 sb.append(getDefaultUint64());
2217 sb.append("\n");
2218 }
2219 if( hasDefaultSint32() ) {
2220 sb.append(prefix+"default_sint32: ");
2221 sb.append(getDefaultSint32());
2222 sb.append("\n");
2223 }
2224 if( hasDefaultSint64() ) {
2225 sb.append(prefix+"default_sint64: ");
2226 sb.append(getDefaultSint64());
2227 sb.append("\n");
2228 }
2229 if( hasDefaultFixed32() ) {
2230 sb.append(prefix+"default_fixed32: ");
2231 sb.append(getDefaultFixed32());
2232 sb.append("\n");
2233 }
2234 if( hasDefaultFixed64() ) {
2235 sb.append(prefix+"default_fixed64: ");
2236 sb.append(getDefaultFixed64());
2237 sb.append("\n");
2238 }
2239 if( hasDefaultSfixed32() ) {
2240 sb.append(prefix+"default_sfixed32: ");
2241 sb.append(getDefaultSfixed32());
2242 sb.append("\n");
2243 }
2244 if( hasDefaultSfixed64() ) {
2245 sb.append(prefix+"default_sfixed64: ");
2246 sb.append(getDefaultSfixed64());
2247 sb.append("\n");
2248 }
2249 if( hasDefaultFloat() ) {
2250 sb.append(prefix+"default_float: ");
2251 sb.append(getDefaultFloat());
2252 sb.append("\n");
2253 }
2254 if( hasDefaultDouble() ) {
2255 sb.append(prefix+"default_double: ");
2256 sb.append(getDefaultDouble());
2257 sb.append("\n");
2258 }
2259 if( hasDefaultBool() ) {
2260 sb.append(prefix+"default_bool: ");
2261 sb.append(getDefaultBool());
2262 sb.append("\n");
2263 }
2264 if( hasDefaultString() ) {
2265 sb.append(prefix+"default_string: ");
2266 sb.append(getDefaultString());
2267 sb.append("\n");
2268 }
2269 if( hasDefaultBytes() ) {
2270 sb.append(prefix+"default_bytes: ");
2271 sb.append(getDefaultBytes());
2272 sb.append("\n");
2273 }
2274 if( hasDefaultNestedEnum() ) {
2275 sb.append(prefix+"default_nested_enum: ");
2276 sb.append(getDefaultNestedEnum());
2277 sb.append("\n");
2278 }
2279 if( hasDefaultForeignEnum() ) {
2280 sb.append(prefix+"default_foreign_enum: ");
2281 sb.append(getDefaultForeignEnum());
2282 sb.append("\n");
2283 }
2284 if( hasDefaultImportEnum() ) {
2285 sb.append(prefix+"default_import_enum: ");
2286 sb.append(getDefaultImportEnum());
2287 sb.append("\n");
2288 }
2289 if( hasDefaultStringPiece() ) {
2290 sb.append(prefix+"default_string_piece: ");
2291 sb.append(getDefaultStringPiece());
2292 sb.append("\n");
2293 }
2294 if( hasDefaultCord() ) {
2295 sb.append(prefix+"default_cord: ");
2296 sb.append(getDefaultCord());
2297 sb.append("\n");
2298 }
2299 return sb;
2300 }
2301
2302 public boolean equals(Object obj) {
2303 if( obj==this )
2304 return true;
2305
2306 if( obj==null || obj.getClass()!=TestAllTypes.class )
2307 return false;
2308
2309 return equals((TestAllTypes)obj);
2310 }
2311
2312 public boolean equals(TestAllTypes obj) {
2313 if (hasOptionalInt32() ^ obj.hasOptionalInt32() )
2314 return false;
2315 if (hasOptionalInt32() && ( getOptionalInt32()!=obj.getOptionalInt32() ))
2316 return false;
2317 if (hasOptionalInt64() ^ obj.hasOptionalInt64() )
2318 return false;
2319 if (hasOptionalInt64() && ( getOptionalInt64()!=obj.getOptionalInt64() ))
2320 return false;
2321 if (hasOptionalUint32() ^ obj.hasOptionalUint32() )
2322 return false;
2323 if (hasOptionalUint32() && ( getOptionalUint32()!=obj.getOptionalUint32() ))
2324 return false;
2325 if (hasOptionalUint64() ^ obj.hasOptionalUint64() )
2326 return false;
2327 if (hasOptionalUint64() && ( getOptionalUint64()!=obj.getOptionalUint64() ))
2328 return false;
2329 if (hasOptionalSint32() ^ obj.hasOptionalSint32() )
2330 return false;
2331 if (hasOptionalSint32() && ( getOptionalSint32()!=obj.getOptionalSint32() ))
2332 return false;
2333 if (hasOptionalSint64() ^ obj.hasOptionalSint64() )
2334 return false;
2335 if (hasOptionalSint64() && ( getOptionalSint64()!=obj.getOptionalSint64() ))
2336 return false;
2337 if (hasOptionalFixed32() ^ obj.hasOptionalFixed32() )
2338 return false;
2339 if (hasOptionalFixed32() && ( getOptionalFixed32()!=obj.getOptionalFixed32() ))
2340 return false;
2341 if (hasOptionalFixed64() ^ obj.hasOptionalFixed64() )
2342 return false;
2343 if (hasOptionalFixed64() && ( getOptionalFixed64()!=obj.getOptionalFixed64() ))
2344 return false;
2345 if (hasOptionalSfixed32() ^ obj.hasOptionalSfixed32() )
2346 return false;
2347 if (hasOptionalSfixed32() && ( getOptionalSfixed32()!=obj.getOptionalSfixed32() ))
2348 return false;
2349 if (hasOptionalSfixed64() ^ obj.hasOptionalSfixed64() )
2350 return false;
2351 if (hasOptionalSfixed64() && ( getOptionalSfixed64()!=obj.getOptionalSfixed64() ))
2352 return false;
2353 if (hasOptionalFloat() ^ obj.hasOptionalFloat() )
2354 return false;
2355 if (hasOptionalFloat() && ( getOptionalFloat()!=obj.getOptionalFloat() ))
2356 return false;
2357 if (hasOptionalDouble() ^ obj.hasOptionalDouble() )
2358 return false;
2359 if (hasOptionalDouble() && ( getOptionalDouble()!=obj.getOptionalDouble() ))
2360 return false;
2361 if (hasOptionalBool() ^ obj.hasOptionalBool() )
2362 return false;
2363 if (hasOptionalBool() && ( getOptionalBool()!=obj.getOptionalBool() ))
2364 return false;
2365 if (hasOptionalString() ^ obj.hasOptionalString() )
2366 return false;
2367 if (hasOptionalString() && ( !getOptionalString().equals(obj.getOptionalString()) ))
2368 return false;
2369 if (hasOptionalBytes() ^ obj.hasOptionalBytes() )
2370 return false;
2371 if (hasOptionalBytes() && ( !getOptionalBytes().equals(obj.getOptionalBytes()) ))
2372 return false;
2373 if (hasOptionalGroup() ^ obj.hasOptionalGroup() )
2374 return false;
2375 if (hasOptionalGroup() && ( !getOptionalGroup().equals(obj.getOptionalGroup()) ))
2376 return false;
2377 if (hasOptionalNestedMessage() ^ obj.hasOptionalNestedMessage() )
2378 return false;
2379 if (hasOptionalNestedMessage() && ( !getOptionalNestedMessage().equals(obj.getOptionalNestedMessage()) ))
2380 return false;
2381 if (hasOptionalForeignMessage() ^ obj.hasOptionalForeignMessage() )
2382 return false;
2383 if (hasOptionalForeignMessage() && ( !getOptionalForeignMessage().equals(obj.getOptionalForeignMessage()) ))
2384 return false;
2385 if (hasOptionalImportMessage() ^ obj.hasOptionalImportMessage() )
2386 return false;
2387 if (hasOptionalImportMessage() && ( !getOptionalImportMessage().equals(obj.getOptionalImportMessage()) ))
2388 return false;
2389 if (hasOptionalNestedEnum() ^ obj.hasOptionalNestedEnum() )
2390 return false;
2391 if (hasOptionalNestedEnum() && ( !getOptionalNestedEnum().equals(obj.getOptionalNestedEnum()) ))
2392 return false;
2393 if (hasOptionalForeignEnum() ^ obj.hasOptionalForeignEnum() )
2394 return false;
2395 if (hasOptionalForeignEnum() && ( !getOptionalForeignEnum().equals(obj.getOptionalForeignEnum()) ))
2396 return false;
2397 if (hasOptionalImportEnum() ^ obj.hasOptionalImportEnum() )
2398 return false;
2399 if (hasOptionalImportEnum() && ( !getOptionalImportEnum().equals(obj.getOptionalImportEnum()) ))
2400 return false;
2401 if (hasOptionalStringPiece() ^ obj.hasOptionalStringPiece() )
2402 return false;
2403 if (hasOptionalStringPiece() && ( !getOptionalStringPiece().equals(obj.getOptionalStringPiece()) ))
2404 return false;
2405 if (hasOptionalCord() ^ obj.hasOptionalCord() )
2406 return false;
2407 if (hasOptionalCord() && ( !getOptionalCord().equals(obj.getOptionalCord()) ))
2408 return false;
2409 if (hasRepeatedInt32() ^ obj.hasRepeatedInt32() )
2410 return false;
2411 if (hasRepeatedInt32() && ( !getRepeatedInt32List().equals(obj.getRepeatedInt32List()) ))
2412 return false;
2413 if (hasRepeatedInt64() ^ obj.hasRepeatedInt64() )
2414 return false;
2415 if (hasRepeatedInt64() && ( !getRepeatedInt64List().equals(obj.getRepeatedInt64List()) ))
2416 return false;
2417 if (hasRepeatedUint32() ^ obj.hasRepeatedUint32() )
2418 return false;
2419 if (hasRepeatedUint32() && ( !getRepeatedUint32List().equals(obj.getRepeatedUint32List()) ))
2420 return false;
2421 if (hasRepeatedUint64() ^ obj.hasRepeatedUint64() )
2422 return false;
2423 if (hasRepeatedUint64() && ( !getRepeatedUint64List().equals(obj.getRepeatedUint64List()) ))
2424 return false;
2425 if (hasRepeatedSint32() ^ obj.hasRepeatedSint32() )
2426 return false;
2427 if (hasRepeatedSint32() && ( !getRepeatedSint32List().equals(obj.getRepeatedSint32List()) ))
2428 return false;
2429 if (hasRepeatedSint64() ^ obj.hasRepeatedSint64() )
2430 return false;
2431 if (hasRepeatedSint64() && ( !getRepeatedSint64List().equals(obj.getRepeatedSint64List()) ))
2432 return false;
2433 if (hasRepeatedFixed32() ^ obj.hasRepeatedFixed32() )
2434 return false;
2435 if (hasRepeatedFixed32() && ( !getRepeatedFixed32List().equals(obj.getRepeatedFixed32List()) ))
2436 return false;
2437 if (hasRepeatedFixed64() ^ obj.hasRepeatedFixed64() )
2438 return false;
2439 if (hasRepeatedFixed64() && ( !getRepeatedFixed64List().equals(obj.getRepeatedFixed64List()) ))
2440 return false;
2441 if (hasRepeatedSfixed32() ^ obj.hasRepeatedSfixed32() )
2442 return false;
2443 if (hasRepeatedSfixed32() && ( !getRepeatedSfixed32List().equals(obj.getRepeatedSfixed32List()) ))
2444 return false;
2445 if (hasRepeatedSfixed64() ^ obj.hasRepeatedSfixed64() )
2446 return false;
2447 if (hasRepeatedSfixed64() && ( !getRepeatedSfixed64List().equals(obj.getRepeatedSfixed64List()) ))
2448 return false;
2449 if (hasRepeatedFloat() ^ obj.hasRepeatedFloat() )
2450 return false;
2451 if (hasRepeatedFloat() && ( !getRepeatedFloatList().equals(obj.getRepeatedFloatList()) ))
2452 return false;
2453 if (hasRepeatedDouble() ^ obj.hasRepeatedDouble() )
2454 return false;
2455 if (hasRepeatedDouble() && ( !getRepeatedDoubleList().equals(obj.getRepeatedDoubleList()) ))
2456 return false;
2457 if (hasRepeatedBool() ^ obj.hasRepeatedBool() )
2458 return false;
2459 if (hasRepeatedBool() && ( !getRepeatedBoolList().equals(obj.getRepeatedBoolList()) ))
2460 return false;
2461 if (hasRepeatedString() ^ obj.hasRepeatedString() )
2462 return false;
2463 if (hasRepeatedString() && ( !getRepeatedStringList().equals(obj.getRepeatedStringList()) ))
2464 return false;
2465 if (hasRepeatedBytes() ^ obj.hasRepeatedBytes() )
2466 return false;
2467 if (hasRepeatedBytes() && ( !getRepeatedBytesList().equals(obj.getRepeatedBytesList()) ))
2468 return false;
2469 if (hasRepeatedGroup() ^ obj.hasRepeatedGroup() )
2470 return false;
2471 if (hasRepeatedGroup() && ( !getRepeatedGroupList().equals(obj.getRepeatedGroupList()) ))
2472 return false;
2473 if (hasRepeatedNestedMessage() ^ obj.hasRepeatedNestedMessage() )
2474 return false;
2475 if (hasRepeatedNestedMessage() && ( !getRepeatedNestedMessageList().equals(obj.getRepeatedNestedMessageList()) ))
2476 return false;
2477 if (hasRepeatedForeignMessage() ^ obj.hasRepeatedForeignMessage() )
2478 return false;
2479 if (hasRepeatedForeignMessage() && ( !getRepeatedForeignMessageList().equals(obj.getRepeatedForeignMessageList()) ))
2480 return false;
2481 if (hasRepeatedImportMessage() ^ obj.hasRepeatedImportMessage() )
2482 return false;
2483 if (hasRepeatedImportMessage() && ( !getRepeatedImportMessageList().equals(obj.getRepeatedImportMessageList()) ))
2484 return false;
2485 if (hasRepeatedNestedEnum() ^ obj.hasRepeatedNestedEnum() )
2486 return false;
2487 if (hasRepeatedNestedEnum() && ( !getRepeatedNestedEnumList().equals(obj.getRepeatedNestedEnumList()) ))
2488 return false;
2489 if (hasRepeatedForeignEnum() ^ obj.hasRepeatedForeignEnum() )
2490 return false;
2491 if (hasRepeatedForeignEnum() && ( !getRepeatedForeignEnumList().equals(obj.getRepeatedForeignEnumList()) ))
2492 return false;
2493 if (hasRepeatedImportEnum() ^ obj.hasRepeatedImportEnum() )
2494 return false;
2495 if (hasRepeatedImportEnum() && ( !getRepeatedImportEnumList().equals(obj.getRepeatedImportEnumList()) ))
2496 return false;
2497 if (hasRepeatedStringPiece() ^ obj.hasRepeatedStringPiece() )
2498 return false;
2499 if (hasRepeatedStringPiece() && ( !getRepeatedStringPieceList().equals(obj.getRepeatedStringPieceList()) ))
2500 return false;
2501 if (hasRepeatedCord() ^ obj.hasRepeatedCord() )
2502 return false;
2503 if (hasRepeatedCord() && ( !getRepeatedCordList().equals(obj.getRepeatedCordList()) ))
2504 return false;
2505 if (hasDefaultInt32() ^ obj.hasDefaultInt32() )
2506 return false;
2507 if (hasDefaultInt32() && ( getDefaultInt32()!=obj.getDefaultInt32() ))
2508 return false;
2509 if (hasDefaultInt64() ^ obj.hasDefaultInt64() )
2510 return false;
2511 if (hasDefaultInt64() && ( getDefaultInt64()!=obj.getDefaultInt64() ))
2512 return false;
2513 if (hasDefaultUint32() ^ obj.hasDefaultUint32() )
2514 return false;
2515 if (hasDefaultUint32() && ( getDefaultUint32()!=obj.getDefaultUint32() ))
2516 return false;
2517 if (hasDefaultUint64() ^ obj.hasDefaultUint64() )
2518 return false;
2519 if (hasDefaultUint64() && ( getDefaultUint64()!=obj.getDefaultUint64() ))
2520 return false;
2521 if (hasDefaultSint32() ^ obj.hasDefaultSint32() )
2522 return false;
2523 if (hasDefaultSint32() && ( getDefaultSint32()!=obj.getDefaultSint32() ))
2524 return false;
2525 if (hasDefaultSint64() ^ obj.hasDefaultSint64() )
2526 return false;
2527 if (hasDefaultSint64() && ( getDefaultSint64()!=obj.getDefaultSint64() ))
2528 return false;
2529 if (hasDefaultFixed32() ^ obj.hasDefaultFixed32() )
2530 return false;
2531 if (hasDefaultFixed32() && ( getDefaultFixed32()!=obj.getDefaultFixed32() ))
2532 return false;
2533 if (hasDefaultFixed64() ^ obj.hasDefaultFixed64() )
2534 return false;
2535 if (hasDefaultFixed64() && ( getDefaultFixed64()!=obj.getDefaultFixed64() ))
2536 return false;
2537 if (hasDefaultSfixed32() ^ obj.hasDefaultSfixed32() )
2538 return false;
2539 if (hasDefaultSfixed32() && ( getDefaultSfixed32()!=obj.getDefaultSfixed32() ))
2540 return false;
2541 if (hasDefaultSfixed64() ^ obj.hasDefaultSfixed64() )
2542 return false;
2543 if (hasDefaultSfixed64() && ( getDefaultSfixed64()!=obj.getDefaultSfixed64() ))
2544 return false;
2545 if (hasDefaultFloat() ^ obj.hasDefaultFloat() )
2546 return false;
2547 if (hasDefaultFloat() && ( getDefaultFloat()!=obj.getDefaultFloat() ))
2548 return false;
2549 if (hasDefaultDouble() ^ obj.hasDefaultDouble() )
2550 return false;
2551 if (hasDefaultDouble() && ( getDefaultDouble()!=obj.getDefaultDouble() ))
2552 return false;
2553 if (hasDefaultBool() ^ obj.hasDefaultBool() )
2554 return false;
2555 if (hasDefaultBool() && ( getDefaultBool()!=obj.getDefaultBool() ))
2556 return false;
2557 if (hasDefaultString() ^ obj.hasDefaultString() )
2558 return false;
2559 if (hasDefaultString() && ( !getDefaultString().equals(obj.getDefaultString()) ))
2560 return false;
2561 if (hasDefaultBytes() ^ obj.hasDefaultBytes() )
2562 return false;
2563 if (hasDefaultBytes() && ( !getDefaultBytes().equals(obj.getDefaultBytes()) ))
2564 return false;
2565 if (hasDefaultNestedEnum() ^ obj.hasDefaultNestedEnum() )
2566 return false;
2567 if (hasDefaultNestedEnum() && ( !getDefaultNestedEnum().equals(obj.getDefaultNestedEnum()) ))
2568 return false;
2569 if (hasDefaultForeignEnum() ^ obj.hasDefaultForeignEnum() )
2570 return false;
2571 if (hasDefaultForeignEnum() && ( !getDefaultForeignEnum().equals(obj.getDefaultForeignEnum()) ))
2572 return false;
2573 if (hasDefaultImportEnum() ^ obj.hasDefaultImportEnum() )
2574 return false;
2575 if (hasDefaultImportEnum() && ( !getDefaultImportEnum().equals(obj.getDefaultImportEnum()) ))
2576 return false;
2577 if (hasDefaultStringPiece() ^ obj.hasDefaultStringPiece() )
2578 return false;
2579 if (hasDefaultStringPiece() && ( !getDefaultStringPiece().equals(obj.getDefaultStringPiece()) ))
2580 return false;
2581 if (hasDefaultCord() ^ obj.hasDefaultCord() )
2582 return false;
2583 if (hasDefaultCord() && ( !getDefaultCord().equals(obj.getDefaultCord()) ))
2584 return false;
2585 return true;
2586 }
2587
2588 public int hashCode() {
2589 int rc=-1628039638;
2590 if (hasOptionalInt32()) {
2591 rc ^= ( 1444245230^getOptionalInt32() );
2592 }
2593 if (hasOptionalInt64()) {
2594 rc ^= ( 1444245325^(new Long(getOptionalInt64())).hashCode() );
2595 }
2596 if (hasOptionalUint32()) {
2597 rc ^= ( -2134222119^getOptionalUint32() );
2598 }
2599 if (hasOptionalUint64()) {
2600 rc ^= ( -2134222024^(new Long(getOptionalUint64())).hashCode() );
2601 }
2602 if (hasOptionalSint32()) {
2603 rc ^= ( 2103486875^getOptionalSint32() );
2604 }
2605 if (hasOptionalSint64()) {
2606 rc ^= ( 2103486970^(new Long(getOptionalSint64())).hashCode() );
2607 }
2608 if (hasOptionalFixed32()) {
2609 rc ^= ( 2139773235^getOptionalFixed32() );
2610 }
2611 if (hasOptionalFixed64()) {
2612 rc ^= ( 2139773330^(new Long(getOptionalFixed64())).hashCode() );
2613 }
2614 if (hasOptionalSfixed32()) {
2615 rc ^= ( 15834272^getOptionalSfixed32() );
2616 }
2617 if (hasOptionalSfixed64()) {
2618 rc ^= ( 15834367^(new Long(getOptionalSfixed64())).hashCode() );
2619 }
2620 if (hasOptionalFloat()) {
2621 rc ^= ( 1441411772^(new Double(getOptionalFloat())).hashCode() );
2622 }
2623 if (hasOptionalDouble()) {
2624 rc ^= ( 1679783793^(new Double(getOptionalDouble())).hashCode() );
2625 }
2626 if (hasOptionalBool()) {
2627 rc ^= ( 1986043530^ (getOptionalBool()? 13:-13) );
2628 }
2629 if (hasOptionalString()) {
2630 rc ^= ( 2113756081^getOptionalString().hashCode() );
2631 }
2632 if (hasOptionalBytes()) {
2633 rc ^= ( 1438109899^getOptionalBytes().hashCode() );
2634 }
2635 if (hasOptionalGroup()) {
2636 rc ^= ( 1442514655^getOptionalGroup().hashCode() );
2637 }
2638 if (hasOptionalNestedMessage()) {
2639 rc ^= ( 1060320112^getOptionalNestedMessage().hashCode() );
2640 }
2641 if (hasOptionalForeignMessage()) {
2642 rc ^= ( 215194675^getOptionalForeignMessage().hashCode() );
2643 }
2644 if (hasOptionalImportMessage()) {
2645 rc ^= ( 1436573954^getOptionalImportMessage().hashCode() );
2646 }
2647 if (hasOptionalNestedEnum()) {
2648 rc ^= ( 1820672568^getOptionalNestedEnum().hashCode() );
2649 }
2650 if (hasOptionalForeignEnum()) {
2651 rc ^= ( 944523349^getOptionalForeignEnum().hashCode() );
2652 }
2653 if (hasOptionalImportEnum()) {
2654 rc ^= ( 539446758^getOptionalImportEnum().hashCode() );
2655 }
2656 if (hasOptionalStringPiece()) {
2657 rc ^= ( 868607421^getOptionalStringPiece().hashCode() );
2658 }
2659 if (hasOptionalCord()) {
2660 rc ^= ( 1986073406^getOptionalCord().hashCode() );
2661 }
2662 if (hasRepeatedInt32()) {
2663 rc ^= ( -1044448492^getRepeatedInt32List().hashCode() );
2664 }
2665 if (hasRepeatedInt64()) {
2666 rc ^= ( -1044448397^getRepeatedInt64List().hashCode() );
2667 }
2668 if (hasRepeatedUint32()) {
2669 rc ^= ( -1974316173^getRepeatedUint32List().hashCode() );
2670 }
2671 if (hasRepeatedUint64()) {
2672 rc ^= ( -1974316078^getRepeatedUint64List().hashCode() );
2673 }
2674 if (hasRepeatedSint32()) {
2675 rc ^= ( -2031574475^getRepeatedSint32List().hashCode() );
2676 }
2677 if (hasRepeatedSint64()) {
2678 rc ^= ( -2031574380^getRepeatedSint64List().hashCode() );
2679 }
2680 if (hasRepeatedFixed32()) {
2681 rc ^= ( -1493077031^getRepeatedFixed32List().hashCode() );
2682 }
2683 if (hasRepeatedFixed64()) {
2684 rc ^= ( -1493076936^getRepeatedFixed64List().hashCode() );
2685 }
2686 if (hasRepeatedSfixed32()) {
2687 rc ^= ( -933374278^getRepeatedSfixed32List().hashCode() );
2688 }
2689 if (hasRepeatedSfixed64()) {
2690 rc ^= ( -933374183^getRepeatedSfixed64List().hashCode() );
2691 }
2692 if (hasRepeatedFloat()) {
2693 rc ^= ( -1047281950^getRepeatedFloatList().hashCode() );
2694 }
2695 if (hasRepeatedDouble()) {
2696 rc ^= ( 1839689739^getRepeatedDoubleList().hashCode() );
2697 }
2698 if (hasRepeatedBool()) {
2699 rc ^= ( -1696467548^getRepeatedBoolList().hashCode() );
2700 }
2701 if (hasRepeatedString()) {
2702 rc ^= ( -2021305269^getRepeatedStringList().hashCode() );
2703 }
2704 if (hasRepeatedBytes()) {
2705 rc ^= ( -1050583823^getRepeatedBytesList().hashCode() );
2706 }
2707 if (hasRepeatedGroup()) {
2708 rc ^= ( -1046179067^getRepeatedGroupList().hashCode() );
2709 }
2710 if (hasRepeatedNestedMessage()) {
2711 rc ^= ( 1622751638^getRepeatedNestedMessageList().hashCode() );
2712 }
2713 if (hasRepeatedForeignMessage()) {
2714 rc ^= ( 470702797^getRepeatedForeignMessageList().hashCode() );
2715 }
2716 if (hasRepeatedImportMessage()) {
2717 rc ^= ( 1999005480^getRepeatedImportMessageList().hashCode() );
2718 }
2719 if (hasRepeatedNestedEnum()) {
2720 rc ^= ( 164322770^getRepeatedNestedEnumList().hashCode() );
2721 }
2722 if (hasRepeatedForeignEnum()) {
2723 rc ^= ( 1137287163^getRepeatedForeignEnumList().hashCode() );
2724 }
2725 if (hasRepeatedImportEnum()) {
2726 rc ^= ( -1116903040^getRepeatedImportEnumList().hashCode() );
2727 }
2728 if (hasRepeatedStringPiece()) {
2729 rc ^= ( 1061371235^getRepeatedStringPieceList().hashCode() );
2730 }
2731 if (hasRepeatedCord()) {
2732 rc ^= ( -1696437672^getRepeatedCordList().hashCode() );
2733 }
2734 if (hasDefaultInt32()) {
2735 rc ^= ( -506417939^getDefaultInt32() );
2736 }
2737 if (hasDefaultInt64()) {
2738 rc ^= ( -506417844^(new Long(getDefaultInt64())).hashCode() );
2739 }
2740 if (hasDefaultUint32()) {
2741 rc ^= ( 1819729082^getDefaultUint32() );
2742 }
2743 if (hasDefaultUint64()) {
2744 rc ^= ( 1819729177^(new Long(getDefaultUint64())).hashCode() );
2745 }
2746 if (hasDefaultSint32()) {
2747 rc ^= ( 1762470780^getDefaultSint32() );
2748 }
2749 if (hasDefaultSint64()) {
2750 rc ^= ( 1762470875^(new Long(getDefaultSint64())).hashCode() );
2751 }
2752 if (hasDefaultFixed32()) {
2753 rc ^= ( 158208882^getDefaultFixed32() );
2754 }
2755 if (hasDefaultFixed64()) {
2756 rc ^= ( 158208977^(new Long(getDefaultFixed64())).hashCode() );
2757 }
2758 if (hasDefaultSfixed32()) {
2759 rc ^= ( -1283118527^getDefaultSfixed32() );
2760 }
2761 if (hasDefaultSfixed64()) {
2762 rc ^= ( -1283118432^(new Long(getDefaultSfixed64())).hashCode() );
2763 }
2764 if (hasDefaultFloat()) {
2765 rc ^= ( -509251397^(new Double(getDefaultFloat())).hashCode() );
2766 }
2767 if (hasDefaultDouble()) {
2768 rc ^= ( 1338767698^(new Double(getDefaultDouble())).hashCode() );
2769 }
2770 if (hasDefaultBool()) {
2771 rc ^= ( 1230382251^ (getDefaultBool()? 61:-61) );
2772 }
2773 if (hasDefaultString()) {
2774 rc ^= ( 1772739986^getDefaultString().hashCode() );
2775 }
2776 if (hasDefaultBytes()) {
2777 rc ^= ( -512553270^getDefaultBytes().hashCode() );
2778 }
2779 if (hasDefaultNestedEnum()) {
2780 rc ^= ( -932451431^getDefaultNestedEnum().hashCode() );
2781 }
2782 if (hasDefaultForeignEnum()) {
2783 rc ^= ( 1497025300^getDefaultForeignEnum().hashCode() );
2784 }
2785 if (hasDefaultImportEnum()) {
2786 rc ^= ( 2081290055^getDefaultImportEnum().hashCode() );
2787 }
2788 if (hasDefaultStringPiece()) {
2789 rc ^= ( 1421109372^getDefaultStringPiece().hashCode() );
2790 }
2791 if (hasDefaultCord()) {
2792 rc ^= ( 1230412127^getDefaultCord().hashCode() );
2793 }
2794 return rc;
2795 }
2796
2797 }
2798
2799 static abstract class TestAllTypesBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
2800
2801 // optional int32 optional_int32 = 1;
2802 private int f_optionalInt32 = 0;
2803 private boolean b_optionalInt32;
2804
2805 public boolean hasOptionalInt32() {
2806 return this.b_optionalInt32;
2807 }
2808
2809 public int getOptionalInt32() {
2810 return this.f_optionalInt32;
2811 }
2812
2813 public T setOptionalInt32(int optionalInt32) {
2814 loadAndClear();
2815 this.b_optionalInt32 = true;
2816 this.f_optionalInt32 = optionalInt32;
2817 return (T)this;
2818 }
2819
2820 public void clearOptionalInt32() {
2821 loadAndClear();
2822 this.b_optionalInt32 = false;
2823 this.f_optionalInt32 = 0;
2824 }
2825
2826 // optional int64 optional_int64 = 2;
2827 private long f_optionalInt64 = 0;
2828 private boolean b_optionalInt64;
2829
2830 public boolean hasOptionalInt64() {
2831 return this.b_optionalInt64;
2832 }
2833
2834 public long getOptionalInt64() {
2835 return this.f_optionalInt64;
2836 }
2837
2838 public T setOptionalInt64(long optionalInt64) {
2839 loadAndClear();
2840 this.b_optionalInt64 = true;
2841 this.f_optionalInt64 = optionalInt64;
2842 return (T)this;
2843 }
2844
2845 public void clearOptionalInt64() {
2846 loadAndClear();
2847 this.b_optionalInt64 = false;
2848 this.f_optionalInt64 = 0;
2849 }
2850
2851 // optional uint32 optional_uint32 = 3;
2852 private int f_optionalUint32 = 0;
2853 private boolean b_optionalUint32;
2854
2855 public boolean hasOptionalUint32() {
2856 return this.b_optionalUint32;
2857 }
2858
2859 public int getOptionalUint32() {
2860 return this.f_optionalUint32;
2861 }
2862
2863 public T setOptionalUint32(int optionalUint32) {
2864 loadAndClear();
2865 this.b_optionalUint32 = true;
2866 this.f_optionalUint32 = optionalUint32;
2867 return (T)this;
2868 }
2869
2870 public void clearOptionalUint32() {
2871 loadAndClear();
2872 this.b_optionalUint32 = false;
2873 this.f_optionalUint32 = 0;
2874 }
2875
2876 // optional uint64 optional_uint64 = 4;
2877 private long f_optionalUint64 = 0;
2878 private boolean b_optionalUint64;
2879
2880 public boolean hasOptionalUint64() {
2881 return this.b_optionalUint64;
2882 }
2883
2884 public long getOptionalUint64() {
2885 return this.f_optionalUint64;
2886 }
2887
2888 public T setOptionalUint64(long optionalUint64) {
2889 loadAndClear();
2890 this.b_optionalUint64 = true;
2891 this.f_optionalUint64 = optionalUint64;
2892 return (T)this;
2893 }
2894
2895 public void clearOptionalUint64() {
2896 loadAndClear();
2897 this.b_optionalUint64 = false;
2898 this.f_optionalUint64 = 0;
2899 }
2900
2901 // optional sint32 optional_sint32 = 5;
2902 private int f_optionalSint32 = 0;
2903 private boolean b_optionalSint32;
2904
2905 public boolean hasOptionalSint32() {
2906 return this.b_optionalSint32;
2907 }
2908
2909 public int getOptionalSint32() {
2910 return this.f_optionalSint32;
2911 }
2912
2913 public T setOptionalSint32(int optionalSint32) {
2914 loadAndClear();
2915 this.b_optionalSint32 = true;
2916 this.f_optionalSint32 = optionalSint32;
2917 return (T)this;
2918 }
2919
2920 public void clearOptionalSint32() {
2921 loadAndClear();
2922 this.b_optionalSint32 = false;
2923 this.f_optionalSint32 = 0;
2924 }
2925
2926 // optional sint64 optional_sint64 = 6;
2927 private long f_optionalSint64 = 0;
2928 private boolean b_optionalSint64;
2929
2930 public boolean hasOptionalSint64() {
2931 return this.b_optionalSint64;
2932 }
2933
2934 public long getOptionalSint64() {
2935 return this.f_optionalSint64;
2936 }
2937
2938 public T setOptionalSint64(long optionalSint64) {
2939 loadAndClear();
2940 this.b_optionalSint64 = true;
2941 this.f_optionalSint64 = optionalSint64;
2942 return (T)this;
2943 }
2944
2945 public void clearOptionalSint64() {
2946 loadAndClear();
2947 this.b_optionalSint64 = false;
2948 this.f_optionalSint64 = 0;
2949 }
2950
2951 // optional fixed32 optional_fixed32 = 7;
2952 private int f_optionalFixed32 = 0;
2953 private boolean b_optionalFixed32;
2954
2955 public boolean hasOptionalFixed32() {
2956 return this.b_optionalFixed32;
2957 }
2958
2959 public int getOptionalFixed32() {
2960 return this.f_optionalFixed32;
2961 }
2962
2963 public T setOptionalFixed32(int optionalFixed32) {
2964 loadAndClear();
2965 this.b_optionalFixed32 = true;
2966 this.f_optionalFixed32 = optionalFixed32;
2967 return (T)this;
2968 }
2969
2970 public void clearOptionalFixed32() {
2971 loadAndClear();
2972 this.b_optionalFixed32 = false;
2973 this.f_optionalFixed32 = 0;
2974 }
2975
2976 // optional fixed64 optional_fixed64 = 8;
2977 private long f_optionalFixed64 = 0;
2978 private boolean b_optionalFixed64;
2979
2980 public boolean hasOptionalFixed64() {
2981 return this.b_optionalFixed64;
2982 }
2983
2984 public long getOptionalFixed64() {
2985 return this.f_optionalFixed64;
2986 }
2987
2988 public T setOptionalFixed64(long optionalFixed64) {
2989 loadAndClear();
2990 this.b_optionalFixed64 = true;
2991 this.f_optionalFixed64 = optionalFixed64;
2992 return (T)this;
2993 }
2994
2995 public void clearOptionalFixed64() {
2996 loadAndClear();
2997 this.b_optionalFixed64 = false;
2998 this.f_optionalFixed64 = 0;
2999 }
3000
3001 // optional sfixed32 optional_sfixed32 = 9;
3002 private int f_optionalSfixed32 = 0;
3003 private boolean b_optionalSfixed32;
3004
3005 public boolean hasOptionalSfixed32() {
3006 return this.b_optionalSfixed32;
3007 }
3008
3009 public int getOptionalSfixed32() {
3010 return this.f_optionalSfixed32;
3011 }
3012
3013 public T setOptionalSfixed32(int optionalSfixed32) {
3014 loadAndClear();
3015 this.b_optionalSfixed32 = true;
3016 this.f_optionalSfixed32 = optionalSfixed32;
3017 return (T)this;
3018 }
3019
3020 public void clearOptionalSfixed32() {
3021 loadAndClear();
3022 this.b_optionalSfixed32 = false;
3023 this.f_optionalSfixed32 = 0;
3024 }
3025
3026 // optional sfixed64 optional_sfixed64 = 10;
3027 private long f_optionalSfixed64 = 0;
3028 private boolean b_optionalSfixed64;
3029
3030 public boolean hasOptionalSfixed64() {
3031 return this.b_optionalSfixed64;
3032 }
3033
3034 public long getOptionalSfixed64() {
3035 return this.f_optionalSfixed64;
3036 }
3037
3038 public T setOptionalSfixed64(long optionalSfixed64) {
3039 loadAndClear();
3040 this.b_optionalSfixed64 = true;
3041 this.f_optionalSfixed64 = optionalSfixed64;
3042 return (T)this;
3043 }
3044
3045 public void clearOptionalSfixed64() {
3046 loadAndClear();
3047 this.b_optionalSfixed64 = false;
3048 this.f_optionalSfixed64 = 0;
3049 }
3050
3051 // optional float optional_float = 11;
3052 private float f_optionalFloat = 0;
3053 private boolean b_optionalFloat;
3054
3055 public boolean hasOptionalFloat() {
3056 return this.b_optionalFloat;
3057 }
3058
3059 public float getOptionalFloat() {
3060 return this.f_optionalFloat;
3061 }
3062
3063 public T setOptionalFloat(float optionalFloat) {
3064 loadAndClear();
3065 this.b_optionalFloat = true;
3066 this.f_optionalFloat = optionalFloat;
3067 return (T)this;
3068 }
3069
3070 public void clearOptionalFloat() {
3071 loadAndClear();
3072 this.b_optionalFloat = false;
3073 this.f_optionalFloat = 0;
3074 }
3075
3076 // optional double optional_double = 12;
3077 private double f_optionalDouble = 0;
3078 private boolean b_optionalDouble;
3079
3080 public boolean hasOptionalDouble() {
3081 return this.b_optionalDouble;
3082 }
3083
3084 public double getOptionalDouble() {
3085 return this.f_optionalDouble;
3086 }
3087
3088 public T setOptionalDouble(double optionalDouble) {
3089 loadAndClear();
3090 this.b_optionalDouble = true;
3091 this.f_optionalDouble = optionalDouble;
3092 return (T)this;
3093 }
3094
3095 public void clearOptionalDouble() {
3096 loadAndClear();
3097 this.b_optionalDouble = false;
3098 this.f_optionalDouble = 0;
3099 }
3100
3101 // optional bool optional_bool = 13;
3102 private boolean f_optionalBool = false;
3103 private boolean b_optionalBool;
3104
3105 public boolean hasOptionalBool() {
3106 return this.b_optionalBool;
3107 }
3108
3109 public boolean getOptionalBool() {
3110 return this.f_optionalBool;
3111 }
3112
3113 public T setOptionalBool(boolean optionalBool) {
3114 loadAndClear();
3115 this.b_optionalBool = true;
3116 this.f_optionalBool = optionalBool;
3117 return (T)this;
3118 }
3119
3120 public void clearOptionalBool() {
3121 loadAndClear();
3122 this.b_optionalBool = false;
3123 this.f_optionalBool = false;
3124 }
3125
3126 // optional string optional_string = 14;
3127 private java.lang.String f_optionalString = null;
3128 private boolean b_optionalString;
3129
3130 public boolean hasOptionalString() {
3131 return this.b_optionalString;
3132 }
3133
3134 public java.lang.String getOptionalString() {
3135 return this.f_optionalString;
3136 }
3137
3138 public T setOptionalString(java.lang.String optionalString) {
3139 loadAndClear();
3140 this.b_optionalString = true;
3141 this.f_optionalString = optionalString;
3142 return (T)this;
3143 }
3144
3145 public void clearOptionalString() {
3146 loadAndClear();
3147 this.b_optionalString = false;
3148 this.f_optionalString = null;
3149 }
3150
3151 // optional bytes optional_bytes = 15;
3152 private org.apache.activemq.protobuf.Buffer f_optionalBytes = null;
3153 private boolean b_optionalBytes;
3154
3155 public boolean hasOptionalBytes() {
3156 return this.b_optionalBytes;
3157 }
3158
3159 public org.apache.activemq.protobuf.Buffer getOptionalBytes() {
3160 return this.f_optionalBytes;
3161 }
3162
3163 public T setOptionalBytes(org.apache.activemq.protobuf.Buffer optionalBytes) {
3164 loadAndClear();
3165 this.b_optionalBytes = true;
3166 this.f_optionalBytes = optionalBytes;
3167 return (T)this;
3168 }
3169
3170 public void clearOptionalBytes() {
3171 loadAndClear();
3172 this.b_optionalBytes = false;
3173 this.f_optionalBytes = null;
3174 }
3175
3176 // optional OptionalGroup OptionalGroup = 16;
3177 private TestAllTypes.OptionalGroup f_optionalGroup = null;
3178
3179 public boolean hasOptionalGroup() {
3180 return this.f_optionalGroup!=null;
3181 }
3182
3183 public TestAllTypes.OptionalGroup getOptionalGroup() {
3184 if( this.f_optionalGroup == null ) {
3185 this.f_optionalGroup = new TestAllTypes.OptionalGroup();
3186 }
3187 return this.f_optionalGroup;
3188 }
3189
3190 public T setOptionalGroup(TestAllTypes.OptionalGroup optionalGroup) {
3191 loadAndClear();
3192 this.f_optionalGroup = optionalGroup;
3193 return (T)this;
3194 }
3195
3196 public void clearOptionalGroup() {
3197 loadAndClear();
3198 this.f_optionalGroup = null;
3199 }
3200
3201 // optional NestedMessage optional_nested_message = 18;
3202 private TestAllTypes.NestedMessage f_optionalNestedMessage = null;
3203
3204 public boolean hasOptionalNestedMessage() {
3205 return this.f_optionalNestedMessage!=null;
3206 }
3207
3208 public TestAllTypes.NestedMessage getOptionalNestedMessage() {
3209 if( this.f_optionalNestedMessage == null ) {
3210 this.f_optionalNestedMessage = new TestAllTypes.NestedMessage();
3211 }
3212 return this.f_optionalNestedMessage;
3213 }
3214
3215 public T setOptionalNestedMessage(TestAllTypes.NestedMessage optionalNestedMessage) {
3216 loadAndClear();
3217 this.f_optionalNestedMessage = optionalNestedMessage;
3218 return (T)this;
3219 }
3220
3221 public void clearOptionalNestedMessage() {
3222 loadAndClear();
3223 this.f_optionalNestedMessage = null;
3224 }
3225
3226 // optional ForeignMessage optional_foreign_message = 19;
3227 private ForeignMessage f_optionalForeignMessage = null;
3228
3229 public boolean hasOptionalForeignMessage() {
3230 return this.f_optionalForeignMessage!=null;
3231 }
3232
3233 public ForeignMessage getOptionalForeignMessage() {
3234 if( this.f_optionalForeignMessage == null ) {
3235 this.f_optionalForeignMessage = new ForeignMessage();
3236 }
3237 return this.f_optionalForeignMessage;
3238 }
3239
3240 public T setOptionalForeignMessage(ForeignMessage optionalForeignMessage) {
3241 loadAndClear();
3242 this.f_optionalForeignMessage = optionalForeignMessage;
3243 return (T)this;
3244 }
3245
3246 public void clearOptionalForeignMessage() {
3247 loadAndClear();
3248 this.f_optionalForeignMessage = null;
3249 }
3250
3251 // optional protobuf_unittest_import.ImportMessage optional_import_message = 20;
3252 private com.google.protobuf.test.UnittestImport.ImportMessage f_optionalImportMessage = null;
3253
3254 public boolean hasOptionalImportMessage() {
3255 return this.f_optionalImportMessage!=null;
3256 }
3257
3258 public com.google.protobuf.test.UnittestImport.ImportMessage getOptionalImportMessage() {
3259 if( this.f_optionalImportMessage == null ) {
3260 this.f_optionalImportMessage = new com.google.protobuf.test.UnittestImport.ImportMessage();
3261 }
3262 return this.f_optionalImportMessage;
3263 }
3264
3265 public T setOptionalImportMessage(com.google.protobuf.test.UnittestImport.ImportMessage optionalImportMessage) {
3266 loadAndClear();
3267 this.f_optionalImportMessage = optionalImportMessage;
3268 return (T)this;
3269 }
3270
3271 public void clearOptionalImportMessage() {
3272 loadAndClear();
3273 this.f_optionalImportMessage = null;
3274 }
3275
3276 // optional NestedEnum optional_nested_enum = 21;
3277 private TestAllTypes.NestedEnum f_optionalNestedEnum = null;
3278 private boolean b_optionalNestedEnum;
3279
3280 public boolean hasOptionalNestedEnum() {
3281 return this.b_optionalNestedEnum;
3282 }
3283
3284 public TestAllTypes.NestedEnum getOptionalNestedEnum() {
3285 return this.f_optionalNestedEnum;
3286 }
3287
3288 public T setOptionalNestedEnum(TestAllTypes.NestedEnum optionalNestedEnum) {
3289 loadAndClear();
3290 this.b_optionalNestedEnum = true;
3291 this.f_optionalNestedEnum = optionalNestedEnum;
3292 return (T)this;
3293 }
3294
3295 public void clearOptionalNestedEnum() {
3296 loadAndClear();
3297 this.b_optionalNestedEnum = false;
3298 this.f_optionalNestedEnum = null;
3299 }
3300
3301 // optional ForeignEnum optional_foreign_enum = 22;
3302 private ForeignEnum f_optionalForeignEnum = null;
3303 private boolean b_optionalForeignEnum;
3304
3305 public boolean hasOptionalForeignEnum() {
3306 return this.b_optionalForeignEnum;
3307 }
3308
3309 public ForeignEnum getOptionalForeignEnum() {
3310 return this.f_optionalForeignEnum;
3311 }
3312
3313 public T setOptionalForeignEnum(ForeignEnum optionalForeignEnum) {
3314 loadAndClear();
3315 this.b_optionalForeignEnum = true;
3316 this.f_optionalForeignEnum = optionalForeignEnum;
3317 return (T)this;
3318 }
3319
3320 public void clearOptionalForeignEnum() {
3321 loadAndClear();
3322 this.b_optionalForeignEnum = false;
3323 this.f_optionalForeignEnum = null;
3324 }
3325
3326 // optional protobuf_unittest_import.ImportEnum optional_import_enum = 23;
3327 private com.google.protobuf.test.UnittestImport.ImportEnum f_optionalImportEnum = null;
3328 private boolean b_optionalImportEnum;
3329
3330 public boolean hasOptionalImportEnum() {
3331 return this.b_optionalImportEnum;
3332 }
3333
3334 public com.google.protobuf.test.UnittestImport.ImportEnum getOptionalImportEnum() {
3335 return this.f_optionalImportEnum;
3336 }
3337
3338 public T setOptionalImportEnum(com.google.protobuf.test.UnittestImport.ImportEnum optionalImportEnum) {
3339 loadAndClear();
3340 this.b_optionalImportEnum = true;
3341 this.f_optionalImportEnum = optionalImportEnum;
3342 return (T)this;
3343 }
3344
3345 public void clearOptionalImportEnum() {
3346 loadAndClear();
3347 this.b_optionalImportEnum = false;
3348 this.f_optionalImportEnum = null;
3349 }
3350
3351 // optional string optional_string_piece = 24;
3352 private java.lang.String f_optionalStringPiece = null;
3353 private boolean b_optionalStringPiece;
3354
3355 public boolean hasOptionalStringPiece() {
3356 return this.b_optionalStringPiece;
3357 }
3358
3359 public java.lang.String getOptionalStringPiece() {
3360 return this.f_optionalStringPiece;
3361 }
3362
3363 public T setOptionalStringPiece(java.lang.String optionalStringPiece) {
3364 loadAndClear();
3365 this.b_optionalStringPiece = true;
3366 this.f_optionalStringPiece = optionalStringPiece;
3367 return (T)this;
3368 }
3369
3370 public void clearOptionalStringPiece() {
3371 loadAndClear();
3372 this.b_optionalStringPiece = false;
3373 this.f_optionalStringPiece = null;
3374 }
3375
3376 // optional string optional_cord = 25;
3377 private java.lang.String f_optionalCord = null;
3378 private boolean b_optionalCord;
3379
3380 public boolean hasOptionalCord() {
3381 return this.b_optionalCord;
3382 }
3383
3384 public java.lang.String getOptionalCord() {
3385 return this.f_optionalCord;
3386 }
3387
3388 public T setOptionalCord(java.lang.String optionalCord) {
3389 loadAndClear();
3390 this.b_optionalCord = true;
3391 this.f_optionalCord = optionalCord;
3392 return (T)this;
3393 }
3394
3395 public void clearOptionalCord() {
3396 loadAndClear();
3397 this.b_optionalCord = false;
3398 this.f_optionalCord = null;
3399 }
3400
3401 // repeated int32 repeated_int32 = 31;
3402 private java.util.List<java.lang.Integer> f_repeatedInt32;
3403
3404 public boolean hasRepeatedInt32() {
3405 return this.f_repeatedInt32!=null && !this.f_repeatedInt32.isEmpty();
3406 }
3407
3408 public java.util.List<java.lang.Integer> getRepeatedInt32List() {
3409 if( this.f_repeatedInt32 == null ) {
3410 this.f_repeatedInt32 = new java.util.ArrayList<java.lang.Integer>();
3411 }
3412 return this.f_repeatedInt32;
3413 }
3414
3415 public T setRepeatedInt32List(java.util.List<java.lang.Integer> repeatedInt32) {
3416 loadAndClear();
3417 this.f_repeatedInt32 = repeatedInt32;
3418 return (T)this;
3419 }
3420
3421 public int getRepeatedInt32Count() {
3422 if( this.f_repeatedInt32 == null ) {
3423 return 0;
3424 }
3425 return this.f_repeatedInt32.size();
3426 }
3427
3428 public java.lang.Integer getRepeatedInt32(int index) {
3429 if( this.f_repeatedInt32 == null ) {
3430 return null;
3431 }
3432 return this.f_repeatedInt32.get(index);
3433 }
3434
3435 public T setRepeatedInt32(int index, java.lang.Integer value) {
3436 loadAndClear();
3437 getRepeatedInt32List().set(index, value);
3438 return (T)this;
3439 }
3440
3441 public T addRepeatedInt32(java.lang.Integer value) {
3442 loadAndClear();
3443 getRepeatedInt32List().add(value);
3444 return (T)this;
3445 }
3446
3447 public T addAllRepeatedInt32(java.lang.Iterable<? extends java.lang.Integer> collection) {
3448 loadAndClear();
3449 super.addAll(collection, getRepeatedInt32List());
3450 return (T)this;
3451 }
3452
3453 public void clearRepeatedInt32() {
3454 loadAndClear();
3455 this.f_repeatedInt32 = null;
3456 }
3457
3458 // repeated int64 repeated_int64 = 32;
3459 private java.util.List<java.lang.Long> f_repeatedInt64;
3460
3461 public boolean hasRepeatedInt64() {
3462 return this.f_repeatedInt64!=null && !this.f_repeatedInt64.isEmpty();
3463 }
3464
3465 public java.util.List<java.lang.Long> getRepeatedInt64List() {
3466 if( this.f_repeatedInt64 == null ) {
3467 this.f_repeatedInt64 = new java.util.ArrayList<java.lang.Long>();
3468 }
3469 return this.f_repeatedInt64;
3470 }
3471
3472 public T setRepeatedInt64List(java.util.List<java.lang.Long> repeatedInt64) {
3473 loadAndClear();
3474 this.f_repeatedInt64 = repeatedInt64;
3475 return (T)this;
3476 }
3477
3478 public int getRepeatedInt64Count() {
3479 if( this.f_repeatedInt64 == null ) {
3480 return 0;
3481 }
3482 return this.f_repeatedInt64.size();
3483 }
3484
3485 public java.lang.Long getRepeatedInt64(int index) {
3486 if( this.f_repeatedInt64 == null ) {
3487 return null;
3488 }
3489 return this.f_repeatedInt64.get(index);
3490 }
3491
3492 public T setRepeatedInt64(int index, java.lang.Long value) {
3493 loadAndClear();
3494 getRepeatedInt64List().set(index, value);
3495 return (T)this;
3496 }
3497
3498 public T addRepeatedInt64(java.lang.Long value) {
3499 loadAndClear();
3500 getRepeatedInt64List().add(value);
3501 return (T)this;
3502 }
3503
3504 public T addAllRepeatedInt64(java.lang.Iterable<? extends java.lang.Long> collection) {
3505 loadAndClear();
3506 super.addAll(collection, getRepeatedInt64List());
3507 return (T)this;
3508 }
3509
3510 public void clearRepeatedInt64() {
3511 loadAndClear();
3512 this.f_repeatedInt64 = null;
3513 }
3514
3515 // repeated uint32 repeated_uint32 = 33;
3516 private java.util.List<java.lang.Integer> f_repeatedUint32;
3517
3518 public boolean hasRepeatedUint32() {
3519 return this.f_repeatedUint32!=null && !this.f_repeatedUint32.isEmpty();
3520 }
3521
3522 public java.util.List<java.lang.Integer> getRepeatedUint32List() {
3523 if( this.f_repeatedUint32 == null ) {
3524 this.f_repeatedUint32 = new java.util.ArrayList<java.lang.Integer>();
3525 }
3526 return this.f_repeatedUint32;
3527 }
3528
3529 public T setRepeatedUint32List(java.util.List<java.lang.Integer> repeatedUint32) {
3530 loadAndClear();
3531 this.f_repeatedUint32 = repeatedUint32;
3532 return (T)this;
3533 }
3534
3535 public int getRepeatedUint32Count() {
3536 if( this.f_repeatedUint32 == null ) {
3537 return 0;
3538 }
3539 return this.f_repeatedUint32.size();
3540 }
3541
3542 public java.lang.Integer getRepeatedUint32(int index) {
3543 if( this.f_repeatedUint32 == null ) {
3544 return null;
3545 }
3546 return this.f_repeatedUint32.get(index);
3547 }
3548
3549 public T setRepeatedUint32(int index, java.lang.Integer value) {
3550 loadAndClear();
3551 getRepeatedUint32List().set(index, value);
3552 return (T)this;
3553 }
3554
3555 public T addRepeatedUint32(java.lang.Integer value) {
3556 loadAndClear();
3557 getRepeatedUint32List().add(value);
3558 return (T)this;
3559 }
3560
3561 public T addAllRepeatedUint32(java.lang.Iterable<? extends java.lang.Integer> collection) {
3562 loadAndClear();
3563 super.addAll(collection, getRepeatedUint32List());
3564 return (T)this;
3565 }
3566
3567 public void clearRepeatedUint32() {
3568 loadAndClear();
3569 this.f_repeatedUint32 = null;
3570 }
3571
3572 // repeated uint64 repeated_uint64 = 34;
3573 private java.util.List<java.lang.Long> f_repeatedUint64;
3574
3575 public boolean hasRepeatedUint64() {
3576 return this.f_repeatedUint64!=null && !this.f_repeatedUint64.isEmpty();
3577 }
3578
3579 public java.util.List<java.lang.Long> getRepeatedUint64List() {
3580 if( this.f_repeatedUint64 == null ) {
3581 this.f_repeatedUint64 = new java.util.ArrayList<java.lang.Long>();
3582 }
3583 return this.f_repeatedUint64;
3584 }
3585
3586 public T setRepeatedUint64List(java.util.List<java.lang.Long> repeatedUint64) {
3587 loadAndClear();
3588 this.f_repeatedUint64 = repeatedUint64;
3589 return (T)this;
3590 }
3591
3592 public int getRepeatedUint64Count() {
3593 if( this.f_repeatedUint64 == null ) {
3594 return 0;
3595 }
3596 return this.f_repeatedUint64.size();
3597 }
3598
3599 public java.lang.Long getRepeatedUint64(int index) {
3600 if( this.f_repeatedUint64 == null ) {
3601 return null;
3602 }
3603 return this.f_repeatedUint64.get(index);
3604 }
3605
3606 public T setRepeatedUint64(int index, java.lang.Long value) {
3607 loadAndClear();
3608 getRepeatedUint64List().set(index, value);
3609 return (T)this;
3610 }
3611
3612 public T addRepeatedUint64(java.lang.Long value) {
3613 loadAndClear();
3614 getRepeatedUint64List().add(value);
3615 return (T)this;
3616 }
3617
3618 public T addAllRepeatedUint64(java.lang.Iterable<? extends java.lang.Long> collection) {
3619 loadAndClear();
3620 super.addAll(collection, getRepeatedUint64List());
3621 return (T)this;
3622 }
3623
3624 public void clearRepeatedUint64() {
3625 loadAndClear();
3626 this.f_repeatedUint64 = null;
3627 }
3628
3629 // repeated sint32 repeated_sint32 = 35;
3630 private java.util.List<java.lang.Integer> f_repeatedSint32;
3631
3632 public boolean hasRepeatedSint32() {
3633 return this.f_repeatedSint32!=null && !this.f_repeatedSint32.isEmpty();
3634 }
3635
3636 public java.util.List<java.lang.Integer> getRepeatedSint32List() {
3637 if( this.f_repeatedSint32 == null ) {
3638 this.f_repeatedSint32 = new java.util.ArrayList<java.lang.Integer>();
3639 }
3640 return this.f_repeatedSint32;
3641 }
3642
3643 public T setRepeatedSint32List(java.util.List<java.lang.Integer> repeatedSint32) {
3644 loadAndClear();
3645 this.f_repeatedSint32 = repeatedSint32;
3646 return (T)this;
3647 }
3648
3649 public int getRepeatedSint32Count() {
3650 if( this.f_repeatedSint32 == null ) {
3651 return 0;
3652 }
3653 return this.f_repeatedSint32.size();
3654 }
3655
3656 public java.lang.Integer getRepeatedSint32(int index) {
3657 if( this.f_repeatedSint32 == null ) {
3658 return null;
3659 }
3660 return this.f_repeatedSint32.get(index);
3661 }
3662
3663 public T setRepeatedSint32(int index, java.lang.Integer value) {
3664 loadAndClear();
3665 getRepeatedSint32List().set(index, value);
3666 return (T)this;
3667 }
3668
3669 public T addRepeatedSint32(java.lang.Integer value) {
3670 loadAndClear();
3671 getRepeatedSint32List().add(value);
3672 return (T)this;
3673 }
3674
3675 public T addAllRepeatedSint32(java.lang.Iterable<? extends java.lang.Integer> collection) {
3676 loadAndClear();
3677 super.addAll(collection, getRepeatedSint32List());
3678 return (T)this;
3679 }
3680
3681 public void clearRepeatedSint32() {
3682 loadAndClear();
3683 this.f_repeatedSint32 = null;
3684 }
3685
3686 // repeated sint64 repeated_sint64 = 36;
3687 private java.util.List<java.lang.Long> f_repeatedSint64;
3688
3689 public boolean hasRepeatedSint64() {
3690 return this.f_repeatedSint64!=null && !this.f_repeatedSint64.isEmpty();
3691 }
3692
3693 public java.util.List<java.lang.Long> getRepeatedSint64List() {
3694 if( this.f_repeatedSint64 == null ) {
3695 this.f_repeatedSint64 = new java.util.ArrayList<java.lang.Long>();
3696 }
3697 return this.f_repeatedSint64;
3698 }
3699
3700 public T setRepeatedSint64List(java.util.List<java.lang.Long> repeatedSint64) {
3701 loadAndClear();
3702 this.f_repeatedSint64 = repeatedSint64;
3703 return (T)this;
3704 }
3705
3706 public int getRepeatedSint64Count() {
3707 if( this.f_repeatedSint64 == null ) {
3708 return 0;
3709 }
3710 return this.f_repeatedSint64.size();
3711 }
3712
3713 public java.lang.Long getRepeatedSint64(int index) {
3714 if( this.f_repeatedSint64 == null ) {
3715 return null;
3716 }
3717 return this.f_repeatedSint64.get(index);
3718 }
3719
3720 public T setRepeatedSint64(int index, java.lang.Long value) {
3721 loadAndClear();
3722 getRepeatedSint64List().set(index, value);
3723 return (T)this;
3724 }
3725
3726 public T addRepeatedSint64(java.lang.Long value) {
3727 loadAndClear();
3728 getRepeatedSint64List().add(value);
3729 return (T)this;
3730 }
3731
3732 public T addAllRepeatedSint64(java.lang.Iterable<? extends java.lang.Long> collection) {
3733 loadAndClear();
3734 super.addAll(collection, getRepeatedSint64List());
3735 return (T)this;
3736 }
3737
3738 public void clearRepeatedSint64() {
3739 loadAndClear();
3740 this.f_repeatedSint64 = null;
3741 }
3742
3743 // repeated fixed32 repeated_fixed32 = 37;
3744 private java.util.List<java.lang.Integer> f_repeatedFixed32;
3745
3746 public boolean hasRepeatedFixed32() {
3747 return this.f_repeatedFixed32!=null && !this.f_repeatedFixed32.isEmpty();
3748 }
3749
3750 public java.util.List<java.lang.Integer> getRepeatedFixed32List() {
3751 if( this.f_repeatedFixed32 == null ) {
3752 this.f_repeatedFixed32 = new java.util.ArrayList<java.lang.Integer>();
3753 }
3754 return this.f_repeatedFixed32;
3755 }
3756
3757 public T setRepeatedFixed32List(java.util.List<java.lang.Integer> repeatedFixed32) {
3758 loadAndClear();
3759 this.f_repeatedFixed32 = repeatedFixed32;
3760 return (T)this;
3761 }
3762
3763 public int getRepeatedFixed32Count() {
3764 if( this.f_repeatedFixed32 == null ) {
3765 return 0;
3766 }
3767 return this.f_repeatedFixed32.size();
3768 }
3769
3770 public java.lang.Integer getRepeatedFixed32(int index) {
3771 if( this.f_repeatedFixed32 == null ) {
3772 return null;
3773 }
3774 return this.f_repeatedFixed32.get(index);
3775 }
3776
3777 public T setRepeatedFixed32(int index, java.lang.Integer value) {
3778 loadAndClear();
3779 getRepeatedFixed32List().set(index, value);
3780 return (T)this;
3781 }
3782
3783 public T addRepeatedFixed32(java.lang.Integer value) {
3784 loadAndClear();
3785 getRepeatedFixed32List().add(value);
3786 return (T)this;
3787 }
3788
3789 public T addAllRepeatedFixed32(java.lang.Iterable<? extends java.lang.Integer> collection) {
3790 loadAndClear();
3791 super.addAll(collection, getRepeatedFixed32List());
3792 return (T)this;
3793 }
3794
3795 public void clearRepeatedFixed32() {
3796 loadAndClear();
3797 this.f_repeatedFixed32 = null;
3798 }
3799
3800 // repeated fixed64 repeated_fixed64 = 38;
3801 private java.util.List<java.lang.Long> f_repeatedFixed64;
3802
3803 public boolean hasRepeatedFixed64() {
3804 return this.f_repeatedFixed64!=null && !this.f_repeatedFixed64.isEmpty();
3805 }
3806
3807 public java.util.List<java.lang.Long> getRepeatedFixed64List() {
3808 if( this.f_repeatedFixed64 == null ) {
3809 this.f_repeatedFixed64 = new java.util.ArrayList<java.lang.Long>();
3810 }
3811 return this.f_repeatedFixed64;
3812 }
3813
3814 public T setRepeatedFixed64List(java.util.List<java.lang.Long> repeatedFixed64) {
3815 loadAndClear();
3816 this.f_repeatedFixed64 = repeatedFixed64;
3817 return (T)this;
3818 }
3819
3820 public int getRepeatedFixed64Count() {
3821 if( this.f_repeatedFixed64 == null ) {
3822 return 0;
3823 }
3824 return this.f_repeatedFixed64.size();
3825 }
3826
3827 public java.lang.Long getRepeatedFixed64(int index) {
3828 if( this.f_repeatedFixed64 == null ) {
3829 return null;
3830 }
3831 return this.f_repeatedFixed64.get(index);
3832 }
3833
3834 public T setRepeatedFixed64(int index, java.lang.Long value) {
3835 loadAndClear();
3836 getRepeatedFixed64List().set(index, value);
3837 return (T)this;
3838 }
3839
3840 public T addRepeatedFixed64(java.lang.Long value) {
3841 loadAndClear();
3842 getRepeatedFixed64List().add(value);
3843 return (T)this;
3844 }
3845
3846 public T addAllRepeatedFixed64(java.lang.Iterable<? extends java.lang.Long> collection) {
3847 loadAndClear();
3848 super.addAll(collection, getRepeatedFixed64List());
3849 return (T)this;
3850 }
3851
3852 public void clearRepeatedFixed64() {
3853 loadAndClear();
3854 this.f_repeatedFixed64 = null;
3855 }
3856
3857 // repeated sfixed32 repeated_sfixed32 = 39;
3858 private java.util.List<java.lang.Integer> f_repeatedSfixed32;
3859
3860 public boolean hasRepeatedSfixed32() {
3861 return this.f_repeatedSfixed32!=null && !this.f_repeatedSfixed32.isEmpty();
3862 }
3863
3864 public java.util.List<java.lang.Integer> getRepeatedSfixed32List() {
3865 if( this.f_repeatedSfixed32 == null ) {
3866 this.f_repeatedSfixed32 = new java.util.ArrayList<java.lang.Integer>();
3867 }
3868 return this.f_repeatedSfixed32;
3869 }
3870
3871 public T setRepeatedSfixed32List(java.util.List<java.lang.Integer> repeatedSfixed32) {
3872 loadAndClear();
3873 this.f_repeatedSfixed32 = repeatedSfixed32;
3874 return (T)this;
3875 }
3876
3877 public int getRepeatedSfixed32Count() {
3878 if( this.f_repeatedSfixed32 == null ) {
3879 return 0;
3880 }
3881 return this.f_repeatedSfixed32.size();
3882 }
3883
3884 public java.lang.Integer getRepeatedSfixed32(int index) {
3885 if( this.f_repeatedSfixed32 == null ) {
3886 return null;
3887 }
3888 return this.f_repeatedSfixed32.get(index);
3889 }
3890
3891 public T setRepeatedSfixed32(int index, java.lang.Integer value) {
3892 loadAndClear();
3893 getRepeatedSfixed32List().set(index, value);
3894 return (T)this;
3895 }
3896
3897 public T addRepeatedSfixed32(java.lang.Integer value) {
3898 loadAndClear();
3899 getRepeatedSfixed32List().add(value);
3900 return (T)this;
3901 }
3902
3903 public T addAllRepeatedSfixed32(java.lang.Iterable<? extends java.lang.Integer> collection) {
3904 loadAndClear();
3905 super.addAll(collection, getRepeatedSfixed32List());
3906 return (T)this;
3907 }
3908
3909 public void clearRepeatedSfixed32() {
3910 loadAndClear();
3911 this.f_repeatedSfixed32 = null;
3912 }
3913
3914 // repeated sfixed64 repeated_sfixed64 = 40;
3915 private java.util.List<java.lang.Long> f_repeatedSfixed64;
3916
3917 public boolean hasRepeatedSfixed64() {
3918 return this.f_repeatedSfixed64!=null && !this.f_repeatedSfixed64.isEmpty();
3919 }
3920
3921 public java.util.List<java.lang.Long> getRepeatedSfixed64List() {
3922 if( this.f_repeatedSfixed64 == null ) {
3923 this.f_repeatedSfixed64 = new java.util.ArrayList<java.lang.Long>();
3924 }
3925 return this.f_repeatedSfixed64;
3926 }
3927
3928 public T setRepeatedSfixed64List(java.util.List<java.lang.Long> repeatedSfixed64) {
3929 loadAndClear();
3930 this.f_repeatedSfixed64 = repeatedSfixed64;
3931 return (T)this;
3932 }
3933
3934 public int getRepeatedSfixed64Count() {
3935 if( this.f_repeatedSfixed64 == null ) {
3936 return 0;
3937 }
3938 return this.f_repeatedSfixed64.size();
3939 }
3940
3941 public java.lang.Long getRepeatedSfixed64(int index) {
3942 if( this.f_repeatedSfixed64 == null ) {
3943 return null;
3944 }
3945 return this.f_repeatedSfixed64.get(index);
3946 }
3947
3948 public T setRepeatedSfixed64(int index, java.lang.Long value) {
3949 loadAndClear();
3950 getRepeatedSfixed64List().set(index, value);
3951 return (T)this;
3952 }
3953
3954 public T addRepeatedSfixed64(java.lang.Long value) {
3955 loadAndClear();
3956 getRepeatedSfixed64List().add(value);
3957 return (T)this;
3958 }
3959
3960 public T addAllRepeatedSfixed64(java.lang.Iterable<? extends java.lang.Long> collection) {
3961 loadAndClear();
3962 super.addAll(collection, getRepeatedSfixed64List());
3963 return (T)this;
3964 }
3965
3966 public void clearRepeatedSfixed64() {
3967 loadAndClear();
3968 this.f_repeatedSfixed64 = null;
3969 }
3970
3971 // repeated float repeated_float = 41;
3972 private java.util.List<java.lang.Float> f_repeatedFloat;
3973
3974 public boolean hasRepeatedFloat() {
3975 return this.f_repeatedFloat!=null && !this.f_repeatedFloat.isEmpty();
3976 }
3977
3978 public java.util.List<java.lang.Float> getRepeatedFloatList() {
3979 if( this.f_repeatedFloat == null ) {
3980 this.f_repeatedFloat = new java.util.ArrayList<java.lang.Float>();
3981 }
3982 return this.f_repeatedFloat;
3983 }
3984
3985 public T setRepeatedFloatList(java.util.List<java.lang.Float> repeatedFloat) {
3986 loadAndClear();
3987 this.f_repeatedFloat = repeatedFloat;
3988 return (T)this;
3989 }
3990
3991 public int getRepeatedFloatCount() {
3992 if( this.f_repeatedFloat == null ) {
3993 return 0;
3994 }
3995 return this.f_repeatedFloat.size();
3996 }
3997
3998 public java.lang.Float getRepeatedFloat(int index) {
3999 if( this.f_repeatedFloat == null ) {
4000 return null;
4001 }
4002 return this.f_repeatedFloat.get(index);
4003 }
4004
4005 public T setRepeatedFloat(int index, java.lang.Float value) {
4006 loadAndClear();
4007 getRepeatedFloatList().set(index, value);
4008 return (T)this;
4009 }
4010
4011 public T addRepeatedFloat(java.lang.Float value) {
4012 loadAndClear();
4013 getRepeatedFloatList().add(value);
4014 return (T)this;
4015 }
4016
4017 public T addAllRepeatedFloat(java.lang.Iterable<? extends java.lang.Float> collection) {
4018 loadAndClear();
4019 super.addAll(collection, getRepeatedFloatList());
4020 return (T)this;
4021 }
4022
4023 public void clearRepeatedFloat() {
4024 loadAndClear();
4025 this.f_repeatedFloat = null;
4026 }
4027
4028 // repeated double repeated_double = 42;
4029 private java.util.List<java.lang.Double> f_repeatedDouble;
4030
4031 public boolean hasRepeatedDouble() {
4032 return this.f_repeatedDouble!=null && !this.f_repeatedDouble.isEmpty();
4033 }
4034
4035 public java.util.List<java.lang.Double> getRepeatedDoubleList() {
4036 if( this.f_repeatedDouble == null ) {
4037 this.f_repeatedDouble = new java.util.ArrayList<java.lang.Double>();
4038 }
4039 return this.f_repeatedDouble;
4040 }
4041
4042 public T setRepeatedDoubleList(java.util.List<java.lang.Double> repeatedDouble) {
4043 loadAndClear();
4044 this.f_repeatedDouble = repeatedDouble;
4045 return (T)this;
4046 }
4047
4048 public int getRepeatedDoubleCount() {
4049 if( this.f_repeatedDouble == null ) {
4050 return 0;
4051 }
4052 return this.f_repeatedDouble.size();
4053 }
4054
4055 public java.lang.Double getRepeatedDouble(int index) {
4056 if( this.f_repeatedDouble == null ) {
4057 return null;
4058 }
4059 return this.f_repeatedDouble.get(index);
4060 }
4061
4062 public T setRepeatedDouble(int index, java.lang.Double value) {
4063 loadAndClear();
4064 getRepeatedDoubleList().set(index, value);
4065 return (T)this;
4066 }
4067
4068 public T addRepeatedDouble(java.lang.Double value) {
4069 loadAndClear();
4070 getRepeatedDoubleList().add(value);
4071 return (T)this;
4072 }
4073
4074 public T addAllRepeatedDouble(java.lang.Iterable<? extends java.lang.Double> collection) {
4075 loadAndClear();
4076 super.addAll(collection, getRepeatedDoubleList());
4077 return (T)this;
4078 }
4079
4080 public void clearRepeatedDouble() {
4081 loadAndClear();
4082 this.f_repeatedDouble = null;
4083 }
4084
4085 // repeated bool repeated_bool = 43;
4086 private java.util.List<java.lang.Boolean> f_repeatedBool;
4087
4088 public boolean hasRepeatedBool() {
4089 return this.f_repeatedBool!=null && !this.f_repeatedBool.isEmpty();
4090 }
4091
4092 public java.util.List<java.lang.Boolean> getRepeatedBoolList() {
4093 if( this.f_repeatedBool == null ) {
4094 this.f_repeatedBool = new java.util.ArrayList<java.lang.Boolean>();
4095 }
4096 return this.f_repeatedBool;
4097 }
4098
4099 public T setRepeatedBoolList(java.util.List<java.lang.Boolean> repeatedBool) {
4100 loadAndClear();
4101 this.f_repeatedBool = repeatedBool;
4102 return (T)this;
4103 }
4104
4105 public int getRepeatedBoolCount() {
4106 if( this.f_repeatedBool == null ) {
4107 return 0;
4108 }
4109 return this.f_repeatedBool.size();
4110 }
4111
4112 public java.lang.Boolean getRepeatedBool(int index) {
4113 if( this.f_repeatedBool == null ) {
4114 return null;
4115 }
4116 return this.f_repeatedBool.get(index);
4117 }
4118
4119 public T setRepeatedBool(int index, java.lang.Boolean value) {
4120 loadAndClear();
4121 getRepeatedBoolList().set(index, value);
4122 return (T)this;
4123 }
4124
4125 public T addRepeatedBool(java.lang.Boolean value) {
4126 loadAndClear();
4127 getRepeatedBoolList().add(value);
4128 return (T)this;
4129 }
4130
4131 public T addAllRepeatedBool(java.lang.Iterable<? extends java.lang.Boolean> collection) {
4132 loadAndClear();
4133 super.addAll(collection, getRepeatedBoolList());
4134 return (T)this;
4135 }
4136
4137 public void clearRepeatedBool() {
4138 loadAndClear();
4139 this.f_repeatedBool = null;
4140 }
4141
4142 // repeated string repeated_string = 44;
4143 private java.util.List<java.lang.String> f_repeatedString;
4144
4145 public boolean hasRepeatedString() {
4146 return this.f_repeatedString!=null && !this.f_repeatedString.isEmpty();
4147 }
4148
4149 public java.util.List<java.lang.String> getRepeatedStringList() {
4150 if( this.f_repeatedString == null ) {
4151 this.f_repeatedString = new java.util.ArrayList<java.lang.String>();
4152 }
4153 return this.f_repeatedString;
4154 }
4155
4156 public T setRepeatedStringList(java.util.List<java.lang.String> repeatedString) {
4157 loadAndClear();
4158 this.f_repeatedString = repeatedString;
4159 return (T)this;
4160 }
4161
4162 public int getRepeatedStringCount() {
4163 if( this.f_repeatedString == null ) {
4164 return 0;
4165 }
4166 return this.f_repeatedString.size();
4167 }
4168
4169 public java.lang.String getRepeatedString(int index) {
4170 if( this.f_repeatedString == null ) {
4171 return null;
4172 }
4173 return this.f_repeatedString.get(index);
4174 }
4175
4176 public T setRepeatedString(int index, java.lang.String value) {
4177 loadAndClear();
4178 getRepeatedStringList().set(index, value);
4179 return (T)this;
4180 }
4181
4182 public T addRepeatedString(java.lang.String value) {
4183 loadAndClear();
4184 getRepeatedStringList().add(value);
4185 return (T)this;
4186 }
4187
4188 public T addAllRepeatedString(java.lang.Iterable<? extends java.lang.String> collection) {
4189 loadAndClear();
4190 super.addAll(collection, getRepeatedStringList());
4191 return (T)this;
4192 }
4193
4194 public void clearRepeatedString() {
4195 loadAndClear();
4196 this.f_repeatedString = null;
4197 }
4198
4199 // repeated bytes repeated_bytes = 45;
4200 private java.util.List<org.apache.activemq.protobuf.Buffer> f_repeatedBytes;
4201
4202 public boolean hasRepeatedBytes() {
4203 return this.f_repeatedBytes!=null && !this.f_repeatedBytes.isEmpty();
4204 }
4205
4206 public java.util.List<org.apache.activemq.protobuf.Buffer> getRepeatedBytesList() {
4207 if( this.f_repeatedBytes == null ) {
4208 this.f_repeatedBytes = new java.util.ArrayList<org.apache.activemq.protobuf.Buffer>();
4209 }
4210 return this.f_repeatedBytes;
4211 }
4212
4213 public T setRepeatedBytesList(java.util.List<org.apache.activemq.protobuf.Buffer> repeatedBytes) {
4214 loadAndClear();
4215 this.f_repeatedBytes = repeatedBytes;
4216 return (T)this;
4217 }
4218
4219 public int getRepeatedBytesCount() {
4220 if( this.f_repeatedBytes == null ) {
4221 return 0;
4222 }
4223 return this.f_repeatedBytes.size();
4224 }
4225
4226 public org.apache.activemq.protobuf.Buffer getRepeatedBytes(int index) {
4227 if( this.f_repeatedBytes == null ) {
4228 return null;
4229 }
4230 return this.f_repeatedBytes.get(index);
4231 }
4232
4233 public T setRepeatedBytes(int index, org.apache.activemq.protobuf.Buffer value) {
4234 loadAndClear();
4235 getRepeatedBytesList().set(index, value);
4236 return (T)this;
4237 }
4238
4239 public T addRepeatedBytes(org.apache.activemq.protobuf.Buffer value) {
4240 loadAndClear();
4241 getRepeatedBytesList().add(value);
4242 return (T)this;
4243 }
4244
4245 public T addAllRepeatedBytes(java.lang.Iterable<? extends org.apache.activemq.protobuf.Buffer> collection) {
4246 loadAndClear();
4247 super.addAll(collection, getRepeatedBytesList());
4248 return (T)this;
4249 }
4250
4251 public void clearRepeatedBytes() {
4252 loadAndClear();
4253 this.f_repeatedBytes = null;
4254 }
4255
4256 // repeated RepeatedGroup RepeatedGroup = 46;
4257 private java.util.List<TestAllTypes.RepeatedGroup> f_repeatedGroup;
4258
4259 public boolean hasRepeatedGroup() {
4260 return this.f_repeatedGroup!=null && !this.f_repeatedGroup.isEmpty();
4261 }
4262
4263 public java.util.List<TestAllTypes.RepeatedGroup> getRepeatedGroupList() {
4264 if( this.f_repeatedGroup == null ) {
4265 this.f_repeatedGroup = new java.util.ArrayList<TestAllTypes.RepeatedGroup>();
4266 }
4267 return this.f_repeatedGroup;
4268 }
4269
4270 public T setRepeatedGroupList(java.util.List<TestAllTypes.RepeatedGroup> repeatedGroup) {
4271 loadAndClear();
4272 this.f_repeatedGroup = repeatedGroup;
4273 return (T)this;
4274 }
4275
4276 public int getRepeatedGroupCount() {
4277 if( this.f_repeatedGroup == null ) {
4278 return 0;
4279 }
4280 return this.f_repeatedGroup.size();
4281 }
4282
4283 public TestAllTypes.RepeatedGroup getRepeatedGroup(int index) {
4284 if( this.f_repeatedGroup == null ) {
4285 return null;
4286 }
4287 return this.f_repeatedGroup.get(index);
4288 }
4289
4290 public T setRepeatedGroup(int index, TestAllTypes.RepeatedGroup value) {
4291 loadAndClear();
4292 getRepeatedGroupList().set(index, value);
4293 return (T)this;
4294 }
4295
4296 public T addRepeatedGroup(TestAllTypes.RepeatedGroup value) {
4297 loadAndClear();
4298 getRepeatedGroupList().add(value);
4299 return (T)this;
4300 }
4301
4302 public T addAllRepeatedGroup(java.lang.Iterable<? extends TestAllTypes.RepeatedGroup> collection) {
4303 loadAndClear();
4304 super.addAll(collection, getRepeatedGroupList());
4305 return (T)this;
4306 }
4307
4308 public void clearRepeatedGroup() {
4309 loadAndClear();
4310 this.f_repeatedGroup = null;
4311 }
4312
4313 // repeated NestedMessage repeated_nested_message = 48;
4314 private java.util.List<TestAllTypes.NestedMessage> f_repeatedNestedMessage;
4315
4316 public boolean hasRepeatedNestedMessage() {
4317 return this.f_repeatedNestedMessage!=null && !this.f_repeatedNestedMessage.isEmpty();
4318 }
4319
4320 public java.util.List<TestAllTypes.NestedMessage> getRepeatedNestedMessageList() {
4321 if( this.f_repeatedNestedMessage == null ) {
4322 this.f_repeatedNestedMessage = new java.util.ArrayList<TestAllTypes.NestedMessage>();
4323 }
4324 return this.f_repeatedNestedMessage;
4325 }
4326
4327 public T setRepeatedNestedMessageList(java.util.List<TestAllTypes.NestedMessage> repeatedNestedMessage) {
4328 loadAndClear();
4329 this.f_repeatedNestedMessage = repeatedNestedMessage;
4330 return (T)this;
4331 }
4332
4333 public int getRepeatedNestedMessageCount() {
4334 if( this.f_repeatedNestedMessage == null ) {
4335 return 0;
4336 }
4337 return this.f_repeatedNestedMessage.size();
4338 }
4339
4340 public TestAllTypes.NestedMessage getRepeatedNestedMessage(int index) {
4341 if( this.f_repeatedNestedMessage == null ) {
4342 return null;
4343 }
4344 return this.f_repeatedNestedMessage.get(index);
4345 }
4346
4347 public T setRepeatedNestedMessage(int index, TestAllTypes.NestedMessage value) {
4348 loadAndClear();
4349 getRepeatedNestedMessageList().set(index, value);
4350 return (T)this;
4351 }
4352
4353 public T addRepeatedNestedMessage(TestAllTypes.NestedMessage value) {
4354 loadAndClear();
4355 getRepeatedNestedMessageList().add(value);
4356 return (T)this;
4357 }
4358
4359 public T addAllRepeatedNestedMessage(java.lang.Iterable<? extends TestAllTypes.NestedMessage> collection) {
4360 loadAndClear();
4361 super.addAll(collection, getRepeatedNestedMessageList());
4362 return (T)this;
4363 }
4364
4365 public void clearRepeatedNestedMessage() {
4366 loadAndClear();
4367 this.f_repeatedNestedMessage = null;
4368 }
4369
4370 // repeated ForeignMessage repeated_foreign_message = 49;
4371 private java.util.List<ForeignMessage> f_repeatedForeignMessage;
4372
4373 public boolean hasRepeatedForeignMessage() {
4374 return this.f_repeatedForeignMessage!=null && !this.f_repeatedForeignMessage.isEmpty();
4375 }
4376
4377 public java.util.List<ForeignMessage> getRepeatedForeignMessageList() {
4378 if( this.f_repeatedForeignMessage == null ) {
4379 this.f_repeatedForeignMessage = new java.util.ArrayList<ForeignMessage>();
4380 }
4381 return this.f_repeatedForeignMessage;
4382 }
4383
4384 public T setRepeatedForeignMessageList(java.util.List<ForeignMessage> repeatedForeignMessage) {
4385 loadAndClear();
4386 this.f_repeatedForeignMessage = repeatedForeignMessage;
4387 return (T)this;
4388 }
4389
4390 public int getRepeatedForeignMessageCount() {
4391 if( this.f_repeatedForeignMessage == null ) {
4392 return 0;
4393 }
4394 return this.f_repeatedForeignMessage.size();
4395 }
4396
4397 public ForeignMessage getRepeatedForeignMessage(int index) {
4398 if( this.f_repeatedForeignMessage == null ) {
4399 return null;
4400 }
4401 return this.f_repeatedForeignMessage.get(index);
4402 }
4403
4404 public T setRepeatedForeignMessage(int index, ForeignMessage value) {
4405 loadAndClear();
4406 getRepeatedForeignMessageList().set(index, value);
4407 return (T)this;
4408 }
4409
4410 public T addRepeatedForeignMessage(ForeignMessage value) {
4411 loadAndClear();
4412 getRepeatedForeignMessageList().add(value);
4413 return (T)this;
4414 }
4415
4416 public T addAllRepeatedForeignMessage(java.lang.Iterable<? extends ForeignMessage> collection) {
4417 loadAndClear();
4418 super.addAll(collection, getRepeatedForeignMessageList());
4419 return (T)this;
4420 }
4421
4422 public void clearRepeatedForeignMessage() {
4423 loadAndClear();
4424 this.f_repeatedForeignMessage = null;
4425 }
4426
4427 // repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50;
4428 private java.util.List<com.google.protobuf.test.UnittestImport.ImportMessage> f_repeatedImportMessage;
4429
4430 public boolean hasRepeatedImportMessage() {
4431 return this.f_repeatedImportMessage!=null && !this.f_repeatedImportMessage.isEmpty();
4432 }
4433
4434 public java.util.List<com.google.protobuf.test.UnittestImport.ImportMessage> getRepeatedImportMessageList() {
4435 if( this.f_repeatedImportMessage == null ) {
4436 this.f_repeatedImportMessage = new java.util.ArrayList<com.google.protobuf.test.UnittestImport.ImportMessage>();
4437 }
4438 return this.f_repeatedImportMessage;
4439 }
4440
4441 public T setRepeatedImportMessageList(java.util.List<com.google.protobuf.test.UnittestImport.ImportMessage> repeatedImportMessage) {
4442 loadAndClear();
4443 this.f_repeatedImportMessage = repeatedImportMessage;
4444 return (T)this;
4445 }
4446
4447 public int getRepeatedImportMessageCount() {
4448 if( this.f_repeatedImportMessage == null ) {
4449 return 0;
4450 }
4451 return this.f_repeatedImportMessage.size();
4452 }
4453
4454 public com.google.protobuf.test.UnittestImport.ImportMessage getRepeatedImportMessage(int index) {
4455 if( this.f_repeatedImportMessage == null ) {
4456 return null;
4457 }
4458 return this.f_repeatedImportMessage.get(index);
4459 }
4460
4461 public T setRepeatedImportMessage(int index, com.google.protobuf.test.UnittestImport.ImportMessage value) {
4462 loadAndClear();
4463 getRepeatedImportMessageList().set(index, value);
4464 return (T)this;
4465 }
4466
4467 public T addRepeatedImportMessage(com.google.protobuf.test.UnittestImport.ImportMessage value) {
4468 loadAndClear();
4469 getRepeatedImportMessageList().add(value);
4470 return (T)this;
4471 }
4472
4473 public T addAllRepeatedImportMessage(java.lang.Iterable<? extends com.google.protobuf.test.UnittestImport.ImportMessage> collection) {
4474 loadAndClear();
4475 super.addAll(collection, getRepeatedImportMessageList());
4476 return (T)this;
4477 }
4478
4479 public void clearRepeatedImportMessage() {
4480 loadAndClear();
4481 this.f_repeatedImportMessage = null;
4482 }
4483
4484 // repeated NestedEnum repeated_nested_enum = 51;
4485 private java.util.List<TestAllTypes.NestedEnum> f_repeatedNestedEnum;
4486
4487 public boolean hasRepeatedNestedEnum() {
4488 return this.f_repeatedNestedEnum!=null && !this.f_repeatedNestedEnum.isEmpty();
4489 }
4490
4491 public java.util.List<TestAllTypes.NestedEnum> getRepeatedNestedEnumList() {
4492 if( this.f_repeatedNestedEnum == null ) {
4493 this.f_repeatedNestedEnum = new java.util.ArrayList<TestAllTypes.NestedEnum>();
4494 }
4495 return this.f_repeatedNestedEnum;
4496 }
4497
4498 public T setRepeatedNestedEnumList(java.util.List<TestAllTypes.NestedEnum> repeatedNestedEnum) {
4499 loadAndClear();
4500 this.f_repeatedNestedEnum = repeatedNestedEnum;
4501 return (T)this;
4502 }
4503
4504 public int getRepeatedNestedEnumCount() {
4505 if( this.f_repeatedNestedEnum == null ) {
4506 return 0;
4507 }
4508 return this.f_repeatedNestedEnum.size();
4509 }
4510
4511 public TestAllTypes.NestedEnum getRepeatedNestedEnum(int index) {
4512 if( this.f_repeatedNestedEnum == null ) {
4513 return null;
4514 }
4515 return this.f_repeatedNestedEnum.get(index);
4516 }
4517
4518 public T setRepeatedNestedEnum(int index, TestAllTypes.NestedEnum value) {
4519 loadAndClear();
4520 getRepeatedNestedEnumList().set(index, value);
4521 return (T)this;
4522 }
4523
4524 public T addRepeatedNestedEnum(TestAllTypes.NestedEnum value) {
4525 loadAndClear();
4526 getRepeatedNestedEnumList().add(value);
4527 return (T)this;
4528 }
4529
4530 public T addAllRepeatedNestedEnum(java.lang.Iterable<? extends TestAllTypes.NestedEnum> collection) {
4531 loadAndClear();
4532 super.addAll(collection, getRepeatedNestedEnumList());
4533 return (T)this;
4534 }
4535
4536 public void clearRepeatedNestedEnum() {
4537 loadAndClear();
4538 this.f_repeatedNestedEnum = null;
4539 }
4540
4541 // repeated ForeignEnum repeated_foreign_enum = 52;
4542 private java.util.List<ForeignEnum> f_repeatedForeignEnum;
4543
4544 public boolean hasRepeatedForeignEnum() {
4545 return this.f_repeatedForeignEnum!=null && !this.f_repeatedForeignEnum.isEmpty();
4546 }
4547
4548 public java.util.List<ForeignEnum> getRepeatedForeignEnumList() {
4549 if( this.f_repeatedForeignEnum == null ) {
4550 this.f_repeatedForeignEnum = new java.util.ArrayList<ForeignEnum>();
4551 }
4552 return this.f_repeatedForeignEnum;
4553 }
4554
4555 public T setRepeatedForeignEnumList(java.util.List<ForeignEnum> repeatedForeignEnum) {
4556 loadAndClear();
4557 this.f_repeatedForeignEnum = repeatedForeignEnum;
4558 return (T)this;
4559 }
4560
4561 public int getRepeatedForeignEnumCount() {
4562 if( this.f_repeatedForeignEnum == null ) {
4563 return 0;
4564 }
4565 return this.f_repeatedForeignEnum.size();
4566 }
4567
4568 public ForeignEnum getRepeatedForeignEnum(int index) {
4569 if( this.f_repeatedForeignEnum == null ) {
4570 return null;
4571 }
4572 return this.f_repeatedForeignEnum.get(index);
4573 }
4574
4575 public T setRepeatedForeignEnum(int index, ForeignEnum value) {
4576 loadAndClear();
4577 getRepeatedForeignEnumList().set(index, value);
4578 return (T)this;
4579 }
4580
4581 public T addRepeatedForeignEnum(ForeignEnum value) {
4582 loadAndClear();
4583 getRepeatedForeignEnumList().add(value);
4584 return (T)this;
4585 }
4586
4587 public T addAllRepeatedForeignEnum(java.lang.Iterable<? extends ForeignEnum> collection) {
4588 loadAndClear();
4589 super.addAll(collection, getRepeatedForeignEnumList());
4590 return (T)this;
4591 }
4592
4593 public void clearRepeatedForeignEnum() {
4594 loadAndClear();
4595 this.f_repeatedForeignEnum = null;
4596 }
4597
4598 // repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53;
4599 private java.util.List<com.google.protobuf.test.UnittestImport.ImportEnum> f_repeatedImportEnum;
4600
4601 public boolean hasRepeatedImportEnum() {
4602 return this.f_repeatedImportEnum!=null && !this.f_repeatedImportEnum.isEmpty();
4603 }
4604
4605 public java.util.List<com.google.protobuf.test.UnittestImport.ImportEnum> getRepeatedImportEnumList() {
4606 if( this.f_repeatedImportEnum == null ) {
4607 this.f_repeatedImportEnum = new java.util.ArrayList<com.google.protobuf.test.UnittestImport.ImportEnum>();
4608 }
4609 return this.f_repeatedImportEnum;
4610 }
4611
4612 public T setRepeatedImportEnumList(java.util.List<com.google.protobuf.test.UnittestImport.ImportEnum> repeatedImportEnum) {
4613 loadAndClear();
4614 this.f_repeatedImportEnum = repeatedImportEnum;
4615 return (T)this;
4616 }
4617
4618 public int getRepeatedImportEnumCount() {
4619 if( this.f_repeatedImportEnum == null ) {
4620 return 0;
4621 }
4622 return this.f_repeatedImportEnum.size();
4623 }
4624
4625 public com.google.protobuf.test.UnittestImport.ImportEnum getRepeatedImportEnum(int index) {
4626 if( this.f_repeatedImportEnum == null ) {
4627 return null;
4628 }
4629 return this.f_repeatedImportEnum.get(index);
4630 }
4631
4632 public T setRepeatedImportEnum(int index, com.google.protobuf.test.UnittestImport.ImportEnum value) {
4633 loadAndClear();
4634 getRepeatedImportEnumList().set(index, value);
4635 return (T)this;
4636 }
4637
4638 public T addRepeatedImportEnum(com.google.protobuf.test.UnittestImport.ImportEnum value) {
4639 loadAndClear();
4640 getRepeatedImportEnumList().add(value);
4641 return (T)this;
4642 }
4643
4644 public T addAllRepeatedImportEnum(java.lang.Iterable<? extends com.google.protobuf.test.UnittestImport.ImportEnum> collection) {
4645 loadAndClear();
4646 super.addAll(collection, getRepeatedImportEnumList());
4647 return (T)this;
4648 }
4649
4650 public void clearRepeatedImportEnum() {
4651 loadAndClear();
4652 this.f_repeatedImportEnum = null;
4653 }
4654
4655 // repeated string repeated_string_piece = 54;
4656 private java.util.List<java.lang.String> f_repeatedStringPiece;
4657
4658 public boolean hasRepeatedStringPiece() {
4659 return this.f_repeatedStringPiece!=null && !this.f_repeatedStringPiece.isEmpty();
4660 }
4661
4662 public java.util.List<java.lang.String> getRepeatedStringPieceList() {
4663 if( this.f_repeatedStringPiece == null ) {
4664 this.f_repeatedStringPiece = new java.util.ArrayList<java.lang.String>();
4665 }
4666 return this.f_repeatedStringPiece;
4667 }
4668
4669 public T setRepeatedStringPieceList(java.util.List<java.lang.String> repeatedStringPiece) {
4670 loadAndClear();
4671 this.f_repeatedStringPiece = repeatedStringPiece;
4672 return (T)this;
4673 }
4674
4675 public int getRepeatedStringPieceCount() {
4676 if( this.f_repeatedStringPiece == null ) {
4677 return 0;
4678 }
4679 return this.f_repeatedStringPiece.size();
4680 }
4681
4682 public java.lang.String getRepeatedStringPiece(int index) {
4683 if( this.f_repeatedStringPiece == null ) {
4684 return null;
4685 }
4686 return this.f_repeatedStringPiece.get(index);
4687 }
4688
4689 public T setRepeatedStringPiece(int index, java.lang.String value) {
4690 loadAndClear();
4691 getRepeatedStringPieceList().set(index, value);
4692 return (T)this;
4693 }
4694
4695 public T addRepeatedStringPiece(java.lang.String value) {
4696 loadAndClear();
4697 getRepeatedStringPieceList().add(value);
4698 return (T)this;
4699 }
4700
4701 public T addAllRepeatedStringPiece(java.lang.Iterable<? extends java.lang.String> collection) {
4702 loadAndClear();
4703 super.addAll(collection, getRepeatedStringPieceList());
4704 return (T)this;
4705 }
4706
4707 public void clearRepeatedStringPiece() {
4708 loadAndClear();
4709 this.f_repeatedStringPiece = null;
4710 }
4711
4712 // repeated string repeated_cord = 55;
4713 private java.util.List<java.lang.String> f_repeatedCord;
4714
4715 public boolean hasRepeatedCord() {
4716 return this.f_repeatedCord!=null && !this.f_repeatedCord.isEmpty();
4717 }
4718
4719 public java.util.List<java.lang.String> getRepeatedCordList() {
4720 if( this.f_repeatedCord == null ) {
4721 this.f_repeatedCord = new java.util.ArrayList<java.lang.String>();
4722 }
4723 return this.f_repeatedCord;
4724 }
4725
4726 public T setRepeatedCordList(java.util.List<java.lang.String> repeatedCord) {
4727 loadAndClear();
4728 this.f_repeatedCord = repeatedCord;
4729 return (T)this;
4730 }
4731
4732 public int getRepeatedCordCount() {
4733 if( this.f_repeatedCord == null ) {
4734 return 0;
4735 }
4736 return this.f_repeatedCord.size();
4737 }
4738
4739 public java.lang.String getRepeatedCord(int index) {
4740 if( this.f_repeatedCord == null ) {
4741 return null;
4742 }
4743 return this.f_repeatedCord.get(index);
4744 }
4745
4746 public T setRepeatedCord(int index, java.lang.String value) {
4747 loadAndClear();
4748 getRepeatedCordList().set(index, value);
4749 return (T)this;
4750 }
4751
4752 public T addRepeatedCord(java.lang.String value) {
4753 loadAndClear();
4754 getRepeatedCordList().add(value);
4755 return (T)this;
4756 }
4757
4758 public T addAllRepeatedCord(java.lang.Iterable<? extends java.lang.String> collection) {
4759 loadAndClear();
4760 super.addAll(collection, getRepeatedCordList());
4761 return (T)this;
4762 }
4763
4764 public void clearRepeatedCord() {
4765 loadAndClear();
4766 this.f_repeatedCord = null;
4767 }
4768
4769 // optional int32 default_int32 = 61;
4770 private int f_defaultInt32 = 41;
4771 private boolean b_defaultInt32;
4772
4773 public boolean hasDefaultInt32() {
4774 return this.b_defaultInt32;
4775 }
4776
4777 public int getDefaultInt32() {
4778 return this.f_defaultInt32;
4779 }
4780
4781 public T setDefaultInt32(int defaultInt32) {
4782 loadAndClear();
4783 this.b_defaultInt32 = true;
4784 this.f_defaultInt32 = defaultInt32;
4785 return (T)this;
4786 }
4787
4788 public void clearDefaultInt32() {
4789 loadAndClear();
4790 this.b_defaultInt32 = false;
4791 this.f_defaultInt32 = 41;
4792 }
4793
4794 // optional int64 default_int64 = 62;
4795 private long f_defaultInt64 = 42l;
4796 private boolean b_defaultInt64;
4797
4798 public boolean hasDefaultInt64() {
4799 return this.b_defaultInt64;
4800 }
4801
4802 public long getDefaultInt64() {
4803 return this.f_defaultInt64;
4804 }
4805
4806 public T setDefaultInt64(long defaultInt64) {
4807 loadAndClear();
4808 this.b_defaultInt64 = true;
4809 this.f_defaultInt64 = defaultInt64;
4810 return (T)this;
4811 }
4812
4813 public void clearDefaultInt64() {
4814 loadAndClear();
4815 this.b_defaultInt64 = false;
4816 this.f_defaultInt64 = 42l;
4817 }
4818
4819 // optional uint32 default_uint32 = 63;
4820 private int f_defaultUint32 = 43;
4821 private boolean b_defaultUint32;
4822
4823 public boolean hasDefaultUint32() {
4824 return this.b_defaultUint32;
4825 }
4826
4827 public int getDefaultUint32() {
4828 return this.f_defaultUint32;
4829 }
4830
4831 public T setDefaultUint32(int defaultUint32) {
4832 loadAndClear();
4833 this.b_defaultUint32 = true;
4834 this.f_defaultUint32 = defaultUint32;
4835 return (T)this;
4836 }
4837
4838 public void clearDefaultUint32() {
4839 loadAndClear();
4840 this.b_defaultUint32 = false;
4841 this.f_defaultUint32 = 43;
4842 }
4843
4844 // optional uint64 default_uint64 = 64;
4845 private long f_defaultUint64 = 44l;
4846 private boolean b_defaultUint64;
4847
4848 public boolean hasDefaultUint64() {
4849 return this.b_defaultUint64;
4850 }
4851
4852 public long getDefaultUint64() {
4853 return this.f_defaultUint64;
4854 }
4855
4856 public T setDefaultUint64(long defaultUint64) {
4857 loadAndClear();
4858 this.b_defaultUint64 = true;
4859 this.f_defaultUint64 = defaultUint64;
4860 return (T)this;
4861 }
4862
4863 public void clearDefaultUint64() {
4864 loadAndClear();
4865 this.b_defaultUint64 = false;
4866 this.f_defaultUint64 = 44l;
4867 }
4868
4869 // optional sint32 default_sint32 = 65;
4870 private int f_defaultSint32 = -45;
4871 private boolean b_defaultSint32;
4872
4873 public boolean hasDefaultSint32() {
4874 return this.b_defaultSint32;
4875 }
4876
4877 public int getDefaultSint32() {
4878 return this.f_defaultSint32;
4879 }
4880
4881 public T setDefaultSint32(int defaultSint32) {
4882 loadAndClear();
4883 this.b_defaultSint32 = true;
4884 this.f_defaultSint32 = defaultSint32;
4885 return (T)this;
4886 }
4887
4888 public void clearDefaultSint32() {
4889 loadAndClear();
4890 this.b_defaultSint32 = false;
4891 this.f_defaultSint32 = -45;
4892 }
4893
4894 // optional sint64 default_sint64 = 66;
4895 private long f_defaultSint64 = 46l;
4896 private boolean b_defaultSint64;
4897
4898 public boolean hasDefaultSint64() {
4899 return this.b_defaultSint64;
4900 }
4901
4902 public long getDefaultSint64() {
4903 return this.f_defaultSint64;
4904 }
4905
4906 public T setDefaultSint64(long defaultSint64) {
4907 loadAndClear();
4908 this.b_defaultSint64 = true;
4909 this.f_defaultSint64 = defaultSint64;
4910 return (T)this;
4911 }
4912
4913 public void clearDefaultSint64() {
4914 loadAndClear();
4915 this.b_defaultSint64 = false;
4916 this.f_defaultSint64 = 46l;
4917 }
4918
4919 // optional fixed32 default_fixed32 = 67;
4920 private int f_defaultFixed32 = 47;
4921 private boolean b_defaultFixed32;
4922
4923 public boolean hasDefaultFixed32() {
4924 return this.b_defaultFixed32;
4925 }
4926
4927 public int getDefaultFixed32() {
4928 return this.f_defaultFixed32;
4929 }
4930
4931 public T setDefaultFixed32(int defaultFixed32) {
4932 loadAndClear();
4933 this.b_defaultFixed32 = true;
4934 this.f_defaultFixed32 = defaultFixed32;
4935 return (T)this;
4936 }
4937
4938 public void clearDefaultFixed32() {
4939 loadAndClear();
4940 this.b_defaultFixed32 = false;
4941 this.f_defaultFixed32 = 47;
4942 }
4943
4944 // optional fixed64 default_fixed64 = 68;
4945 private long f_defaultFixed64 = 48l;
4946 private boolean b_defaultFixed64;
4947
4948 public boolean hasDefaultFixed64() {
4949 return this.b_defaultFixed64;
4950 }
4951
4952 public long getDefaultFixed64() {
4953 return this.f_defaultFixed64;
4954 }
4955
4956 public T setDefaultFixed64(long defaultFixed64) {
4957 loadAndClear();
4958 this.b_defaultFixed64 = true;
4959 this.f_defaultFixed64 = defaultFixed64;
4960 return (T)this;
4961 }
4962
4963 public void clearDefaultFixed64() {
4964 loadAndClear();
4965 this.b_defaultFixed64 = false;
4966 this.f_defaultFixed64 = 48l;
4967 }
4968
4969 // optional sfixed32 default_sfixed32 = 69;
4970 private int f_defaultSfixed32 = 49;
4971 private boolean b_defaultSfixed32;
4972
4973 public boolean hasDefaultSfixed32() {
4974 return this.b_defaultSfixed32;
4975 }
4976
4977 public int getDefaultSfixed32() {
4978 return this.f_defaultSfixed32;
4979 }
4980
4981 public T setDefaultSfixed32(int defaultSfixed32) {
4982 loadAndClear();
4983 this.b_defaultSfixed32 = true;
4984 this.f_defaultSfixed32 = defaultSfixed32;
4985 return (T)this;
4986 }
4987
4988 public void clearDefaultSfixed32() {
4989 loadAndClear();
4990 this.b_defaultSfixed32 = false;
4991 this.f_defaultSfixed32 = 49;
4992 }
4993
4994 // optional sfixed64 default_sfixed64 = 70;
4995 private long f_defaultSfixed64 = -50l;
4996 private boolean b_defaultSfixed64;
4997
4998 public boolean hasDefaultSfixed64() {
4999 return this.b_defaultSfixed64;
5000 }
5001
5002 public long getDefaultSfixed64() {
5003 return this.f_defaultSfixed64;
5004 }
5005
5006 public T setDefaultSfixed64(long defaultSfixed64) {
5007 loadAndClear();
5008 this.b_defaultSfixed64 = true;
5009 this.f_defaultSfixed64 = defaultSfixed64;
5010 return (T)this;
5011 }
5012
5013 public void clearDefaultSfixed64() {
5014 loadAndClear();
5015 this.b_defaultSfixed64 = false;
5016 this.f_defaultSfixed64 = -50l;
5017 }
5018
5019 // optional float default_float = 71;
5020 private float f_defaultFloat = 51.5f;
5021 private boolean b_defaultFloat;
5022
5023 public boolean hasDefaultFloat() {
5024 return this.b_defaultFloat;
5025 }
5026
5027 public float getDefaultFloat() {
5028 return this.f_defaultFloat;
5029 }
5030
5031 public T setDefaultFloat(float defaultFloat) {
5032 loadAndClear();
5033 this.b_defaultFloat = true;
5034 this.f_defaultFloat = defaultFloat;
5035 return (T)this;
5036 }
5037
5038 public void clearDefaultFloat() {
5039 loadAndClear();
5040 this.b_defaultFloat = false;
5041 this.f_defaultFloat = 51.5f;
5042 }
5043
5044 // optional double default_double = 72;
5045 private double f_defaultDouble = 52000.0d;
5046 private boolean b_defaultDouble;
5047
5048 public boolean hasDefaultDouble() {
5049 return this.b_defaultDouble;
5050 }
5051
5052 public double getDefaultDouble() {
5053 return this.f_defaultDouble;
5054 }
5055
5056 public T setDefaultDouble(double defaultDouble) {
5057 loadAndClear();
5058 this.b_defaultDouble = true;
5059 this.f_defaultDouble = defaultDouble;
5060 return (T)this;
5061 }
5062
5063 public void clearDefaultDouble() {
5064 loadAndClear();
5065 this.b_defaultDouble = false;
5066 this.f_defaultDouble = 52000.0d;
5067 }
5068
5069 // optional bool default_bool = 73;
5070 private boolean f_defaultBool = true;
5071 private boolean b_defaultBool;
5072
5073 public boolean hasDefaultBool() {
5074 return this.b_defaultBool;
5075 }
5076
5077 public boolean getDefaultBool() {
5078 return this.f_defaultBool;
5079 }
5080
5081 public T setDefaultBool(boolean defaultBool) {
5082 loadAndClear();
5083 this.b_defaultBool = true;
5084 this.f_defaultBool = defaultBool;
5085 return (T)this;
5086 }
5087
5088 public void clearDefaultBool() {
5089 loadAndClear();
5090 this.b_defaultBool = false;
5091 this.f_defaultBool = true;
5092 }
5093
5094 // optional string default_string = 74;
5095 private java.lang.String f_defaultString = "\u0068\u0065\u006c\u006c\u006f";
5096 private boolean b_defaultString;
5097
5098 public boolean hasDefaultString() {
5099 return this.b_defaultString;
5100 }
5101
5102 public java.lang.String getDefaultString() {
5103 return this.f_defaultString;
5104 }
5105
5106 public T setDefaultString(java.lang.String defaultString) {
5107 loadAndClear();
5108 this.b_defaultString = true;
5109 this.f_defaultString = defaultString;
5110 return (T)this;
5111 }
5112
5113 public void clearDefaultString() {
5114 loadAndClear();
5115 this.b_defaultString = false;
5116 this.f_defaultString = "\u0068\u0065\u006c\u006c\u006f";
5117 }
5118
5119 // optional bytes default_bytes = 75;
5120 private org.apache.activemq.protobuf.Buffer f_defaultBytes = new org.apache.activemq.protobuf.Buffer("\u0077\u006f\u0072\u006c\u0064");
5121 private boolean b_defaultBytes;
5122
5123 public boolean hasDefaultBytes() {
5124 return this.b_defaultBytes;
5125 }
5126
5127 public org.apache.activemq.protobuf.Buffer getDefaultBytes() {
5128 return this.f_defaultBytes;
5129 }
5130
5131 public T setDefaultBytes(org.apache.activemq.protobuf.Buffer defaultBytes) {
5132 loadAndClear();
5133 this.b_defaultBytes = true;
5134 this.f_defaultBytes = defaultBytes;
5135 return (T)this;
5136 }
5137
5138 public void clearDefaultBytes() {
5139 loadAndClear();
5140 this.b_defaultBytes = false;
5141 this.f_defaultBytes = new org.apache.activemq.protobuf.Buffer("\u0077\u006f\u0072\u006c\u0064");
5142 }
5143
5144 // optional NestedEnum default_nested_enum = 81;
5145 private TestAllTypes.NestedEnum f_defaultNestedEnum = TestAllTypes.NestedEnum.BAR;
5146 private boolean b_defaultNestedEnum;
5147
5148 public boolean hasDefaultNestedEnum() {
5149 return this.b_defaultNestedEnum;
5150 }
5151
5152 public TestAllTypes.NestedEnum getDefaultNestedEnum() {
5153 return this.f_defaultNestedEnum;
5154 }
5155
5156 public T setDefaultNestedEnum(TestAllTypes.NestedEnum defaultNestedEnum) {
5157 loadAndClear();
5158 this.b_defaultNestedEnum = true;
5159 this.f_defaultNestedEnum = defaultNestedEnum;
5160 return (T)this;
5161 }
5162
5163 public void clearDefaultNestedEnum() {
5164 loadAndClear();
5165 this.b_defaultNestedEnum = false;
5166 this.f_defaultNestedEnum = TestAllTypes.NestedEnum.BAR;
5167 }
5168
5169 // optional ForeignEnum default_foreign_enum = 82;
5170 private ForeignEnum f_defaultForeignEnum = ForeignEnum.FOREIGN_BAR;
5171 private boolean b_defaultForeignEnum;
5172
5173 public boolean hasDefaultForeignEnum() {
5174 return this.b_defaultForeignEnum;
5175 }
5176
5177 public ForeignEnum getDefaultForeignEnum() {
5178 return this.f_defaultForeignEnum;
5179 }
5180
5181 public T setDefaultForeignEnum(ForeignEnum defaultForeignEnum) {
5182 loadAndClear();
5183 this.b_defaultForeignEnum = true;
5184 this.f_defaultForeignEnum = defaultForeignEnum;
5185 return (T)this;
5186 }
5187
5188 public void clearDefaultForeignEnum() {
5189 loadAndClear();
5190 this.b_defaultForeignEnum = false;
5191 this.f_defaultForeignEnum = ForeignEnum.FOREIGN_BAR;
5192 }
5193
5194 // optional protobuf_unittest_import.ImportEnum default_import_enum = 83;
5195 private com.google.protobuf.test.UnittestImport.ImportEnum f_defaultImportEnum = com.google.protobuf.test.UnittestImport.ImportEnum.IMPORT_BAR;
5196 private boolean b_defaultImportEnum;
5197
5198 public boolean hasDefaultImportEnum() {
5199 return this.b_defaultImportEnum;
5200 }
5201
5202 public com.google.protobuf.test.UnittestImport.ImportEnum getDefaultImportEnum() {
5203 return this.f_defaultImportEnum;
5204 }
5205
5206 public T setDefaultImportEnum(com.google.protobuf.test.UnittestImport.ImportEnum defaultImportEnum) {
5207 loadAndClear();
5208 this.b_defaultImportEnum = true;
5209 this.f_defaultImportEnum = defaultImportEnum;
5210 return (T)this;
5211 }
5212
5213 public void clearDefaultImportEnum() {
5214 loadAndClear();
5215 this.b_defaultImportEnum = false;
5216 this.f_defaultImportEnum = com.google.protobuf.test.UnittestImport.ImportEnum.IMPORT_BAR;
5217 }
5218
5219 // optional string default_string_piece = 84;
5220 private java.lang.String f_defaultStringPiece = "\u0061\u0062\u0063";
5221 private boolean b_defaultStringPiece;
5222
5223 public boolean hasDefaultStringPiece() {
5224 return this.b_defaultStringPiece;
5225 }
5226
5227 public java.lang.String getDefaultStringPiece() {
5228 return this.f_defaultStringPiece;
5229 }
5230
5231 public T setDefaultStringPiece(java.lang.String defaultStringPiece) {
5232 loadAndClear();
5233 this.b_defaultStringPiece = true;
5234 this.f_defaultStringPiece = defaultStringPiece;
5235 return (T)this;
5236 }
5237
5238 public void clearDefaultStringPiece() {
5239 loadAndClear();
5240 this.b_defaultStringPiece = false;
5241 this.f_defaultStringPiece = "\u0061\u0062\u0063";
5242 }
5243
5244 // optional string default_cord = 85;
5245 private java.lang.String f_defaultCord = "123";
5246 private boolean b_defaultCord;
5247
5248 public boolean hasDefaultCord() {
5249 return this.b_defaultCord;
5250 }
5251
5252 public java.lang.String getDefaultCord() {
5253 return this.f_defaultCord;
5254 }
5255
5256 public T setDefaultCord(java.lang.String defaultCord) {
5257 loadAndClear();
5258 this.b_defaultCord = true;
5259 this.f_defaultCord = defaultCord;
5260 return (T)this;
5261 }
5262
5263 public void clearDefaultCord() {
5264 loadAndClear();
5265 this.b_defaultCord = false;
5266 this.f_defaultCord = "123";
5267 }
5268
5269 }
5270
5271
5272 static public final class ForeignMessage extends ForeignMessageBase<ForeignMessage> {
5273
5274 public java.util.ArrayList<String> missingFields() {
5275 java.util.ArrayList<String> missingFields = super.missingFields();
5276 return missingFields;
5277 }
5278
5279 public void clear() {
5280 super.clear();
5281 clearC();
5282 }
5283
5284 public ForeignMessage clone() {
5285 return new ForeignMessage().mergeFrom(this);
5286 }
5287
5288 public ForeignMessage mergeFrom(ForeignMessage other) {
5289 if (other.hasC()) {
5290 setC(other.getC());
5291 }
5292 return this;
5293 }
5294
5295 public int serializedSizeUnframed() {
5296 if (memoizedSerializedSize != -1)
5297 return memoizedSerializedSize;
5298
5299 int size = 0;
5300 if (hasC()) {
5301 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getC());
5302 }
5303 memoizedSerializedSize = size;
5304 return size;
5305 }
5306
5307 public ForeignMessage mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
5308 while (true) {
5309 int tag = input.readTag();
5310 if ((tag & 0x07) == 4) {
5311 return this;
5312 }
5313 switch (tag) {
5314 case 0:
5315 return this;
5316 default: {
5317 break;
5318 }
5319 case 8:
5320 setC(input.readInt32());
5321 break;
5322 }
5323 }
5324 }
5325 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
5326 if (hasC()) {
5327 output.writeInt32(1, getC());
5328 }
5329 }
5330
5331 public static ForeignMessage parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5332 return new ForeignMessage().mergeUnframed(data).checktInitialized();
5333 }
5334
5335 public static ForeignMessage parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5336 return new ForeignMessage().mergeUnframed(data).checktInitialized();
5337 }
5338
5339 public static ForeignMessage parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5340 return new ForeignMessage().mergeUnframed(data).checktInitialized();
5341 }
5342
5343 public static ForeignMessage parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5344 return new ForeignMessage().mergeUnframed(data).checktInitialized();
5345 }
5346
5347 public static ForeignMessage parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5348 return new ForeignMessage().mergeFramed(data).checktInitialized();
5349 }
5350
5351 public static ForeignMessage parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5352 return new ForeignMessage().mergeFramed(data).checktInitialized();
5353 }
5354
5355 public static ForeignMessage parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5356 return new ForeignMessage().mergeFramed(data).checktInitialized();
5357 }
5358
5359 public static ForeignMessage parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5360 return new ForeignMessage().mergeFramed(data).checktInitialized();
5361 }
5362
5363 public String toString() {
5364 return toString(new java.lang.StringBuilder(), "").toString();
5365 }
5366
5367 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
5368 if( hasC() ) {
5369 sb.append(prefix+"c: ");
5370 sb.append(getC());
5371 sb.append("\n");
5372 }
5373 return sb;
5374 }
5375
5376 public boolean equals(Object obj) {
5377 if( obj==this )
5378 return true;
5379
5380 if( obj==null || obj.getClass()!=ForeignMessage.class )
5381 return false;
5382
5383 return equals((ForeignMessage)obj);
5384 }
5385
5386 public boolean equals(ForeignMessage obj) {
5387 if (hasC() ^ obj.hasC() )
5388 return false;
5389 if (hasC() && ( getC()!=obj.getC() ))
5390 return false;
5391 return true;
5392 }
5393
5394 public int hashCode() {
5395 int rc=1901595827;
5396 if (hasC()) {
5397 rc ^= ( 67^getC() );
5398 }
5399 return rc;
5400 }
5401
5402 }
5403
5404 static abstract class ForeignMessageBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
5405
5406 // optional int32 c = 1;
5407 private int f_c = 0;
5408 private boolean b_c;
5409
5410 public boolean hasC() {
5411 return this.b_c;
5412 }
5413
5414 public int getC() {
5415 return this.f_c;
5416 }
5417
5418 public T setC(int c) {
5419 loadAndClear();
5420 this.b_c = true;
5421 this.f_c = c;
5422 return (T)this;
5423 }
5424
5425 public void clearC() {
5426 loadAndClear();
5427 this.b_c = false;
5428 this.f_c = 0;
5429 }
5430
5431 }
5432
5433
5434 static public final class TestAllExtensions extends TestAllExtensionsBase<TestAllExtensions> {
5435
5436 public java.util.ArrayList<String> missingFields() {
5437 java.util.ArrayList<String> missingFields = super.missingFields();
5438 return missingFields;
5439 }
5440
5441 public void clear() {
5442 super.clear();
5443 }
5444
5445 public TestAllExtensions clone() {
5446 return new TestAllExtensions().mergeFrom(this);
5447 }
5448
5449 public TestAllExtensions mergeFrom(TestAllExtensions other) {
5450 return this;
5451 }
5452
5453 public int serializedSizeUnframed() {
5454 if (memoizedSerializedSize != -1)
5455 return memoizedSerializedSize;
5456
5457 int size = 0;
5458 memoizedSerializedSize = size;
5459 return size;
5460 }
5461
5462 public TestAllExtensions mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
5463 while (true) {
5464 int tag = input.readTag();
5465 if ((tag & 0x07) == 4) {
5466 return this;
5467 }
5468 switch (tag) {
5469 case 0:
5470 return this;
5471 default: {
5472 break;
5473 }
5474 }
5475 }
5476 }
5477 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
5478 }
5479
5480 public static TestAllExtensions parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5481 return new TestAllExtensions().mergeUnframed(data).checktInitialized();
5482 }
5483
5484 public static TestAllExtensions parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5485 return new TestAllExtensions().mergeUnframed(data).checktInitialized();
5486 }
5487
5488 public static TestAllExtensions parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5489 return new TestAllExtensions().mergeUnframed(data).checktInitialized();
5490 }
5491
5492 public static TestAllExtensions parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5493 return new TestAllExtensions().mergeUnframed(data).checktInitialized();
5494 }
5495
5496 public static TestAllExtensions parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5497 return new TestAllExtensions().mergeFramed(data).checktInitialized();
5498 }
5499
5500 public static TestAllExtensions parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5501 return new TestAllExtensions().mergeFramed(data).checktInitialized();
5502 }
5503
5504 public static TestAllExtensions parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
5505 return new TestAllExtensions().mergeFramed(data).checktInitialized();
5506 }
5507
5508 public static TestAllExtensions parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
5509 return new TestAllExtensions().mergeFramed(data).checktInitialized();
5510 }
5511
5512 public String toString() {
5513 return toString(new java.lang.StringBuilder(), "").toString();
5514 }
5515
5516 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
5517 return sb;
5518 }
5519
5520 public boolean equals(Object obj) {
5521 if( obj==this )
5522 return true;
5523
5524 if( obj==null || obj.getClass()!=TestAllExtensions.class )
5525 return false;
5526
5527 return equals((TestAllExtensions)obj);
5528 }
5529
5530 public boolean equals(TestAllExtensions obj) {
5531 return true;
5532 }
5533
5534 public int hashCode() {
5535 int rc=-704408317;
5536 return rc;
5537 }
5538
5539 }
5540
5541 static abstract class TestAllExtensionsBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
5542
5543 }
5544
5545
5546 static public final class TestRequired extends TestRequiredBase<TestRequired> {
5547
5548 public java.util.ArrayList<String> missingFields() {
5549 java.util.ArrayList<String> missingFields = super.missingFields();
5550 if( !hasA() ) {
5551 missingFields.add("a");
5552 }
5553 if( !hasB() ) {
5554 missingFields.add("b");
5555 }
5556 if( !hasC() ) {
5557 missingFields.add("c");
5558 }
5559 return missingFields;
5560 }
5561
5562 public void clear() {
5563 super.clear();
5564 clearA();
5565 clearDummy2();
5566 clearB();
5567 clearDummy4();
5568 clearDummy5();
5569 clearDummy6();
5570 clearDummy7();
5571 clearDummy8();
5572 clearDummy9();
5573 clearDummy10();
5574 clearDummy11();
5575 clearDummy12();
5576 clearDummy13();
5577 clearDummy14();
5578 clearDummy15();
5579 clearDummy16();
5580 clearDummy17();
5581 clearDummy18();
5582 clearDummy19();
5583 clearDummy20();
5584 clearDummy21();
5585 clearDummy22();
5586 clearDummy23();
5587 clearDummy24();
5588 clearDummy25();
5589 clearDummy26();
5590 clearDummy27();
5591 clearDummy28();
5592 clearDummy29();
5593 clearDummy30();
5594 clearDummy31();
5595 clearDummy32();
5596 clearC();
5597 }
5598
5599 public TestRequired clone() {
5600 return new TestRequired().mergeFrom(this);
5601 }
5602
5603 public TestRequired mergeFrom(TestRequired other) {
5604 if (other.hasA()) {
5605 setA(other.getA());
5606 }
5607 if (other.hasDummy2()) {
5608 setDummy2(other.getDummy2());
5609 }
5610 if (other.hasB()) {
5611 setB(other.getB());
5612 }
5613 if (other.hasDummy4()) {
5614 setDummy4(other.getDummy4());
5615 }
5616 if (other.hasDummy5()) {
5617 setDummy5(other.getDummy5());
5618 }
5619 if (other.hasDummy6()) {
5620 setDummy6(other.getDummy6());
5621 }
5622 if (other.hasDummy7()) {
5623 setDummy7(other.getDummy7());
5624 }
5625 if (other.hasDummy8()) {
5626 setDummy8(other.getDummy8());
5627 }
5628 if (other.hasDummy9()) {
5629 setDummy9(other.getDummy9());
5630 }
5631 if (other.hasDummy10()) {
5632 setDummy10(other.getDummy10());
5633 }
5634 if (other.hasDummy11()) {
5635 setDummy11(other.getDummy11());
5636 }
5637 if (other.hasDummy12()) {
5638 setDummy12(other.getDummy12());
5639 }
5640 if (other.hasDummy13()) {
5641 setDummy13(other.getDummy13());
5642 }
5643 if (other.hasDummy14()) {
5644 setDummy14(other.getDummy14());
5645 }
5646 if (other.hasDummy15()) {
5647 setDummy15(other.getDummy15());
5648 }
5649 if (other.hasDummy16()) {
5650 setDummy16(other.getDummy16());
5651 }
5652 if (other.hasDummy17()) {
5653 setDummy17(other.getDummy17());
5654 }
5655 if (other.hasDummy18()) {
5656 setDummy18(other.getDummy18());
5657 }
5658 if (other.hasDummy19()) {
5659 setDummy19(other.getDummy19());
5660 }
5661 if (other.hasDummy20()) {
5662 setDummy20(other.getDummy20());
5663 }
5664 if (other.hasDummy21()) {
5665 setDummy21(other.getDummy21());
5666 }
5667 if (other.hasDummy22()) {
5668 setDummy22(other.getDummy22());
5669 }
5670 if (other.hasDummy23()) {
5671 setDummy23(other.getDummy23());
5672 }
5673 if (other.hasDummy24()) {
5674 setDummy24(other.getDummy24());
5675 }
5676 if (other.hasDummy25()) {
5677 setDummy25(other.getDummy25());
5678 }
5679 if (other.hasDummy26()) {
5680 setDummy26(other.getDummy26());
5681 }
5682 if (other.hasDummy27()) {
5683 setDummy27(other.getDummy27());
5684 }
5685 if (other.hasDummy28()) {
5686 setDummy28(other.getDummy28());
5687 }
5688 if (other.hasDummy29()) {
5689 setDummy29(other.getDummy29());
5690 }
5691 if (other.hasDummy30()) {
5692 setDummy30(other.getDummy30());
5693 }
5694 if (other.hasDummy31()) {
5695 setDummy31(other.getDummy31());
5696 }
5697 if (other.hasDummy32()) {
5698 setDummy32(other.getDummy32());
5699 }
5700 if (other.hasC()) {
5701 setC(other.getC());
5702 }
5703 return this;
5704 }
5705
5706 public int serializedSizeUnframed() {
5707 if (memoizedSerializedSize != -1)
5708 return memoizedSerializedSize;
5709
5710 int size = 0;
5711 if (hasA()) {
5712 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getA());
5713 }
5714 if (hasDummy2()) {
5715 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(2, getDummy2());
5716 }
5717 if (hasB()) {
5718 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(3, getB());
5719 }
5720 if (hasDummy4()) {
5721 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(4, getDummy4());
5722 }
5723 if (hasDummy5()) {
5724 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(5, getDummy5());
5725 }
5726 if (hasDummy6()) {
5727 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(6, getDummy6());
5728 }
5729 if (hasDummy7()) {
5730 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(7, getDummy7());
5731 }
5732 if (hasDummy8()) {
5733 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(8, getDummy8());
5734 }
5735 if (hasDummy9()) {
5736 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(9, getDummy9());
5737 }
5738 if (hasDummy10()) {
5739 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(10, getDummy10());
5740 }
5741 if (hasDummy11()) {
5742 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(11, getDummy11());
5743 }
5744 if (hasDummy12()) {
5745 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(12, getDummy12());
5746 }
5747 if (hasDummy13()) {
5748 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(13, getDummy13());
5749 }
5750 if (hasDummy14()) {
5751 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(14, getDummy14());
5752 }
5753 if (hasDummy15()) {
5754 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(15, getDummy15());
5755 }
5756 if (hasDummy16()) {
5757 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(16, getDummy16());
5758 }
5759 if (hasDummy17()) {
5760 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(17, getDummy17());
5761 }
5762 if (hasDummy18()) {
5763 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(18, getDummy18());
5764 }
5765 if (hasDummy19()) {
5766 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(19, getDummy19());
5767 }
5768 if (hasDummy20()) {
5769 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(20, getDummy20());
5770 }
5771 if (hasDummy21()) {
5772 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(21, getDummy21());
5773 }
5774 if (hasDummy22()) {
5775 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(22, getDummy22());
5776 }
5777 if (hasDummy23()) {
5778 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(23, getDummy23());
5779 }
5780 if (hasDummy24()) {
5781 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(24, getDummy24());
5782 }
5783 if (hasDummy25()) {
5784 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(25, getDummy25());
5785 }
5786 if (hasDummy26()) {
5787 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(26, getDummy26());
5788 }
5789 if (hasDummy27()) {
5790 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(27, getDummy27());
5791 }
5792 if (hasDummy28()) {
5793 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(28, getDummy28());
5794 }
5795 if (hasDummy29()) {
5796 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(29, getDummy29());
5797 }
5798 if (hasDummy30()) {
5799 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(30, getDummy30());
5800 }
5801 if (hasDummy31()) {
5802 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(31, getDummy31());
5803 }
5804 if (hasDummy32()) {
5805 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(32, getDummy32());
5806 }
5807 if (hasC()) {
5808 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(33, getC());
5809 }
5810 memoizedSerializedSize = size;
5811 return size;
5812 }
5813
5814 public TestRequired mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
5815 while (true) {
5816 int tag = input.readTag();
5817 if ((tag & 0x07) == 4) {
5818 return this;
5819 }
5820 switch (tag) {
5821 case 0:
5822 return this;
5823 default: {
5824 break;
5825 }
5826 case 8:
5827 setA(input.readInt32());
5828 break;
5829 case 16:
5830 setDummy2(input.readInt32());
5831 break;
5832 case 24:
5833 setB(input.readInt32());
5834 break;
5835 case 32:
5836 setDummy4(input.readInt32());
5837 break;
5838 case 40:
5839 setDummy5(input.readInt32());
5840 break;
5841 case 48:
5842 setDummy6(input.readInt32());
5843 break;
5844 case 56:
5845 setDummy7(input.readInt32());
5846 break;
5847 case 64:
5848 setDummy8(input.readInt32());
5849 break;
5850 case 72:
5851 setDummy9(input.readInt32());
5852 break;
5853 case 80:
5854 setDummy10(input.readInt32());
5855 break;
5856 case 88:
5857 setDummy11(input.readInt32());
5858 break;
5859 case 96:
5860 setDummy12(input.readInt32());
5861 break;
5862 case 104:
5863 setDummy13(input.readInt32());
5864 break;
5865 case 112:
5866 setDummy14(input.readInt32());
5867 break;
5868 case 120:
5869 setDummy15(input.readInt32());
5870 break;
5871 case 128:
5872 setDummy16(input.readInt32());
5873 break;
5874 case 136:
5875 setDummy17(input.readInt32());
5876 break;
5877 case 144:
5878 setDummy18(input.readInt32());
5879 break;
5880 case 152:
5881 setDummy19(input.readInt32());
5882 break;
5883 case 160:
5884 setDummy20(input.readInt32());
5885 break;
5886 case 168:
5887 setDummy21(input.readInt32());
5888 break;
5889 case 176:
5890 setDummy22(input.readInt32());
5891 break;
5892 case 184:
5893 setDummy23(input.readInt32());
5894 break;
5895 case 192:
5896 setDummy24(input.readInt32());
5897 break;
5898 case 200:
5899 setDummy25(input.readInt32());
5900 break;
5901 case 208:
5902 setDummy26(input.readInt32());
5903 break;
5904 case 216:
5905 setDummy27(input.readInt32());
5906 break;
5907 case 224:
5908 setDummy28(input.readInt32());
5909 break;
5910 case 232:
5911 setDummy29(input.readInt32());
5912 break;
5913 case 240:
5914 setDummy30(input.readInt32());
5915 break;
5916 case 248:
5917 setDummy31(input.readInt32());
5918 break;
5919 case 256:
5920 setDummy32(input.readInt32());
5921 break;
5922 case 264:
5923 setC(input.readInt32());
5924 break;
5925 }
5926 }
5927 }
5928 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
5929 if (hasA()) {
5930 output.writeInt32(1, getA());
5931 }
5932 if (hasDummy2()) {
5933 output.writeInt32(2, getDummy2());
5934 }
5935 if (hasB()) {
5936 output.writeInt32(3, getB());
5937 }
5938 if (hasDummy4()) {
5939 output.writeInt32(4, getDummy4());
5940 }
5941 if (hasDummy5()) {
5942 output.writeInt32(5, getDummy5());
5943 }
5944 if (hasDummy6()) {
5945 output.writeInt32(6, getDummy6());
5946 }
5947 if (hasDummy7()) {
5948 output.writeInt32(7, getDummy7());
5949 }
5950 if (hasDummy8()) {
5951 output.writeInt32(8, getDummy8());
5952 }
5953 if (hasDummy9()) {
5954 output.writeInt32(9, getDummy9());
5955 }
5956 if (hasDummy10()) {
5957 output.writeInt32(10, getDummy10());
5958 }
5959 if (hasDummy11()) {
5960 output.writeInt32(11, getDummy11());
5961 }
5962 if (hasDummy12()) {
5963 output.writeInt32(12, getDummy12());
5964 }
5965 if (hasDummy13()) {
5966 output.writeInt32(13, getDummy13());
5967 }
5968 if (hasDummy14()) {
5969 output.writeInt32(14, getDummy14());
5970 }
5971 if (hasDummy15()) {
5972 output.writeInt32(15, getDummy15());
5973 }
5974 if (hasDummy16()) {
5975 output.writeInt32(16, getDummy16());
5976 }
5977 if (hasDummy17()) {
5978 output.writeInt32(17, getDummy17());
5979 }
5980 if (hasDummy18()) {
5981 output.writeInt32(18, getDummy18());
5982 }
5983 if (hasDummy19()) {
5984 output.writeInt32(19, getDummy19());
5985 }
5986 if (hasDummy20()) {
5987 output.writeInt32(20, getDummy20());
5988 }
5989 if (hasDummy21()) {
5990 output.writeInt32(21, getDummy21());
5991 }
5992 if (hasDummy22()) {
5993 output.writeInt32(22, getDummy22());
5994 }
5995 if (hasDummy23()) {
5996 output.writeInt32(23, getDummy23());
5997 }
5998 if (hasDummy24()) {
5999 output.writeInt32(24, getDummy24());
6000 }
6001 if (hasDummy25()) {
6002 output.writeInt32(25, getDummy25());
6003 }
6004 if (hasDummy26()) {
6005 output.writeInt32(26, getDummy26());
6006 }
6007 if (hasDummy27()) {
6008 output.writeInt32(27, getDummy27());
6009 }
6010 if (hasDummy28()) {
6011 output.writeInt32(28, getDummy28());
6012 }
6013 if (hasDummy29()) {
6014 output.writeInt32(29, getDummy29());
6015 }
6016 if (hasDummy30()) {
6017 output.writeInt32(30, getDummy30());
6018 }
6019 if (hasDummy31()) {
6020 output.writeInt32(31, getDummy31());
6021 }
6022 if (hasDummy32()) {
6023 output.writeInt32(32, getDummy32());
6024 }
6025 if (hasC()) {
6026 output.writeInt32(33, getC());
6027 }
6028 }
6029
6030 public static TestRequired parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
6031 return new TestRequired().mergeUnframed(data).checktInitialized();
6032 }
6033
6034 public static TestRequired parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
6035 return new TestRequired().mergeUnframed(data).checktInitialized();
6036 }
6037
6038 public static TestRequired parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
6039 return new TestRequired().mergeUnframed(data).checktInitialized();
6040 }
6041
6042 public static TestRequired parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
6043 return new TestRequired().mergeUnframed(data).checktInitialized();
6044 }
6045
6046 public static TestRequired parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
6047 return new TestRequired().mergeFramed(data).checktInitialized();
6048 }
6049
6050 public static TestRequired parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
6051 return new TestRequired().mergeFramed(data).checktInitialized();
6052 }
6053
6054 public static TestRequired parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
6055 return new TestRequired().mergeFramed(data).checktInitialized();
6056 }
6057
6058 public static TestRequired parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
6059 return new TestRequired().mergeFramed(data).checktInitialized();
6060 }
6061
6062 public String toString() {
6063 return toString(new java.lang.StringBuilder(), "").toString();
6064 }
6065
6066 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
6067 if( hasA() ) {
6068 sb.append(prefix+"a: ");
6069 sb.append(getA());
6070 sb.append("\n");
6071 }
6072 if( hasDummy2() ) {
6073 sb.append(prefix+"dummy2: ");
6074 sb.append(getDummy2());
6075 sb.append("\n");
6076 }
6077 if( hasB() ) {
6078 sb.append(prefix+"b: ");
6079 sb.append(getB());
6080 sb.append("\n");
6081 }
6082 if( hasDummy4() ) {
6083 sb.append(prefix+"dummy4: ");
6084 sb.append(getDummy4());
6085 sb.append("\n");
6086 }
6087 if( hasDummy5() ) {
6088 sb.append(prefix+"dummy5: ");
6089 sb.append(getDummy5());
6090 sb.append("\n");
6091 }
6092 if( hasDummy6() ) {
6093 sb.append(prefix+"dummy6: ");
6094 sb.append(getDummy6());
6095 sb.append("\n");
6096 }
6097 if( hasDummy7() ) {
6098 sb.append(prefix+"dummy7: ");
6099 sb.append(getDummy7());
6100 sb.append("\n");
6101 }
6102 if( hasDummy8() ) {
6103 sb.append(prefix+"dummy8: ");
6104 sb.append(getDummy8());
6105 sb.append("\n");
6106 }
6107 if( hasDummy9() ) {
6108 sb.append(prefix+"dummy9: ");
6109 sb.append(getDummy9());
6110 sb.append("\n");
6111 }
6112 if( hasDummy10() ) {
6113 sb.append(prefix+"dummy10: ");
6114 sb.append(getDummy10());
6115 sb.append("\n");
6116 }
6117 if( hasDummy11() ) {
6118 sb.append(prefix+"dummy11: ");
6119 sb.append(getDummy11());
6120 sb.append("\n");
6121 }
6122 if( hasDummy12() ) {
6123 sb.append(prefix+"dummy12: ");
6124 sb.append(getDummy12());
6125 sb.append("\n");
6126 }
6127 if( hasDummy13() ) {
6128 sb.append(prefix+"dummy13: ");
6129 sb.append(getDummy13());
6130 sb.append("\n");
6131 }
6132 if( hasDummy14() ) {
6133 sb.append(prefix+"dummy14: ");
6134 sb.append(getDummy14());
6135 sb.append("\n");
6136 }
6137 if( hasDummy15() ) {
6138 sb.append(prefix+"dummy15: ");
6139 sb.append(getDummy15());
6140 sb.append("\n");
6141 }
6142 if( hasDummy16() ) {
6143 sb.append(prefix+"dummy16: ");
6144 sb.append(getDummy16());
6145 sb.append("\n");
6146 }
6147 if( hasDummy17() ) {
6148 sb.append(prefix+"dummy17: ");
6149 sb.append(getDummy17());
6150 sb.append("\n");
6151 }
6152 if( hasDummy18() ) {
6153 sb.append(prefix+"dummy18: ");
6154 sb.append(getDummy18());
6155 sb.append("\n");
6156 }
6157 if( hasDummy19() ) {
6158 sb.append(prefix+"dummy19: ");
6159 sb.append(getDummy19());
6160 sb.append("\n");
6161 }
6162 if( hasDummy20() ) {
6163 sb.append(prefix+"dummy20: ");
6164 sb.append(getDummy20());
6165 sb.append("\n");
6166 }
6167 if( hasDummy21() ) {
6168 sb.append(prefix+"dummy21: ");
6169 sb.append(getDummy21());
6170 sb.append("\n");
6171 }
6172 if( hasDummy22() ) {
6173 sb.append(prefix+"dummy22: ");
6174 sb.append(getDummy22());
6175 sb.append("\n");
6176 }
6177 if( hasDummy23() ) {
6178 sb.append(prefix+"dummy23: ");
6179 sb.append(getDummy23());
6180 sb.append("\n");
6181 }
6182 if( hasDummy24() ) {
6183 sb.append(prefix+"dummy24: ");
6184 sb.append(getDummy24());
6185 sb.append("\n");
6186 }
6187 if( hasDummy25() ) {
6188 sb.append(prefix+"dummy25: ");
6189 sb.append(getDummy25());
6190 sb.append("\n");
6191 }
6192 if( hasDummy26() ) {
6193 sb.append(prefix+"dummy26: ");
6194 sb.append(getDummy26());
6195 sb.append("\n");
6196 }
6197 if( hasDummy27() ) {
6198 sb.append(prefix+"dummy27: ");
6199 sb.append(getDummy27());
6200 sb.append("\n");
6201 }
6202 if( hasDummy28() ) {
6203 sb.append(prefix+"dummy28: ");
6204 sb.append(getDummy28());
6205 sb.append("\n");
6206 }
6207 if( hasDummy29() ) {
6208 sb.append(prefix+"dummy29: ");
6209 sb.append(getDummy29());
6210 sb.append("\n");
6211 }
6212 if( hasDummy30() ) {
6213 sb.append(prefix+"dummy30: ");
6214 sb.append(getDummy30());
6215 sb.append("\n");
6216 }
6217 if( hasDummy31() ) {
6218 sb.append(prefix+"dummy31: ");
6219 sb.append(getDummy31());
6220 sb.append("\n");
6221 }
6222 if( hasDummy32() ) {
6223 sb.append(prefix+"dummy32: ");
6224 sb.append(getDummy32());
6225 sb.append("\n");
6226 }
6227 if( hasC() ) {
6228 sb.append(prefix+"c: ");
6229 sb.append(getC());
6230 sb.append("\n");
6231 }
6232 return sb;
6233 }
6234
6235 public boolean equals(Object obj) {
6236 if( obj==this )
6237 return true;
6238
6239 if( obj==null || obj.getClass()!=TestRequired.class )
6240 return false;
6241
6242 return equals((TestRequired)obj);
6243 }
6244
6245 public boolean equals(TestRequired obj) {
6246 if (hasA() ^ obj.hasA() )
6247 return false;
6248 if (hasA() && ( getA()!=obj.getA() ))
6249 return false;
6250 if (hasDummy2() ^ obj.hasDummy2() )
6251 return false;
6252 if (hasDummy2() && ( getDummy2()!=obj.getDummy2() ))
6253 return false;
6254 if (hasB() ^ obj.hasB() )
6255 return false;
6256 if (hasB() && ( getB()!=obj.getB() ))
6257 return false;
6258 if (hasDummy4() ^ obj.hasDummy4() )
6259 return false;
6260 if (hasDummy4() && ( getDummy4()!=obj.getDummy4() ))
6261 return false;
6262 if (hasDummy5() ^ obj.hasDummy5() )
6263 return false;
6264 if (hasDummy5() && ( getDummy5()!=obj.getDummy5() ))
6265 return false;
6266 if (hasDummy6() ^ obj.hasDummy6() )
6267 return false;
6268 if (hasDummy6() && ( getDummy6()!=obj.getDummy6() ))
6269 return false;
6270 if (hasDummy7() ^ obj.hasDummy7() )
6271 return false;
6272 if (hasDummy7() && ( getDummy7()!=obj.getDummy7() ))
6273 return false;
6274 if (hasDummy8() ^ obj.hasDummy8() )
6275 return false;
6276 if (hasDummy8() && ( getDummy8()!=obj.getDummy8() ))
6277 return false;
6278 if (hasDummy9() ^ obj.hasDummy9() )
6279 return false;
6280 if (hasDummy9() && ( getDummy9()!=obj.getDummy9() ))
6281 return false;
6282 if (hasDummy10() ^ obj.hasDummy10() )
6283 return false;
6284 if (hasDummy10() && ( getDummy10()!=obj.getDummy10() ))
6285 return false;
6286 if (hasDummy11() ^ obj.hasDummy11() )
6287 return false;
6288 if (hasDummy11() && ( getDummy11()!=obj.getDummy11() ))
6289 return false;
6290 if (hasDummy12() ^ obj.hasDummy12() )
6291 return false;
6292 if (hasDummy12() && ( getDummy12()!=obj.getDummy12() ))
6293 return false;
6294 if (hasDummy13() ^ obj.hasDummy13() )
6295 return false;
6296 if (hasDummy13() && ( getDummy13()!=obj.getDummy13() ))
6297 return false;
6298 if (hasDummy14() ^ obj.hasDummy14() )
6299 return false;
6300 if (hasDummy14() && ( getDummy14()!=obj.getDummy14() ))
6301 return false;
6302 if (hasDummy15() ^ obj.hasDummy15() )
6303 return false;
6304 if (hasDummy15() && ( getDummy15()!=obj.getDummy15() ))
6305 return false;
6306 if (hasDummy16() ^ obj.hasDummy16() )
6307 return false;
6308 if (hasDummy16() && ( getDummy16()!=obj.getDummy16() ))
6309 return false;
6310 if (hasDummy17() ^ obj.hasDummy17() )
6311 return false;
6312 if (hasDummy17() && ( getDummy17()!=obj.getDummy17() ))
6313 return false;
6314 if (hasDummy18() ^ obj.hasDummy18() )
6315 return false;
6316 if (hasDummy18() && ( getDummy18()!=obj.getDummy18() ))
6317 return false;
6318 if (hasDummy19() ^ obj.hasDummy19() )
6319 return false;
6320 if (hasDummy19() && ( getDummy19()!=obj.getDummy19() ))
6321 return false;
6322 if (hasDummy20() ^ obj.hasDummy20() )
6323 return false;
6324 if (hasDummy20() && ( getDummy20()!=obj.getDummy20() ))
6325 return false;
6326 if (hasDummy21() ^ obj.hasDummy21() )
6327 return false;
6328 if (hasDummy21() && ( getDummy21()!=obj.getDummy21() ))
6329 return false;
6330 if (hasDummy22() ^ obj.hasDummy22() )
6331 return false;
6332 if (hasDummy22() && ( getDummy22()!=obj.getDummy22() ))
6333 return false;
6334 if (hasDummy23() ^ obj.hasDummy23() )
6335 return false;
6336 if (hasDummy23() && ( getDummy23()!=obj.getDummy23() ))
6337 return false;
6338 if (hasDummy24() ^ obj.hasDummy24() )
6339 return false;
6340 if (hasDummy24() && ( getDummy24()!=obj.getDummy24() ))
6341 return false;
6342 if (hasDummy25() ^ obj.hasDummy25() )
6343 return false;
6344 if (hasDummy25() && ( getDummy25()!=obj.getDummy25() ))
6345 return false;
6346 if (hasDummy26() ^ obj.hasDummy26() )
6347 return false;
6348 if (hasDummy26() && ( getDummy26()!=obj.getDummy26() ))
6349 return false;
6350 if (hasDummy27() ^ obj.hasDummy27() )
6351 return false;
6352 if (hasDummy27() && ( getDummy27()!=obj.getDummy27() ))
6353 return false;
6354 if (hasDummy28() ^ obj.hasDummy28() )
6355 return false;
6356 if (hasDummy28() && ( getDummy28()!=obj.getDummy28() ))
6357 return false;
6358 if (hasDummy29() ^ obj.hasDummy29() )
6359 return false;
6360 if (hasDummy29() && ( getDummy29()!=obj.getDummy29() ))
6361 return false;
6362 if (hasDummy30() ^ obj.hasDummy30() )
6363 return false;
6364 if (hasDummy30() && ( getDummy30()!=obj.getDummy30() ))
6365 return false;
6366 if (hasDummy31() ^ obj.hasDummy31() )
6367 return false;
6368 if (hasDummy31() && ( getDummy31()!=obj.getDummy31() ))
6369 return false;
6370 if (hasDummy32() ^ obj.hasDummy32() )
6371 return false;
6372 if (hasDummy32() && ( getDummy32()!=obj.getDummy32() ))
6373 return false;
6374 if (hasC() ^ obj.hasC() )
6375 return false;
6376 if (hasC() && ( getC()!=obj.getC() ))
6377 return false;
6378 return true;
6379 }
6380
6381 public int hashCode() {
6382 int rc=485521009;
6383 if (hasA()) {
6384 rc ^= ( 65^getA() );
6385 }
6386 if (hasDummy2()) {
6387 rc ^= ( 2058189994^getDummy2() );
6388 }
6389 if (hasB()) {
6390 rc ^= ( 66^getB() );
6391 }
6392 if (hasDummy4()) {
6393 rc ^= ( 2058189996^getDummy4() );
6394 }
6395 if (hasDummy5()) {
6396 rc ^= ( 2058189997^getDummy5() );
6397 }
6398 if (hasDummy6()) {
6399 rc ^= ( 2058189998^getDummy6() );
6400 }
6401 if (hasDummy7()) {
6402 rc ^= ( 2058189999^getDummy7() );
6403 }
6404 if (hasDummy8()) {
6405 rc ^= ( 2058190000^getDummy8() );
6406 }
6407 if (hasDummy9()) {
6408 rc ^= ( 2058190001^getDummy9() );
6409 }
6410 if (hasDummy10()) {
6411 rc ^= ( -620619609^getDummy10() );
6412 }
6413 if (hasDummy11()) {
6414 rc ^= ( -620619608^getDummy11() );
6415 }
6416 if (hasDummy12()) {
6417 rc ^= ( -620619607^getDummy12() );
6418 }
6419 if (hasDummy13()) {
6420 rc ^= ( -620619606^getDummy13() );
6421 }
6422 if (hasDummy14()) {
6423 rc ^= ( -620619605^getDummy14() );
6424 }
6425 if (hasDummy15()) {
6426 rc ^= ( -620619604^getDummy15() );
6427 }
6428 if (hasDummy16()) {
6429 rc ^= ( -620619603^getDummy16() );
6430 }
6431 if (hasDummy17()) {
6432 rc ^= ( -620619602^getDummy17() );
6433 }
6434 if (hasDummy18()) {
6435 rc ^= ( -620619601^getDummy18() );
6436 }
6437 if (hasDummy19()) {
6438 rc ^= ( -620619600^getDummy19() );
6439 }
6440 if (hasDummy20()) {
6441 rc ^= ( -620619578^getDummy20() );
6442 }
6443 if (hasDummy21()) {
6444 rc ^= ( -620619577^getDummy21() );
6445 }
6446 if (hasDummy22()) {
6447 rc ^= ( -620619576^getDummy22() );
6448 }
6449 if (hasDummy23()) {
6450 rc ^= ( -620619575^getDummy23() );
6451 }
6452 if (hasDummy24()) {
6453 rc ^= ( -620619574^getDummy24() );
6454 }
6455 if (hasDummy25()) {
6456 rc ^= ( -620619573^getDummy25() );
6457 }
6458 if (hasDummy26()) {
6459 rc ^= ( -620619572^getDummy26() );
6460 }
6461 if (hasDummy27()) {
6462 rc ^= ( -620619571^getDummy27() );
6463 }
6464 if (hasDummy28()) {
6465 rc ^= ( -620619570^getDummy28() );
6466 }
6467 if (hasDummy29()) {
6468 rc ^= ( -620619569^getDummy29() );
6469 }
6470 if (hasDummy30()) {
6471 rc ^= ( -620619547^getDummy30() );
6472 }
6473 if (hasDummy31()) {
6474 rc ^= ( -620619546^getDummy31() );
6475 }
6476 if (hasDummy32()) {
6477 rc ^= ( -620619545^getDummy32() );
6478 }
6479 if (hasC()) {
6480 rc ^= ( 67^getC() );
6481 }
6482 return rc;
6483 }
6484
6485 }
6486
6487 static abstract class TestRequiredBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
6488
6489 // required int32 a = 1;
6490 private int f_a = 0;
6491 private boolean b_a;
6492
6493 public boolean hasA() {
6494 return this.b_a;
6495 }
6496
6497 public int getA() {
6498 return this.f_a;
6499 }
6500
6501 public T setA(int a) {
6502 loadAndClear();
6503 this.b_a = true;
6504 this.f_a = a;
6505 return (T)this;
6506 }
6507
6508 public void clearA() {
6509 loadAndClear();
6510 this.b_a = false;
6511 this.f_a = 0;
6512 }
6513
6514 // optional int32 dummy2 = 2;
6515 private int f_dummy2 = 0;
6516 private boolean b_dummy2;
6517
6518 public boolean hasDummy2() {
6519 return this.b_dummy2;
6520 }
6521
6522 public int getDummy2() {
6523 return this.f_dummy2;
6524 }
6525
6526 public T setDummy2(int dummy2) {
6527 loadAndClear();
6528 this.b_dummy2 = true;
6529 this.f_dummy2 = dummy2;
6530 return (T)this;
6531 }
6532
6533 public void clearDummy2() {
6534 loadAndClear();
6535 this.b_dummy2 = false;
6536 this.f_dummy2 = 0;
6537 }
6538
6539 // required int32 b = 3;
6540 private int f_b = 0;
6541 private boolean b_b;
6542
6543 public boolean hasB() {
6544 return this.b_b;
6545 }
6546
6547 public int getB() {
6548 return this.f_b;
6549 }
6550
6551 public T setB(int b) {
6552 loadAndClear();
6553 this.b_b = true;
6554 this.f_b = b;
6555 return (T)this;
6556 }
6557
6558 public void clearB() {
6559 loadAndClear();
6560 this.b_b = false;
6561 this.f_b = 0;
6562 }
6563
6564 // optional int32 dummy4 = 4;
6565 private int f_dummy4 = 0;
6566 private boolean b_dummy4;
6567
6568 public boolean hasDummy4() {
6569 return this.b_dummy4;
6570 }
6571
6572 public int getDummy4() {
6573 return this.f_dummy4;
6574 }
6575
6576 public T setDummy4(int dummy4) {
6577 loadAndClear();
6578 this.b_dummy4 = true;
6579 this.f_dummy4 = dummy4;
6580 return (T)this;
6581 }
6582
6583 public void clearDummy4() {
6584 loadAndClear();
6585 this.b_dummy4 = false;
6586 this.f_dummy4 = 0;
6587 }
6588
6589 // optional int32 dummy5 = 5;
6590 private int f_dummy5 = 0;
6591 private boolean b_dummy5;
6592
6593 public boolean hasDummy5() {
6594 return this.b_dummy5;
6595 }
6596
6597 public int getDummy5() {
6598 return this.f_dummy5;
6599 }
6600
6601 public T setDummy5(int dummy5) {
6602 loadAndClear();
6603 this.b_dummy5 = true;
6604 this.f_dummy5 = dummy5;
6605 return (T)this;
6606 }
6607
6608 public void clearDummy5() {
6609 loadAndClear();
6610 this.b_dummy5 = false;
6611 this.f_dummy5 = 0;
6612 }
6613
6614 // optional int32 dummy6 = 6;
6615 private int f_dummy6 = 0;
6616 private boolean b_dummy6;
6617
6618 public boolean hasDummy6() {
6619 return this.b_dummy6;
6620 }
6621
6622 public int getDummy6() {
6623 return this.f_dummy6;
6624 }
6625
6626 public T setDummy6(int dummy6) {
6627 loadAndClear();
6628 this.b_dummy6 = true;
6629 this.f_dummy6 = dummy6;
6630 return (T)this;
6631 }
6632
6633 public void clearDummy6() {
6634 loadAndClear();
6635 this.b_dummy6 = false;
6636 this.f_dummy6 = 0;
6637 }
6638
6639 // optional int32 dummy7 = 7;
6640 private int f_dummy7 = 0;
6641 private boolean b_dummy7;
6642
6643 public boolean hasDummy7() {
6644 return this.b_dummy7;
6645 }
6646
6647 public int getDummy7() {
6648 return this.f_dummy7;
6649 }
6650
6651 public T setDummy7(int dummy7) {
6652 loadAndClear();
6653 this.b_dummy7 = true;
6654 this.f_dummy7 = dummy7;
6655 return (T)this;
6656 }
6657
6658 public void clearDummy7() {
6659 loadAndClear();
6660 this.b_dummy7 = false;
6661 this.f_dummy7 = 0;
6662 }
6663
6664 // optional int32 dummy8 = 8;
6665 private int f_dummy8 = 0;
6666 private boolean b_dummy8;
6667
6668 public boolean hasDummy8() {
6669 return this.b_dummy8;
6670 }
6671
6672 public int getDummy8() {
6673 return this.f_dummy8;
6674 }
6675
6676 public T setDummy8(int dummy8) {
6677 loadAndClear();
6678 this.b_dummy8 = true;
6679 this.f_dummy8 = dummy8;
6680 return (T)this;
6681 }
6682
6683 public void clearDummy8() {
6684 loadAndClear();
6685 this.b_dummy8 = false;
6686 this.f_dummy8 = 0;
6687 }
6688
6689 // optional int32 dummy9 = 9;
6690 private int f_dummy9 = 0;
6691 private boolean b_dummy9;
6692
6693 public boolean hasDummy9() {
6694 return this.b_dummy9;
6695 }
6696
6697 public int getDummy9() {
6698 return this.f_dummy9;
6699 }
6700
6701 public T setDummy9(int dummy9) {
6702 loadAndClear();
6703 this.b_dummy9 = true;
6704 this.f_dummy9 = dummy9;
6705 return (T)this;
6706 }
6707
6708 public void clearDummy9() {
6709 loadAndClear();
6710 this.b_dummy9 = false;
6711 this.f_dummy9 = 0;
6712 }
6713
6714 // optional int32 dummy10 = 10;
6715 private int f_dummy10 = 0;
6716 private boolean b_dummy10;
6717
6718 public boolean hasDummy10() {
6719 return this.b_dummy10;
6720 }
6721
6722 public int getDummy10() {
6723 return this.f_dummy10;
6724 }
6725
6726 public T setDummy10(int dummy10) {
6727 loadAndClear();
6728 this.b_dummy10 = true;
6729 this.f_dummy10 = dummy10;
6730 return (T)this;
6731 }
6732
6733 public void clearDummy10() {
6734 loadAndClear();
6735 this.b_dummy10 = false;
6736 this.f_dummy10 = 0;
6737 }
6738
6739 // optional int32 dummy11 = 11;
6740 private int f_dummy11 = 0;
6741 private boolean b_dummy11;
6742
6743 public boolean hasDummy11() {
6744 return this.b_dummy11;
6745 }
6746
6747 public int getDummy11() {
6748 return this.f_dummy11;
6749 }
6750
6751 public T setDummy11(int dummy11) {
6752 loadAndClear();
6753 this.b_dummy11 = true;
6754 this.f_dummy11 = dummy11;
6755 return (T)this;
6756 }
6757
6758 public void clearDummy11() {
6759 loadAndClear();
6760 this.b_dummy11 = false;
6761 this.f_dummy11 = 0;
6762 }
6763
6764 // optional int32 dummy12 = 12;
6765 private int f_dummy12 = 0;
6766 private boolean b_dummy12;
6767
6768 public boolean hasDummy12() {
6769 return this.b_dummy12;
6770 }
6771
6772 public int getDummy12() {
6773 return this.f_dummy12;
6774 }
6775
6776 public T setDummy12(int dummy12) {
6777 loadAndClear();
6778 this.b_dummy12 = true;
6779 this.f_dummy12 = dummy12;
6780 return (T)this;
6781 }
6782
6783 public void clearDummy12() {
6784 loadAndClear();
6785 this.b_dummy12 = false;
6786 this.f_dummy12 = 0;
6787 }
6788
6789 // optional int32 dummy13 = 13;
6790 private int f_dummy13 = 0;
6791 private boolean b_dummy13;
6792
6793 public boolean hasDummy13() {
6794 return this.b_dummy13;
6795 }
6796
6797 public int getDummy13() {
6798 return this.f_dummy13;
6799 }
6800
6801 public T setDummy13(int dummy13) {
6802 loadAndClear();
6803 this.b_dummy13 = true;
6804 this.f_dummy13 = dummy13;
6805 return (T)this;
6806 }
6807
6808 public void clearDummy13() {
6809 loadAndClear();
6810 this.b_dummy13 = false;
6811 this.f_dummy13 = 0;
6812 }
6813
6814 // optional int32 dummy14 = 14;
6815 private int f_dummy14 = 0;
6816 private boolean b_dummy14;
6817
6818 public boolean hasDummy14() {
6819 return this.b_dummy14;
6820 }
6821
6822 public int getDummy14() {
6823 return this.f_dummy14;
6824 }
6825
6826 public T setDummy14(int dummy14) {
6827 loadAndClear();
6828 this.b_dummy14 = true;
6829 this.f_dummy14 = dummy14;
6830 return (T)this;
6831 }
6832
6833 public void clearDummy14() {
6834 loadAndClear();
6835 this.b_dummy14 = false;
6836 this.f_dummy14 = 0;
6837 }
6838
6839 // optional int32 dummy15 = 15;
6840 private int f_dummy15 = 0;
6841 private boolean b_dummy15;
6842
6843 public boolean hasDummy15() {
6844 return this.b_dummy15;
6845 }
6846
6847 public int getDummy15() {
6848 return this.f_dummy15;
6849 }
6850
6851 public T setDummy15(int dummy15) {
6852 loadAndClear();
6853 this.b_dummy15 = true;
6854 this.f_dummy15 = dummy15;
6855 return (T)this;
6856 }
6857
6858 public void clearDummy15() {
6859 loadAndClear();
6860 this.b_dummy15 = false;
6861 this.f_dummy15 = 0;
6862 }
6863
6864 // optional int32 dummy16 = 16;
6865 private int f_dummy16 = 0;
6866 private boolean b_dummy16;
6867
6868 public boolean hasDummy16() {
6869 return this.b_dummy16;
6870 }
6871
6872 public int getDummy16() {
6873 return this.f_dummy16;
6874 }
6875
6876 public T setDummy16(int dummy16) {
6877 loadAndClear();
6878 this.b_dummy16 = true;
6879 this.f_dummy16 = dummy16;
6880 return (T)this;
6881 }
6882
6883 public void clearDummy16() {
6884 loadAndClear();
6885 this.b_dummy16 = false;
6886 this.f_dummy16 = 0;
6887 }
6888
6889 // optional int32 dummy17 = 17;
6890 private int f_dummy17 = 0;
6891 private boolean b_dummy17;
6892
6893 public boolean hasDummy17() {
6894 return this.b_dummy17;
6895 }
6896
6897 public int getDummy17() {
6898 return this.f_dummy17;
6899 }
6900
6901 public T setDummy17(int dummy17) {
6902 loadAndClear();
6903 this.b_dummy17 = true;
6904 this.f_dummy17 = dummy17;
6905 return (T)this;
6906 }
6907
6908 public void clearDummy17() {
6909 loadAndClear();
6910 this.b_dummy17 = false;
6911 this.f_dummy17 = 0;
6912 }
6913
6914 // optional int32 dummy18 = 18;
6915 private int f_dummy18 = 0;
6916 private boolean b_dummy18;
6917
6918 public boolean hasDummy18() {
6919 return this.b_dummy18;
6920 }
6921
6922 public int getDummy18() {
6923 return this.f_dummy18;
6924 }
6925
6926 public T setDummy18(int dummy18) {
6927 loadAndClear();
6928 this.b_dummy18 = true;
6929 this.f_dummy18 = dummy18;
6930 return (T)this;
6931 }
6932
6933 public void clearDummy18() {
6934 loadAndClear();
6935 this.b_dummy18 = false;
6936 this.f_dummy18 = 0;
6937 }
6938
6939 // optional int32 dummy19 = 19;
6940 private int f_dummy19 = 0;
6941 private boolean b_dummy19;
6942
6943 public boolean hasDummy19() {
6944 return this.b_dummy19;
6945 }
6946
6947 public int getDummy19() {
6948 return this.f_dummy19;
6949 }
6950
6951 public T setDummy19(int dummy19) {
6952 loadAndClear();
6953 this.b_dummy19 = true;
6954 this.f_dummy19 = dummy19;
6955 return (T)this;
6956 }
6957
6958 public void clearDummy19() {
6959 loadAndClear();
6960 this.b_dummy19 = false;
6961 this.f_dummy19 = 0;
6962 }
6963
6964 // optional int32 dummy20 = 20;
6965 private int f_dummy20 = 0;
6966 private boolean b_dummy20;
6967
6968 public boolean hasDummy20() {
6969 return this.b_dummy20;
6970 }
6971
6972 public int getDummy20() {
6973 return this.f_dummy20;
6974 }
6975
6976 public T setDummy20(int dummy20) {
6977 loadAndClear();
6978 this.b_dummy20 = true;
6979 this.f_dummy20 = dummy20;
6980 return (T)this;
6981 }
6982
6983 public void clearDummy20() {
6984 loadAndClear();
6985 this.b_dummy20 = false;
6986 this.f_dummy20 = 0;
6987 }
6988
6989 // optional int32 dummy21 = 21;
6990 private int f_dummy21 = 0;
6991 private boolean b_dummy21;
6992
6993 public boolean hasDummy21() {
6994 return this.b_dummy21;
6995 }
6996
6997 public int getDummy21() {
6998 return this.f_dummy21;
6999 }
7000
7001 public T setDummy21(int dummy21) {
7002 loadAndClear();
7003 this.b_dummy21 = true;
7004 this.f_dummy21 = dummy21;
7005 return (T)this;
7006 }
7007
7008 public void clearDummy21() {
7009 loadAndClear();
7010 this.b_dummy21 = false;
7011 this.f_dummy21 = 0;
7012 }
7013
7014 // optional int32 dummy22 = 22;
7015 private int f_dummy22 = 0;
7016 private boolean b_dummy22;
7017
7018 public boolean hasDummy22() {
7019 return this.b_dummy22;
7020 }
7021
7022 public int getDummy22() {
7023 return this.f_dummy22;
7024 }
7025
7026 public T setDummy22(int dummy22) {
7027 loadAndClear();
7028 this.b_dummy22 = true;
7029 this.f_dummy22 = dummy22;
7030 return (T)this;
7031 }
7032
7033 public void clearDummy22() {
7034 loadAndClear();
7035 this.b_dummy22 = false;
7036 this.f_dummy22 = 0;
7037 }
7038
7039 // optional int32 dummy23 = 23;
7040 private int f_dummy23 = 0;
7041 private boolean b_dummy23;
7042
7043 public boolean hasDummy23() {
7044 return this.b_dummy23;
7045 }
7046
7047 public int getDummy23() {
7048 return this.f_dummy23;
7049 }
7050
7051 public T setDummy23(int dummy23) {
7052 loadAndClear();
7053 this.b_dummy23 = true;
7054 this.f_dummy23 = dummy23;
7055 return (T)this;
7056 }
7057
7058 public void clearDummy23() {
7059 loadAndClear();
7060 this.b_dummy23 = false;
7061 this.f_dummy23 = 0;
7062 }
7063
7064 // optional int32 dummy24 = 24;
7065 private int f_dummy24 = 0;
7066 private boolean b_dummy24;
7067
7068 public boolean hasDummy24() {
7069 return this.b_dummy24;
7070 }
7071
7072 public int getDummy24() {
7073 return this.f_dummy24;
7074 }
7075
7076 public T setDummy24(int dummy24) {
7077 loadAndClear();
7078 this.b_dummy24 = true;
7079 this.f_dummy24 = dummy24;
7080 return (T)this;
7081 }
7082
7083 public void clearDummy24() {
7084 loadAndClear();
7085 this.b_dummy24 = false;
7086 this.f_dummy24 = 0;
7087 }
7088
7089 // optional int32 dummy25 = 25;
7090 private int f_dummy25 = 0;
7091 private boolean b_dummy25;
7092
7093 public boolean hasDummy25() {
7094 return this.b_dummy25;
7095 }
7096
7097 public int getDummy25() {
7098 return this.f_dummy25;
7099 }
7100
7101 public T setDummy25(int dummy25) {
7102 loadAndClear();
7103 this.b_dummy25 = true;
7104 this.f_dummy25 = dummy25;
7105 return (T)this;
7106 }
7107
7108 public void clearDummy25() {
7109 loadAndClear();
7110 this.b_dummy25 = false;
7111 this.f_dummy25 = 0;
7112 }
7113
7114 // optional int32 dummy26 = 26;
7115 private int f_dummy26 = 0;
7116 private boolean b_dummy26;
7117
7118 public boolean hasDummy26() {
7119 return this.b_dummy26;
7120 }
7121
7122 public int getDummy26() {
7123 return this.f_dummy26;
7124 }
7125
7126 public T setDummy26(int dummy26) {
7127 loadAndClear();
7128 this.b_dummy26 = true;
7129 this.f_dummy26 = dummy26;
7130 return (T)this;
7131 }
7132
7133 public void clearDummy26() {
7134 loadAndClear();
7135 this.b_dummy26 = false;
7136 this.f_dummy26 = 0;
7137 }
7138
7139 // optional int32 dummy27 = 27;
7140 private int f_dummy27 = 0;
7141 private boolean b_dummy27;
7142
7143 public boolean hasDummy27() {
7144 return this.b_dummy27;
7145 }
7146
7147 public int getDummy27() {
7148 return this.f_dummy27;
7149 }
7150
7151 public T setDummy27(int dummy27) {
7152 loadAndClear();
7153 this.b_dummy27 = true;
7154 this.f_dummy27 = dummy27;
7155 return (T)this;
7156 }
7157
7158 public void clearDummy27() {
7159 loadAndClear();
7160 this.b_dummy27 = false;
7161 this.f_dummy27 = 0;
7162 }
7163
7164 // optional int32 dummy28 = 28;
7165 private int f_dummy28 = 0;
7166 private boolean b_dummy28;
7167
7168 public boolean hasDummy28() {
7169 return this.b_dummy28;
7170 }
7171
7172 public int getDummy28() {
7173 return this.f_dummy28;
7174 }
7175
7176 public T setDummy28(int dummy28) {
7177 loadAndClear();
7178 this.b_dummy28 = true;
7179 this.f_dummy28 = dummy28;
7180 return (T)this;
7181 }
7182
7183 public void clearDummy28() {
7184 loadAndClear();
7185 this.b_dummy28 = false;
7186 this.f_dummy28 = 0;
7187 }
7188
7189 // optional int32 dummy29 = 29;
7190 private int f_dummy29 = 0;
7191 private boolean b_dummy29;
7192
7193 public boolean hasDummy29() {
7194 return this.b_dummy29;
7195 }
7196
7197 public int getDummy29() {
7198 return this.f_dummy29;
7199 }
7200
7201 public T setDummy29(int dummy29) {
7202 loadAndClear();
7203 this.b_dummy29 = true;
7204 this.f_dummy29 = dummy29;
7205 return (T)this;
7206 }
7207
7208 public void clearDummy29() {
7209 loadAndClear();
7210 this.b_dummy29 = false;
7211 this.f_dummy29 = 0;
7212 }
7213
7214 // optional int32 dummy30 = 30;
7215 private int f_dummy30 = 0;
7216 private boolean b_dummy30;
7217
7218 public boolean hasDummy30() {
7219 return this.b_dummy30;
7220 }
7221
7222 public int getDummy30() {
7223 return this.f_dummy30;
7224 }
7225
7226 public T setDummy30(int dummy30) {
7227 loadAndClear();
7228 this.b_dummy30 = true;
7229 this.f_dummy30 = dummy30;
7230 return (T)this;
7231 }
7232
7233 public void clearDummy30() {
7234 loadAndClear();
7235 this.b_dummy30 = false;
7236 this.f_dummy30 = 0;
7237 }
7238
7239 // optional int32 dummy31 = 31;
7240 private int f_dummy31 = 0;
7241 private boolean b_dummy31;
7242
7243 public boolean hasDummy31() {
7244 return this.b_dummy31;
7245 }
7246
7247 public int getDummy31() {
7248 return this.f_dummy31;
7249 }
7250
7251 public T setDummy31(int dummy31) {
7252 loadAndClear();
7253 this.b_dummy31 = true;
7254 this.f_dummy31 = dummy31;
7255 return (T)this;
7256 }
7257
7258 public void clearDummy31() {
7259 loadAndClear();
7260 this.b_dummy31 = false;
7261 this.f_dummy31 = 0;
7262 }
7263
7264 // optional int32 dummy32 = 32;
7265 private int f_dummy32 = 0;
7266 private boolean b_dummy32;
7267
7268 public boolean hasDummy32() {
7269 return this.b_dummy32;
7270 }
7271
7272 public int getDummy32() {
7273 return this.f_dummy32;
7274 }
7275
7276 public T setDummy32(int dummy32) {
7277 loadAndClear();
7278 this.b_dummy32 = true;
7279 this.f_dummy32 = dummy32;
7280 return (T)this;
7281 }
7282
7283 public void clearDummy32() {
7284 loadAndClear();
7285 this.b_dummy32 = false;
7286 this.f_dummy32 = 0;
7287 }
7288
7289 // required int32 c = 33;
7290 private int f_c = 0;
7291 private boolean b_c;
7292
7293 public boolean hasC() {
7294 return this.b_c;
7295 }
7296
7297 public int getC() {
7298 return this.f_c;
7299 }
7300
7301 public T setC(int c) {
7302 loadAndClear();
7303 this.b_c = true;
7304 this.f_c = c;
7305 return (T)this;
7306 }
7307
7308 public void clearC() {
7309 loadAndClear();
7310 this.b_c = false;
7311 this.f_c = 0;
7312 }
7313
7314 }
7315
7316
7317 static public final class TestRequiredForeign extends TestRequiredForeignBase<TestRequiredForeign> {
7318
7319 public java.util.ArrayList<String> missingFields() {
7320 java.util.ArrayList<String> missingFields = super.missingFields();
7321 if( hasOptionalMessage() ) {
7322 try {
7323 getOptionalMessage().assertInitialized();
7324 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
7325 missingFields.addAll(prefix(e.getMissingFields(),"optional_message."));
7326 }
7327 }
7328 if( hasRepeatedMessage() ) {
7329 java.util.List<TestRequired> l = getRepeatedMessageList();
7330 for( int i=0; i < l.size(); i++ ) {
7331 try {
7332 l.get(i).assertInitialized();
7333 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
7334 missingFields.addAll(prefix(e.getMissingFields(),"repeated_message["+i+"]"));
7335 }
7336 }
7337 }
7338 return missingFields;
7339 }
7340
7341 public void clear() {
7342 super.clear();
7343 clearOptionalMessage();
7344 clearRepeatedMessage();
7345 clearDummy();
7346 }
7347
7348 public TestRequiredForeign clone() {
7349 return new TestRequiredForeign().mergeFrom(this);
7350 }
7351
7352 public TestRequiredForeign mergeFrom(TestRequiredForeign other) {
7353 if (other.hasOptionalMessage()) {
7354 if (hasOptionalMessage()) {
7355 getOptionalMessage().mergeFrom(other.getOptionalMessage());
7356 } else {
7357 setOptionalMessage(other.getOptionalMessage().clone());
7358 }
7359 }
7360 if (other.hasRepeatedMessage()) {
7361 for(TestRequired element: other.getRepeatedMessageList() ) {
7362 getRepeatedMessageList().add(element.clone());
7363 }
7364 }
7365 if (other.hasDummy()) {
7366 setDummy(other.getDummy());
7367 }
7368 return this;
7369 }
7370
7371 public int serializedSizeUnframed() {
7372 if (memoizedSerializedSize != -1)
7373 return memoizedSerializedSize;
7374
7375 int size = 0;
7376 if (hasOptionalMessage()) {
7377 size += computeMessageSize(1, getOptionalMessage());
7378 }
7379 if (hasRepeatedMessage()) {
7380 for (TestRequired i : getRepeatedMessageList()) {
7381 size += computeMessageSize(2, i);
7382 }
7383 }
7384 if (hasDummy()) {
7385 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(3, getDummy());
7386 }
7387 memoizedSerializedSize = size;
7388 return size;
7389 }
7390
7391 public TestRequiredForeign mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
7392 while (true) {
7393 int tag = input.readTag();
7394 if ((tag & 0x07) == 4) {
7395 return this;
7396 }
7397 switch (tag) {
7398 case 0:
7399 return this;
7400 default: {
7401 break;
7402 }
7403 case 10:
7404 if (hasOptionalMessage()) {
7405 getOptionalMessage().mergeFramed(input);
7406 } else {
7407 setOptionalMessage(new TestRequired().mergeFramed(input));
7408 }
7409 break;
7410 case 18:
7411 getRepeatedMessageList().add(new TestRequired().mergeFramed(input));
7412 break;
7413 case 24:
7414 setDummy(input.readInt32());
7415 break;
7416 }
7417 }
7418 }
7419 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
7420 if (hasOptionalMessage()) {
7421 writeMessage(output, 1, getOptionalMessage());
7422 }
7423 if (hasRepeatedMessage()) {
7424 for (TestRequired i : getRepeatedMessageList()) {
7425 writeMessage(output, 2, i);
7426 }
7427 }
7428 if (hasDummy()) {
7429 output.writeInt32(3, getDummy());
7430 }
7431 }
7432
7433 public static TestRequiredForeign parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7434 return new TestRequiredForeign().mergeUnframed(data).checktInitialized();
7435 }
7436
7437 public static TestRequiredForeign parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7438 return new TestRequiredForeign().mergeUnframed(data).checktInitialized();
7439 }
7440
7441 public static TestRequiredForeign parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7442 return new TestRequiredForeign().mergeUnframed(data).checktInitialized();
7443 }
7444
7445 public static TestRequiredForeign parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7446 return new TestRequiredForeign().mergeUnframed(data).checktInitialized();
7447 }
7448
7449 public static TestRequiredForeign parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7450 return new TestRequiredForeign().mergeFramed(data).checktInitialized();
7451 }
7452
7453 public static TestRequiredForeign parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7454 return new TestRequiredForeign().mergeFramed(data).checktInitialized();
7455 }
7456
7457 public static TestRequiredForeign parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7458 return new TestRequiredForeign().mergeFramed(data).checktInitialized();
7459 }
7460
7461 public static TestRequiredForeign parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7462 return new TestRequiredForeign().mergeFramed(data).checktInitialized();
7463 }
7464
7465 public String toString() {
7466 return toString(new java.lang.StringBuilder(), "").toString();
7467 }
7468
7469 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
7470 if( hasOptionalMessage() ) {
7471 sb.append(prefix+"optional_message {\n");
7472 getOptionalMessage().toString(sb, prefix+" ");
7473 sb.append(prefix+"}\n");
7474 }
7475 if( hasRepeatedMessage() ) {
7476 java.util.List<TestRequired> l = getRepeatedMessageList();
7477 for( int i=0; i < l.size(); i++ ) {
7478 sb.append(prefix+"repeated_message["+i+"] {\n");
7479 l.get(i).toString(sb, prefix+" ");
7480 sb.append(prefix+"}\n");
7481 }
7482 }
7483 if( hasDummy() ) {
7484 sb.append(prefix+"dummy: ");
7485 sb.append(getDummy());
7486 sb.append("\n");
7487 }
7488 return sb;
7489 }
7490
7491 public boolean equals(Object obj) {
7492 if( obj==this )
7493 return true;
7494
7495 if( obj==null || obj.getClass()!=TestRequiredForeign.class )
7496 return false;
7497
7498 return equals((TestRequiredForeign)obj);
7499 }
7500
7501 public boolean equals(TestRequiredForeign obj) {
7502 if (hasOptionalMessage() ^ obj.hasOptionalMessage() )
7503 return false;
7504 if (hasOptionalMessage() && ( !getOptionalMessage().equals(obj.getOptionalMessage()) ))
7505 return false;
7506 if (hasRepeatedMessage() ^ obj.hasRepeatedMessage() )
7507 return false;
7508 if (hasRepeatedMessage() && ( !getRepeatedMessageList().equals(obj.getRepeatedMessageList()) ))
7509 return false;
7510 if (hasDummy() ^ obj.hasDummy() )
7511 return false;
7512 if (hasDummy() && ( getDummy()!=obj.getDummy() ))
7513 return false;
7514 return true;
7515 }
7516
7517 public int hashCode() {
7518 int rc=1425518883;
7519 if (hasOptionalMessage()) {
7520 rc ^= ( -356353945^getOptionalMessage().hashCode() );
7521 }
7522 if (hasRepeatedMessage()) {
7523 rc ^= ( 305763085^getRepeatedMessageList().hashCode() );
7524 }
7525 if (hasDummy()) {
7526 rc ^= ( 66393224^getDummy() );
7527 }
7528 return rc;
7529 }
7530
7531 }
7532
7533 static abstract class TestRequiredForeignBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
7534
7535 // optional TestRequired optional_message = 1;
7536 private TestRequired f_optionalMessage = null;
7537
7538 public boolean hasOptionalMessage() {
7539 return this.f_optionalMessage!=null;
7540 }
7541
7542 public TestRequired getOptionalMessage() {
7543 if( this.f_optionalMessage == null ) {
7544 this.f_optionalMessage = new TestRequired();
7545 }
7546 return this.f_optionalMessage;
7547 }
7548
7549 public T setOptionalMessage(TestRequired optionalMessage) {
7550 loadAndClear();
7551 this.f_optionalMessage = optionalMessage;
7552 return (T)this;
7553 }
7554
7555 public void clearOptionalMessage() {
7556 loadAndClear();
7557 this.f_optionalMessage = null;
7558 }
7559
7560 // repeated TestRequired repeated_message = 2;
7561 private java.util.List<TestRequired> f_repeatedMessage;
7562
7563 public boolean hasRepeatedMessage() {
7564 return this.f_repeatedMessage!=null && !this.f_repeatedMessage.isEmpty();
7565 }
7566
7567 public java.util.List<TestRequired> getRepeatedMessageList() {
7568 if( this.f_repeatedMessage == null ) {
7569 this.f_repeatedMessage = new java.util.ArrayList<TestRequired>();
7570 }
7571 return this.f_repeatedMessage;
7572 }
7573
7574 public T setRepeatedMessageList(java.util.List<TestRequired> repeatedMessage) {
7575 loadAndClear();
7576 this.f_repeatedMessage = repeatedMessage;
7577 return (T)this;
7578 }
7579
7580 public int getRepeatedMessageCount() {
7581 if( this.f_repeatedMessage == null ) {
7582 return 0;
7583 }
7584 return this.f_repeatedMessage.size();
7585 }
7586
7587 public TestRequired getRepeatedMessage(int index) {
7588 if( this.f_repeatedMessage == null ) {
7589 return null;
7590 }
7591 return this.f_repeatedMessage.get(index);
7592 }
7593
7594 public T setRepeatedMessage(int index, TestRequired value) {
7595 loadAndClear();
7596 getRepeatedMessageList().set(index, value);
7597 return (T)this;
7598 }
7599
7600 public T addRepeatedMessage(TestRequired value) {
7601 loadAndClear();
7602 getRepeatedMessageList().add(value);
7603 return (T)this;
7604 }
7605
7606 public T addAllRepeatedMessage(java.lang.Iterable<? extends TestRequired> collection) {
7607 loadAndClear();
7608 super.addAll(collection, getRepeatedMessageList());
7609 return (T)this;
7610 }
7611
7612 public void clearRepeatedMessage() {
7613 loadAndClear();
7614 this.f_repeatedMessage = null;
7615 }
7616
7617 // optional int32 dummy = 3;
7618 private int f_dummy = 0;
7619 private boolean b_dummy;
7620
7621 public boolean hasDummy() {
7622 return this.b_dummy;
7623 }
7624
7625 public int getDummy() {
7626 return this.f_dummy;
7627 }
7628
7629 public T setDummy(int dummy) {
7630 loadAndClear();
7631 this.b_dummy = true;
7632 this.f_dummy = dummy;
7633 return (T)this;
7634 }
7635
7636 public void clearDummy() {
7637 loadAndClear();
7638 this.b_dummy = false;
7639 this.f_dummy = 0;
7640 }
7641
7642 }
7643
7644
7645 static public final class TestForeignNested extends TestForeignNestedBase<TestForeignNested> {
7646
7647 public java.util.ArrayList<String> missingFields() {
7648 java.util.ArrayList<String> missingFields = super.missingFields();
7649 if( hasForeignNested() ) {
7650 try {
7651 getForeignNested().assertInitialized();
7652 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
7653 missingFields.addAll(prefix(e.getMissingFields(),"foreign_nested."));
7654 }
7655 }
7656 return missingFields;
7657 }
7658
7659 public void clear() {
7660 super.clear();
7661 clearForeignNested();
7662 }
7663
7664 public TestForeignNested clone() {
7665 return new TestForeignNested().mergeFrom(this);
7666 }
7667
7668 public TestForeignNested mergeFrom(TestForeignNested other) {
7669 if (other.hasForeignNested()) {
7670 if (hasForeignNested()) {
7671 getForeignNested().mergeFrom(other.getForeignNested());
7672 } else {
7673 setForeignNested(other.getForeignNested().clone());
7674 }
7675 }
7676 return this;
7677 }
7678
7679 public int serializedSizeUnframed() {
7680 if (memoizedSerializedSize != -1)
7681 return memoizedSerializedSize;
7682
7683 int size = 0;
7684 if (hasForeignNested()) {
7685 size += computeMessageSize(1, getForeignNested());
7686 }
7687 memoizedSerializedSize = size;
7688 return size;
7689 }
7690
7691 public TestForeignNested mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
7692 while (true) {
7693 int tag = input.readTag();
7694 if ((tag & 0x07) == 4) {
7695 return this;
7696 }
7697 switch (tag) {
7698 case 0:
7699 return this;
7700 default: {
7701 break;
7702 }
7703 case 10:
7704 if (hasForeignNested()) {
7705 getForeignNested().mergeFramed(input);
7706 } else {
7707 setForeignNested(new TestAllTypes.NestedMessage().mergeFramed(input));
7708 }
7709 break;
7710 }
7711 }
7712 }
7713 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
7714 if (hasForeignNested()) {
7715 writeMessage(output, 1, getForeignNested());
7716 }
7717 }
7718
7719 public static TestForeignNested parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7720 return new TestForeignNested().mergeUnframed(data).checktInitialized();
7721 }
7722
7723 public static TestForeignNested parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7724 return new TestForeignNested().mergeUnframed(data).checktInitialized();
7725 }
7726
7727 public static TestForeignNested parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7728 return new TestForeignNested().mergeUnframed(data).checktInitialized();
7729 }
7730
7731 public static TestForeignNested parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7732 return new TestForeignNested().mergeUnframed(data).checktInitialized();
7733 }
7734
7735 public static TestForeignNested parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7736 return new TestForeignNested().mergeFramed(data).checktInitialized();
7737 }
7738
7739 public static TestForeignNested parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7740 return new TestForeignNested().mergeFramed(data).checktInitialized();
7741 }
7742
7743 public static TestForeignNested parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7744 return new TestForeignNested().mergeFramed(data).checktInitialized();
7745 }
7746
7747 public static TestForeignNested parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7748 return new TestForeignNested().mergeFramed(data).checktInitialized();
7749 }
7750
7751 public String toString() {
7752 return toString(new java.lang.StringBuilder(), "").toString();
7753 }
7754
7755 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
7756 if( hasForeignNested() ) {
7757 sb.append(prefix+"foreign_nested {\n");
7758 getForeignNested().toString(sb, prefix+" ");
7759 sb.append(prefix+"}\n");
7760 }
7761 return sb;
7762 }
7763
7764 public boolean equals(Object obj) {
7765 if( obj==this )
7766 return true;
7767
7768 if( obj==null || obj.getClass()!=TestForeignNested.class )
7769 return false;
7770
7771 return equals((TestForeignNested)obj);
7772 }
7773
7774 public boolean equals(TestForeignNested obj) {
7775 if (hasForeignNested() ^ obj.hasForeignNested() )
7776 return false;
7777 if (hasForeignNested() && ( !getForeignNested().equals(obj.getForeignNested()) ))
7778 return false;
7779 return true;
7780 }
7781
7782 public int hashCode() {
7783 int rc=1249675097;
7784 if (hasForeignNested()) {
7785 rc ^= ( 505614027^getForeignNested().hashCode() );
7786 }
7787 return rc;
7788 }
7789
7790 }
7791
7792 static abstract class TestForeignNestedBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
7793
7794 // optional TestAllTypes.NestedMessage foreign_nested = 1;
7795 private TestAllTypes.NestedMessage f_foreignNested = null;
7796
7797 public boolean hasForeignNested() {
7798 return this.f_foreignNested!=null;
7799 }
7800
7801 public TestAllTypes.NestedMessage getForeignNested() {
7802 if( this.f_foreignNested == null ) {
7803 this.f_foreignNested = new TestAllTypes.NestedMessage();
7804 }
7805 return this.f_foreignNested;
7806 }
7807
7808 public T setForeignNested(TestAllTypes.NestedMessage foreignNested) {
7809 loadAndClear();
7810 this.f_foreignNested = foreignNested;
7811 return (T)this;
7812 }
7813
7814 public void clearForeignNested() {
7815 loadAndClear();
7816 this.f_foreignNested = null;
7817 }
7818
7819 }
7820
7821
7822 static public final class TestEmptyMessage extends TestEmptyMessageBase<TestEmptyMessage> {
7823
7824 public java.util.ArrayList<String> missingFields() {
7825 java.util.ArrayList<String> missingFields = super.missingFields();
7826 return missingFields;
7827 }
7828
7829 public void clear() {
7830 super.clear();
7831 }
7832
7833 public TestEmptyMessage clone() {
7834 return new TestEmptyMessage().mergeFrom(this);
7835 }
7836
7837 public TestEmptyMessage mergeFrom(TestEmptyMessage other) {
7838 return this;
7839 }
7840
7841 public int serializedSizeUnframed() {
7842 if (memoizedSerializedSize != -1)
7843 return memoizedSerializedSize;
7844
7845 int size = 0;
7846 memoizedSerializedSize = size;
7847 return size;
7848 }
7849
7850 public TestEmptyMessage mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
7851 while (true) {
7852 int tag = input.readTag();
7853 if ((tag & 0x07) == 4) {
7854 return this;
7855 }
7856 switch (tag) {
7857 case 0:
7858 return this;
7859 default: {
7860 break;
7861 }
7862 }
7863 }
7864 }
7865 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
7866 }
7867
7868 public static TestEmptyMessage parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7869 return new TestEmptyMessage().mergeUnframed(data).checktInitialized();
7870 }
7871
7872 public static TestEmptyMessage parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7873 return new TestEmptyMessage().mergeUnframed(data).checktInitialized();
7874 }
7875
7876 public static TestEmptyMessage parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7877 return new TestEmptyMessage().mergeUnframed(data).checktInitialized();
7878 }
7879
7880 public static TestEmptyMessage parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7881 return new TestEmptyMessage().mergeUnframed(data).checktInitialized();
7882 }
7883
7884 public static TestEmptyMessage parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7885 return new TestEmptyMessage().mergeFramed(data).checktInitialized();
7886 }
7887
7888 public static TestEmptyMessage parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7889 return new TestEmptyMessage().mergeFramed(data).checktInitialized();
7890 }
7891
7892 public static TestEmptyMessage parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7893 return new TestEmptyMessage().mergeFramed(data).checktInitialized();
7894 }
7895
7896 public static TestEmptyMessage parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7897 return new TestEmptyMessage().mergeFramed(data).checktInitialized();
7898 }
7899
7900 public String toString() {
7901 return toString(new java.lang.StringBuilder(), "").toString();
7902 }
7903
7904 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
7905 return sb;
7906 }
7907
7908 public boolean equals(Object obj) {
7909 if( obj==this )
7910 return true;
7911
7912 if( obj==null || obj.getClass()!=TestEmptyMessage.class )
7913 return false;
7914
7915 return equals((TestEmptyMessage)obj);
7916 }
7917
7918 public boolean equals(TestEmptyMessage obj) {
7919 return true;
7920 }
7921
7922 public int hashCode() {
7923 int rc=1046840268;
7924 return rc;
7925 }
7926
7927 }
7928
7929 static abstract class TestEmptyMessageBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
7930
7931 }
7932
7933
7934 static public final class TestEmptyMessageWithExtensions extends TestEmptyMessageWithExtensionsBase<TestEmptyMessageWithExtensions> {
7935
7936 public java.util.ArrayList<String> missingFields() {
7937 java.util.ArrayList<String> missingFields = super.missingFields();
7938 return missingFields;
7939 }
7940
7941 public void clear() {
7942 super.clear();
7943 }
7944
7945 public TestEmptyMessageWithExtensions clone() {
7946 return new TestEmptyMessageWithExtensions().mergeFrom(this);
7947 }
7948
7949 public TestEmptyMessageWithExtensions mergeFrom(TestEmptyMessageWithExtensions other) {
7950 return this;
7951 }
7952
7953 public int serializedSizeUnframed() {
7954 if (memoizedSerializedSize != -1)
7955 return memoizedSerializedSize;
7956
7957 int size = 0;
7958 memoizedSerializedSize = size;
7959 return size;
7960 }
7961
7962 public TestEmptyMessageWithExtensions mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
7963 while (true) {
7964 int tag = input.readTag();
7965 if ((tag & 0x07) == 4) {
7966 return this;
7967 }
7968 switch (tag) {
7969 case 0:
7970 return this;
7971 default: {
7972 break;
7973 }
7974 }
7975 }
7976 }
7977 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
7978 }
7979
7980 public static TestEmptyMessageWithExtensions parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7981 return new TestEmptyMessageWithExtensions().mergeUnframed(data).checktInitialized();
7982 }
7983
7984 public static TestEmptyMessageWithExtensions parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7985 return new TestEmptyMessageWithExtensions().mergeUnframed(data).checktInitialized();
7986 }
7987
7988 public static TestEmptyMessageWithExtensions parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
7989 return new TestEmptyMessageWithExtensions().mergeUnframed(data).checktInitialized();
7990 }
7991
7992 public static TestEmptyMessageWithExtensions parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7993 return new TestEmptyMessageWithExtensions().mergeUnframed(data).checktInitialized();
7994 }
7995
7996 public static TestEmptyMessageWithExtensions parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
7997 return new TestEmptyMessageWithExtensions().mergeFramed(data).checktInitialized();
7998 }
7999
8000 public static TestEmptyMessageWithExtensions parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8001 return new TestEmptyMessageWithExtensions().mergeFramed(data).checktInitialized();
8002 }
8003
8004 public static TestEmptyMessageWithExtensions parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8005 return new TestEmptyMessageWithExtensions().mergeFramed(data).checktInitialized();
8006 }
8007
8008 public static TestEmptyMessageWithExtensions parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8009 return new TestEmptyMessageWithExtensions().mergeFramed(data).checktInitialized();
8010 }
8011
8012 public String toString() {
8013 return toString(new java.lang.StringBuilder(), "").toString();
8014 }
8015
8016 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
8017 return sb;
8018 }
8019
8020 public boolean equals(Object obj) {
8021 if( obj==this )
8022 return true;
8023
8024 if( obj==null || obj.getClass()!=TestEmptyMessageWithExtensions.class )
8025 return false;
8026
8027 return equals((TestEmptyMessageWithExtensions)obj);
8028 }
8029
8030 public boolean equals(TestEmptyMessageWithExtensions obj) {
8031 return true;
8032 }
8033
8034 public int hashCode() {
8035 int rc=643429478;
8036 return rc;
8037 }
8038
8039 }
8040
8041 static abstract class TestEmptyMessageWithExtensionsBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
8042
8043 }
8044
8045
8046 static public final class TestReallyLargeTagNumber extends TestReallyLargeTagNumberBase<TestReallyLargeTagNumber> {
8047
8048 public java.util.ArrayList<String> missingFields() {
8049 java.util.ArrayList<String> missingFields = super.missingFields();
8050 return missingFields;
8051 }
8052
8053 public void clear() {
8054 super.clear();
8055 clearA();
8056 clearBb();
8057 }
8058
8059 public TestReallyLargeTagNumber clone() {
8060 return new TestReallyLargeTagNumber().mergeFrom(this);
8061 }
8062
8063 public TestReallyLargeTagNumber mergeFrom(TestReallyLargeTagNumber other) {
8064 if (other.hasA()) {
8065 setA(other.getA());
8066 }
8067 if (other.hasBb()) {
8068 setBb(other.getBb());
8069 }
8070 return this;
8071 }
8072
8073 public int serializedSizeUnframed() {
8074 if (memoizedSerializedSize != -1)
8075 return memoizedSerializedSize;
8076
8077 int size = 0;
8078 if (hasA()) {
8079 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getA());
8080 }
8081 if (hasBb()) {
8082 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(268435455, getBb());
8083 }
8084 memoizedSerializedSize = size;
8085 return size;
8086 }
8087
8088 public TestReallyLargeTagNumber mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
8089 while (true) {
8090 int tag = input.readTag();
8091 if ((tag & 0x07) == 4) {
8092 return this;
8093 }
8094 switch (tag) {
8095 case 0:
8096 return this;
8097 default: {
8098 break;
8099 }
8100 case 8:
8101 setA(input.readInt32());
8102 break;
8103 case 2147483640:
8104 setBb(input.readInt32());
8105 break;
8106 }
8107 }
8108 }
8109 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
8110 if (hasA()) {
8111 output.writeInt32(1, getA());
8112 }
8113 if (hasBb()) {
8114 output.writeInt32(268435455, getBb());
8115 }
8116 }
8117
8118 public static TestReallyLargeTagNumber parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8119 return new TestReallyLargeTagNumber().mergeUnframed(data).checktInitialized();
8120 }
8121
8122 public static TestReallyLargeTagNumber parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8123 return new TestReallyLargeTagNumber().mergeUnframed(data).checktInitialized();
8124 }
8125
8126 public static TestReallyLargeTagNumber parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8127 return new TestReallyLargeTagNumber().mergeUnframed(data).checktInitialized();
8128 }
8129
8130 public static TestReallyLargeTagNumber parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8131 return new TestReallyLargeTagNumber().mergeUnframed(data).checktInitialized();
8132 }
8133
8134 public static TestReallyLargeTagNumber parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8135 return new TestReallyLargeTagNumber().mergeFramed(data).checktInitialized();
8136 }
8137
8138 public static TestReallyLargeTagNumber parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8139 return new TestReallyLargeTagNumber().mergeFramed(data).checktInitialized();
8140 }
8141
8142 public static TestReallyLargeTagNumber parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8143 return new TestReallyLargeTagNumber().mergeFramed(data).checktInitialized();
8144 }
8145
8146 public static TestReallyLargeTagNumber parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8147 return new TestReallyLargeTagNumber().mergeFramed(data).checktInitialized();
8148 }
8149
8150 public String toString() {
8151 return toString(new java.lang.StringBuilder(), "").toString();
8152 }
8153
8154 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
8155 if( hasA() ) {
8156 sb.append(prefix+"a: ");
8157 sb.append(getA());
8158 sb.append("\n");
8159 }
8160 if( hasBb() ) {
8161 sb.append(prefix+"bb: ");
8162 sb.append(getBb());
8163 sb.append("\n");
8164 }
8165 return sb;
8166 }
8167
8168 public boolean equals(Object obj) {
8169 if( obj==this )
8170 return true;
8171
8172 if( obj==null || obj.getClass()!=TestReallyLargeTagNumber.class )
8173 return false;
8174
8175 return equals((TestReallyLargeTagNumber)obj);
8176 }
8177
8178 public boolean equals(TestReallyLargeTagNumber obj) {
8179 if (hasA() ^ obj.hasA() )
8180 return false;
8181 if (hasA() && ( getA()!=obj.getA() ))
8182 return false;
8183 if (hasBb() ^ obj.hasBb() )
8184 return false;
8185 if (hasBb() && ( getBb()!=obj.getBb() ))
8186 return false;
8187 return true;
8188 }
8189
8190 public int hashCode() {
8191 int rc=-1888395547;
8192 if (hasA()) {
8193 rc ^= ( 65^getA() );
8194 }
8195 if (hasBb()) {
8196 rc ^= ( 2144^getBb() );
8197 }
8198 return rc;
8199 }
8200
8201 }
8202
8203 static abstract class TestReallyLargeTagNumberBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
8204
8205 // optional int32 a = 1;
8206 private int f_a = 0;
8207 private boolean b_a;
8208
8209 public boolean hasA() {
8210 return this.b_a;
8211 }
8212
8213 public int getA() {
8214 return this.f_a;
8215 }
8216
8217 public T setA(int a) {
8218 loadAndClear();
8219 this.b_a = true;
8220 this.f_a = a;
8221 return (T)this;
8222 }
8223
8224 public void clearA() {
8225 loadAndClear();
8226 this.b_a = false;
8227 this.f_a = 0;
8228 }
8229
8230 // optional int32 bb = 268435455;
8231 private int f_bb = 0;
8232 private boolean b_bb;
8233
8234 public boolean hasBb() {
8235 return this.b_bb;
8236 }
8237
8238 public int getBb() {
8239 return this.f_bb;
8240 }
8241
8242 public T setBb(int bb) {
8243 loadAndClear();
8244 this.b_bb = true;
8245 this.f_bb = bb;
8246 return (T)this;
8247 }
8248
8249 public void clearBb() {
8250 loadAndClear();
8251 this.b_bb = false;
8252 this.f_bb = 0;
8253 }
8254
8255 }
8256
8257
8258 static public final class TestRecursiveMessage extends TestRecursiveMessageBase<TestRecursiveMessage> {
8259
8260 public java.util.ArrayList<String> missingFields() {
8261 java.util.ArrayList<String> missingFields = super.missingFields();
8262 if( hasA() ) {
8263 try {
8264 getA().assertInitialized();
8265 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
8266 missingFields.addAll(prefix(e.getMissingFields(),"a."));
8267 }
8268 }
8269 return missingFields;
8270 }
8271
8272 public void clear() {
8273 super.clear();
8274 clearA();
8275 clearI();
8276 }
8277
8278 public TestRecursiveMessage clone() {
8279 return new TestRecursiveMessage().mergeFrom(this);
8280 }
8281
8282 public TestRecursiveMessage mergeFrom(TestRecursiveMessage other) {
8283 if (other.hasA()) {
8284 if (hasA()) {
8285 getA().mergeFrom(other.getA());
8286 } else {
8287 setA(other.getA().clone());
8288 }
8289 }
8290 if (other.hasI()) {
8291 setI(other.getI());
8292 }
8293 return this;
8294 }
8295
8296 public int serializedSizeUnframed() {
8297 if (memoizedSerializedSize != -1)
8298 return memoizedSerializedSize;
8299
8300 int size = 0;
8301 if (hasA()) {
8302 size += computeMessageSize(1, getA());
8303 }
8304 if (hasI()) {
8305 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(2, getI());
8306 }
8307 memoizedSerializedSize = size;
8308 return size;
8309 }
8310
8311 public TestRecursiveMessage mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
8312 while (true) {
8313 int tag = input.readTag();
8314 if ((tag & 0x07) == 4) {
8315 return this;
8316 }
8317 switch (tag) {
8318 case 0:
8319 return this;
8320 default: {
8321 break;
8322 }
8323 case 10:
8324 if (hasA()) {
8325 getA().mergeFramed(input);
8326 } else {
8327 setA(new TestRecursiveMessage().mergeFramed(input));
8328 }
8329 break;
8330 case 16:
8331 setI(input.readInt32());
8332 break;
8333 }
8334 }
8335 }
8336 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
8337 if (hasA()) {
8338 writeMessage(output, 1, getA());
8339 }
8340 if (hasI()) {
8341 output.writeInt32(2, getI());
8342 }
8343 }
8344
8345 public static TestRecursiveMessage parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8346 return new TestRecursiveMessage().mergeUnframed(data).checktInitialized();
8347 }
8348
8349 public static TestRecursiveMessage parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8350 return new TestRecursiveMessage().mergeUnframed(data).checktInitialized();
8351 }
8352
8353 public static TestRecursiveMessage parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8354 return new TestRecursiveMessage().mergeUnframed(data).checktInitialized();
8355 }
8356
8357 public static TestRecursiveMessage parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8358 return new TestRecursiveMessage().mergeUnframed(data).checktInitialized();
8359 }
8360
8361 public static TestRecursiveMessage parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8362 return new TestRecursiveMessage().mergeFramed(data).checktInitialized();
8363 }
8364
8365 public static TestRecursiveMessage parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8366 return new TestRecursiveMessage().mergeFramed(data).checktInitialized();
8367 }
8368
8369 public static TestRecursiveMessage parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8370 return new TestRecursiveMessage().mergeFramed(data).checktInitialized();
8371 }
8372
8373 public static TestRecursiveMessage parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8374 return new TestRecursiveMessage().mergeFramed(data).checktInitialized();
8375 }
8376
8377 public String toString() {
8378 return toString(new java.lang.StringBuilder(), "").toString();
8379 }
8380
8381 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
8382 if( hasA() ) {
8383 sb.append(prefix+"a {\n");
8384 getA().toString(sb, prefix+" ");
8385 sb.append(prefix+"}\n");
8386 }
8387 if( hasI() ) {
8388 sb.append(prefix+"i: ");
8389 sb.append(getI());
8390 sb.append("\n");
8391 }
8392 return sb;
8393 }
8394
8395 public boolean equals(Object obj) {
8396 if( obj==this )
8397 return true;
8398
8399 if( obj==null || obj.getClass()!=TestRecursiveMessage.class )
8400 return false;
8401
8402 return equals((TestRecursiveMessage)obj);
8403 }
8404
8405 public boolean equals(TestRecursiveMessage obj) {
8406 if (hasA() ^ obj.hasA() )
8407 return false;
8408 if (hasA() && ( !getA().equals(obj.getA()) ))
8409 return false;
8410 if (hasI() ^ obj.hasI() )
8411 return false;
8412 if (hasI() && ( getI()!=obj.getI() ))
8413 return false;
8414 return true;
8415 }
8416
8417 public int hashCode() {
8418 int rc=-2143170489;
8419 if (hasA()) {
8420 rc ^= ( 65^getA().hashCode() );
8421 }
8422 if (hasI()) {
8423 rc ^= ( 73^getI() );
8424 }
8425 return rc;
8426 }
8427
8428 }
8429
8430 static abstract class TestRecursiveMessageBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
8431
8432 // optional TestRecursiveMessage a = 1;
8433 private TestRecursiveMessage f_a = null;
8434
8435 public boolean hasA() {
8436 return this.f_a!=null;
8437 }
8438
8439 public TestRecursiveMessage getA() {
8440 if( this.f_a == null ) {
8441 this.f_a = new TestRecursiveMessage();
8442 }
8443 return this.f_a;
8444 }
8445
8446 public T setA(TestRecursiveMessage a) {
8447 loadAndClear();
8448 this.f_a = a;
8449 return (T)this;
8450 }
8451
8452 public void clearA() {
8453 loadAndClear();
8454 this.f_a = null;
8455 }
8456
8457 // optional int32 i = 2;
8458 private int f_i = 0;
8459 private boolean b_i;
8460
8461 public boolean hasI() {
8462 return this.b_i;
8463 }
8464
8465 public int getI() {
8466 return this.f_i;
8467 }
8468
8469 public T setI(int i) {
8470 loadAndClear();
8471 this.b_i = true;
8472 this.f_i = i;
8473 return (T)this;
8474 }
8475
8476 public void clearI() {
8477 loadAndClear();
8478 this.b_i = false;
8479 this.f_i = 0;
8480 }
8481
8482 }
8483
8484
8485 static public final class TestMutualRecursionA extends TestMutualRecursionABase<TestMutualRecursionA> {
8486
8487 public java.util.ArrayList<String> missingFields() {
8488 java.util.ArrayList<String> missingFields = super.missingFields();
8489 if( hasBb() ) {
8490 try {
8491 getBb().assertInitialized();
8492 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
8493 missingFields.addAll(prefix(e.getMissingFields(),"bb."));
8494 }
8495 }
8496 return missingFields;
8497 }
8498
8499 public void clear() {
8500 super.clear();
8501 clearBb();
8502 }
8503
8504 public TestMutualRecursionA clone() {
8505 return new TestMutualRecursionA().mergeFrom(this);
8506 }
8507
8508 public TestMutualRecursionA mergeFrom(TestMutualRecursionA other) {
8509 if (other.hasBb()) {
8510 if (hasBb()) {
8511 getBb().mergeFrom(other.getBb());
8512 } else {
8513 setBb(other.getBb().clone());
8514 }
8515 }
8516 return this;
8517 }
8518
8519 public int serializedSizeUnframed() {
8520 if (memoizedSerializedSize != -1)
8521 return memoizedSerializedSize;
8522
8523 int size = 0;
8524 if (hasBb()) {
8525 size += computeMessageSize(1, getBb());
8526 }
8527 memoizedSerializedSize = size;
8528 return size;
8529 }
8530
8531 public TestMutualRecursionA mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
8532 while (true) {
8533 int tag = input.readTag();
8534 if ((tag & 0x07) == 4) {
8535 return this;
8536 }
8537 switch (tag) {
8538 case 0:
8539 return this;
8540 default: {
8541 break;
8542 }
8543 case 10:
8544 if (hasBb()) {
8545 getBb().mergeFramed(input);
8546 } else {
8547 setBb(new TestMutualRecursionB().mergeFramed(input));
8548 }
8549 break;
8550 }
8551 }
8552 }
8553 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
8554 if (hasBb()) {
8555 writeMessage(output, 1, getBb());
8556 }
8557 }
8558
8559 public static TestMutualRecursionA parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8560 return new TestMutualRecursionA().mergeUnframed(data).checktInitialized();
8561 }
8562
8563 public static TestMutualRecursionA parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8564 return new TestMutualRecursionA().mergeUnframed(data).checktInitialized();
8565 }
8566
8567 public static TestMutualRecursionA parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8568 return new TestMutualRecursionA().mergeUnframed(data).checktInitialized();
8569 }
8570
8571 public static TestMutualRecursionA parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8572 return new TestMutualRecursionA().mergeUnframed(data).checktInitialized();
8573 }
8574
8575 public static TestMutualRecursionA parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8576 return new TestMutualRecursionA().mergeFramed(data).checktInitialized();
8577 }
8578
8579 public static TestMutualRecursionA parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8580 return new TestMutualRecursionA().mergeFramed(data).checktInitialized();
8581 }
8582
8583 public static TestMutualRecursionA parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8584 return new TestMutualRecursionA().mergeFramed(data).checktInitialized();
8585 }
8586
8587 public static TestMutualRecursionA parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8588 return new TestMutualRecursionA().mergeFramed(data).checktInitialized();
8589 }
8590
8591 public String toString() {
8592 return toString(new java.lang.StringBuilder(), "").toString();
8593 }
8594
8595 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
8596 if( hasBb() ) {
8597 sb.append(prefix+"bb {\n");
8598 getBb().toString(sb, prefix+" ");
8599 sb.append(prefix+"}\n");
8600 }
8601 return sb;
8602 }
8603
8604 public boolean equals(Object obj) {
8605 if( obj==this )
8606 return true;
8607
8608 if( obj==null || obj.getClass()!=TestMutualRecursionA.class )
8609 return false;
8610
8611 return equals((TestMutualRecursionA)obj);
8612 }
8613
8614 public boolean equals(TestMutualRecursionA obj) {
8615 if (hasBb() ^ obj.hasBb() )
8616 return false;
8617 if (hasBb() && ( !getBb().equals(obj.getBb()) ))
8618 return false;
8619 return true;
8620 }
8621
8622 public int hashCode() {
8623 int rc=-536236763;
8624 if (hasBb()) {
8625 rc ^= ( 2144^getBb().hashCode() );
8626 }
8627 return rc;
8628 }
8629
8630 }
8631
8632 static abstract class TestMutualRecursionABase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
8633
8634 // optional TestMutualRecursionB bb = 1;
8635 private TestMutualRecursionB f_bb = null;
8636
8637 public boolean hasBb() {
8638 return this.f_bb!=null;
8639 }
8640
8641 public TestMutualRecursionB getBb() {
8642 if( this.f_bb == null ) {
8643 this.f_bb = new TestMutualRecursionB();
8644 }
8645 return this.f_bb;
8646 }
8647
8648 public T setBb(TestMutualRecursionB bb) {
8649 loadAndClear();
8650 this.f_bb = bb;
8651 return (T)this;
8652 }
8653
8654 public void clearBb() {
8655 loadAndClear();
8656 this.f_bb = null;
8657 }
8658
8659 }
8660
8661
8662 static public final class TestMutualRecursionB extends TestMutualRecursionBBase<TestMutualRecursionB> {
8663
8664 public java.util.ArrayList<String> missingFields() {
8665 java.util.ArrayList<String> missingFields = super.missingFields();
8666 if( hasA() ) {
8667 try {
8668 getA().assertInitialized();
8669 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
8670 missingFields.addAll(prefix(e.getMissingFields(),"a."));
8671 }
8672 }
8673 return missingFields;
8674 }
8675
8676 public void clear() {
8677 super.clear();
8678 clearA();
8679 clearOptionalInt32();
8680 }
8681
8682 public TestMutualRecursionB clone() {
8683 return new TestMutualRecursionB().mergeFrom(this);
8684 }
8685
8686 public TestMutualRecursionB mergeFrom(TestMutualRecursionB other) {
8687 if (other.hasA()) {
8688 if (hasA()) {
8689 getA().mergeFrom(other.getA());
8690 } else {
8691 setA(other.getA().clone());
8692 }
8693 }
8694 if (other.hasOptionalInt32()) {
8695 setOptionalInt32(other.getOptionalInt32());
8696 }
8697 return this;
8698 }
8699
8700 public int serializedSizeUnframed() {
8701 if (memoizedSerializedSize != -1)
8702 return memoizedSerializedSize;
8703
8704 int size = 0;
8705 if (hasA()) {
8706 size += computeMessageSize(1, getA());
8707 }
8708 if (hasOptionalInt32()) {
8709 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(2, getOptionalInt32());
8710 }
8711 memoizedSerializedSize = size;
8712 return size;
8713 }
8714
8715 public TestMutualRecursionB mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
8716 while (true) {
8717 int tag = input.readTag();
8718 if ((tag & 0x07) == 4) {
8719 return this;
8720 }
8721 switch (tag) {
8722 case 0:
8723 return this;
8724 default: {
8725 break;
8726 }
8727 case 10:
8728 if (hasA()) {
8729 getA().mergeFramed(input);
8730 } else {
8731 setA(new TestMutualRecursionA().mergeFramed(input));
8732 }
8733 break;
8734 case 16:
8735 setOptionalInt32(input.readInt32());
8736 break;
8737 }
8738 }
8739 }
8740 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
8741 if (hasA()) {
8742 writeMessage(output, 1, getA());
8743 }
8744 if (hasOptionalInt32()) {
8745 output.writeInt32(2, getOptionalInt32());
8746 }
8747 }
8748
8749 public static TestMutualRecursionB parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8750 return new TestMutualRecursionB().mergeUnframed(data).checktInitialized();
8751 }
8752
8753 public static TestMutualRecursionB parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8754 return new TestMutualRecursionB().mergeUnframed(data).checktInitialized();
8755 }
8756
8757 public static TestMutualRecursionB parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8758 return new TestMutualRecursionB().mergeUnframed(data).checktInitialized();
8759 }
8760
8761 public static TestMutualRecursionB parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8762 return new TestMutualRecursionB().mergeUnframed(data).checktInitialized();
8763 }
8764
8765 public static TestMutualRecursionB parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8766 return new TestMutualRecursionB().mergeFramed(data).checktInitialized();
8767 }
8768
8769 public static TestMutualRecursionB parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8770 return new TestMutualRecursionB().mergeFramed(data).checktInitialized();
8771 }
8772
8773 public static TestMutualRecursionB parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8774 return new TestMutualRecursionB().mergeFramed(data).checktInitialized();
8775 }
8776
8777 public static TestMutualRecursionB parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8778 return new TestMutualRecursionB().mergeFramed(data).checktInitialized();
8779 }
8780
8781 public String toString() {
8782 return toString(new java.lang.StringBuilder(), "").toString();
8783 }
8784
8785 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
8786 if( hasA() ) {
8787 sb.append(prefix+"a {\n");
8788 getA().toString(sb, prefix+" ");
8789 sb.append(prefix+"}\n");
8790 }
8791 if( hasOptionalInt32() ) {
8792 sb.append(prefix+"optional_int32: ");
8793 sb.append(getOptionalInt32());
8794 sb.append("\n");
8795 }
8796 return sb;
8797 }
8798
8799 public boolean equals(Object obj) {
8800 if( obj==this )
8801 return true;
8802
8803 if( obj==null || obj.getClass()!=TestMutualRecursionB.class )
8804 return false;
8805
8806 return equals((TestMutualRecursionB)obj);
8807 }
8808
8809 public boolean equals(TestMutualRecursionB obj) {
8810 if (hasA() ^ obj.hasA() )
8811 return false;
8812 if (hasA() && ( !getA().equals(obj.getA()) ))
8813 return false;
8814 if (hasOptionalInt32() ^ obj.hasOptionalInt32() )
8815 return false;
8816 if (hasOptionalInt32() && ( getOptionalInt32()!=obj.getOptionalInt32() ))
8817 return false;
8818 return true;
8819 }
8820
8821 public int hashCode() {
8822 int rc=-536236762;
8823 if (hasA()) {
8824 rc ^= ( 65^getA().hashCode() );
8825 }
8826 if (hasOptionalInt32()) {
8827 rc ^= ( 1444245230^getOptionalInt32() );
8828 }
8829 return rc;
8830 }
8831
8832 }
8833
8834 static abstract class TestMutualRecursionBBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
8835
8836 // optional TestMutualRecursionA a = 1;
8837 private TestMutualRecursionA f_a = null;
8838
8839 public boolean hasA() {
8840 return this.f_a!=null;
8841 }
8842
8843 public TestMutualRecursionA getA() {
8844 if( this.f_a == null ) {
8845 this.f_a = new TestMutualRecursionA();
8846 }
8847 return this.f_a;
8848 }
8849
8850 public T setA(TestMutualRecursionA a) {
8851 loadAndClear();
8852 this.f_a = a;
8853 return (T)this;
8854 }
8855
8856 public void clearA() {
8857 loadAndClear();
8858 this.f_a = null;
8859 }
8860
8861 // optional int32 optional_int32 = 2;
8862 private int f_optionalInt32 = 0;
8863 private boolean b_optionalInt32;
8864
8865 public boolean hasOptionalInt32() {
8866 return this.b_optionalInt32;
8867 }
8868
8869 public int getOptionalInt32() {
8870 return this.f_optionalInt32;
8871 }
8872
8873 public T setOptionalInt32(int optionalInt32) {
8874 loadAndClear();
8875 this.b_optionalInt32 = true;
8876 this.f_optionalInt32 = optionalInt32;
8877 return (T)this;
8878 }
8879
8880 public void clearOptionalInt32() {
8881 loadAndClear();
8882 this.b_optionalInt32 = false;
8883 this.f_optionalInt32 = 0;
8884 }
8885
8886 }
8887
8888
8889 static public final class TestDupFieldNumber extends TestDupFieldNumberBase<TestDupFieldNumber> {
8890
8891
8892 static public final class Foo extends FooBase<Foo> {
8893
8894 public java.util.ArrayList<String> missingFields() {
8895 java.util.ArrayList<String> missingFields = super.missingFields();
8896 return missingFields;
8897 }
8898
8899 public void clear() {
8900 super.clear();
8901 clearA();
8902 }
8903
8904 public Foo clone() {
8905 return new Foo().mergeFrom(this);
8906 }
8907
8908 public Foo mergeFrom(Foo other) {
8909 if (other.hasA()) {
8910 setA(other.getA());
8911 }
8912 return this;
8913 }
8914
8915 public int serializedSizeUnframed() {
8916 if (memoizedSerializedSize != -1)
8917 return memoizedSerializedSize;
8918
8919 int size = 0;
8920 if (hasA()) {
8921 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getA());
8922 }
8923 memoizedSerializedSize = size;
8924 return size;
8925 }
8926
8927 public Foo mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
8928 while (true) {
8929 int tag = input.readTag();
8930 if ((tag & 0x07) == 4) {
8931 return this;
8932 }
8933 switch (tag) {
8934 case 0:
8935 return this;
8936 default: {
8937 break;
8938 }
8939 case 8:
8940 setA(input.readInt32());
8941 break;
8942 }
8943 }
8944 }
8945 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
8946 if (hasA()) {
8947 output.writeInt32(1, getA());
8948 }
8949 }
8950
8951 public static Foo parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8952 return new Foo().mergeUnframed(data).checktInitialized();
8953 }
8954
8955 public static Foo parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8956 return new Foo().mergeUnframed(data).checktInitialized();
8957 }
8958
8959 public static Foo parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8960 return new Foo().mergeUnframed(data).checktInitialized();
8961 }
8962
8963 public static Foo parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8964 return new Foo().mergeUnframed(data).checktInitialized();
8965 }
8966
8967 public static Foo parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8968 return new Foo().mergeFramed(data).checktInitialized();
8969 }
8970
8971 public static Foo parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8972 return new Foo().mergeFramed(data).checktInitialized();
8973 }
8974
8975 public static Foo parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
8976 return new Foo().mergeFramed(data).checktInitialized();
8977 }
8978
8979 public static Foo parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
8980 return new Foo().mergeFramed(data).checktInitialized();
8981 }
8982
8983 public String toString() {
8984 return toString(new java.lang.StringBuilder(), "").toString();
8985 }
8986
8987 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
8988 if( hasA() ) {
8989 sb.append(prefix+"a: ");
8990 sb.append(getA());
8991 sb.append("\n");
8992 }
8993 return sb;
8994 }
8995
8996 public boolean equals(Object obj) {
8997 if( obj==this )
8998 return true;
8999
9000 if( obj==null || obj.getClass()!=Foo.class )
9001 return false;
9002
9003 return equals((Foo)obj);
9004 }
9005
9006 public boolean equals(Foo obj) {
9007 if (hasA() ^ obj.hasA() )
9008 return false;
9009 if (hasA() && ( getA()!=obj.getA() ))
9010 return false;
9011 return true;
9012 }
9013
9014 public int hashCode() {
9015 int rc=70822;
9016 if (hasA()) {
9017 rc ^= ( 65^getA() );
9018 }
9019 return rc;
9020 }
9021
9022 }
9023
9024 static abstract class FooBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
9025
9026 // optional int32 a = 1;
9027 private int f_a = 0;
9028 private boolean b_a;
9029
9030 public boolean hasA() {
9031 return this.b_a;
9032 }
9033
9034 public int getA() {
9035 return this.f_a;
9036 }
9037
9038 public T setA(int a) {
9039 loadAndClear();
9040 this.b_a = true;
9041 this.f_a = a;
9042 return (T)this;
9043 }
9044
9045 public void clearA() {
9046 loadAndClear();
9047 this.b_a = false;
9048 this.f_a = 0;
9049 }
9050
9051 }
9052
9053
9054 static public final class Bar extends BarBase<Bar> {
9055
9056 public java.util.ArrayList<String> missingFields() {
9057 java.util.ArrayList<String> missingFields = super.missingFields();
9058 return missingFields;
9059 }
9060
9061 public void clear() {
9062 super.clear();
9063 clearA();
9064 }
9065
9066 public Bar clone() {
9067 return new Bar().mergeFrom(this);
9068 }
9069
9070 public Bar mergeFrom(Bar other) {
9071 if (other.hasA()) {
9072 setA(other.getA());
9073 }
9074 return this;
9075 }
9076
9077 public int serializedSizeUnframed() {
9078 if (memoizedSerializedSize != -1)
9079 return memoizedSerializedSize;
9080
9081 int size = 0;
9082 if (hasA()) {
9083 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getA());
9084 }
9085 memoizedSerializedSize = size;
9086 return size;
9087 }
9088
9089 public Bar mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
9090 while (true) {
9091 int tag = input.readTag();
9092 if ((tag & 0x07) == 4) {
9093 return this;
9094 }
9095 switch (tag) {
9096 case 0:
9097 return this;
9098 default: {
9099 break;
9100 }
9101 case 8:
9102 setA(input.readInt32());
9103 break;
9104 }
9105 }
9106 }
9107 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
9108 if (hasA()) {
9109 output.writeInt32(1, getA());
9110 }
9111 }
9112
9113 public static Bar parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9114 return new Bar().mergeUnframed(data).checktInitialized();
9115 }
9116
9117 public static Bar parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9118 return new Bar().mergeUnframed(data).checktInitialized();
9119 }
9120
9121 public static Bar parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9122 return new Bar().mergeUnframed(data).checktInitialized();
9123 }
9124
9125 public static Bar parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9126 return new Bar().mergeUnframed(data).checktInitialized();
9127 }
9128
9129 public static Bar parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9130 return new Bar().mergeFramed(data).checktInitialized();
9131 }
9132
9133 public static Bar parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9134 return new Bar().mergeFramed(data).checktInitialized();
9135 }
9136
9137 public static Bar parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9138 return new Bar().mergeFramed(data).checktInitialized();
9139 }
9140
9141 public static Bar parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9142 return new Bar().mergeFramed(data).checktInitialized();
9143 }
9144
9145 public String toString() {
9146 return toString(new java.lang.StringBuilder(), "").toString();
9147 }
9148
9149 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
9150 if( hasA() ) {
9151 sb.append(prefix+"a: ");
9152 sb.append(getA());
9153 sb.append("\n");
9154 }
9155 return sb;
9156 }
9157
9158 public boolean equals(Object obj) {
9159 if( obj==this )
9160 return true;
9161
9162 if( obj==null || obj.getClass()!=Bar.class )
9163 return false;
9164
9165 return equals((Bar)obj);
9166 }
9167
9168 public boolean equals(Bar obj) {
9169 if (hasA() ^ obj.hasA() )
9170 return false;
9171 if (hasA() && ( getA()!=obj.getA() ))
9172 return false;
9173 return true;
9174 }
9175
9176 public int hashCode() {
9177 int rc=66547;
9178 if (hasA()) {
9179 rc ^= ( 65^getA() );
9180 }
9181 return rc;
9182 }
9183
9184 }
9185
9186 static abstract class BarBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
9187
9188 // optional int32 a = 1;
9189 private int f_a = 0;
9190 private boolean b_a;
9191
9192 public boolean hasA() {
9193 return this.b_a;
9194 }
9195
9196 public int getA() {
9197 return this.f_a;
9198 }
9199
9200 public T setA(int a) {
9201 loadAndClear();
9202 this.b_a = true;
9203 this.f_a = a;
9204 return (T)this;
9205 }
9206
9207 public void clearA() {
9208 loadAndClear();
9209 this.b_a = false;
9210 this.f_a = 0;
9211 }
9212
9213 }
9214
9215 public java.util.ArrayList<String> missingFields() {
9216 java.util.ArrayList<String> missingFields = super.missingFields();
9217 if( hasFoo() ) {
9218 try {
9219 getFoo().assertInitialized();
9220 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
9221 missingFields.addAll(prefix(e.getMissingFields(),"Foo."));
9222 }
9223 }
9224 if( hasBar() ) {
9225 try {
9226 getBar().assertInitialized();
9227 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
9228 missingFields.addAll(prefix(e.getMissingFields(),"Bar."));
9229 }
9230 }
9231 return missingFields;
9232 }
9233
9234 public void clear() {
9235 super.clear();
9236 clearA();
9237 clearFoo();
9238 clearBar();
9239 }
9240
9241 public TestDupFieldNumber clone() {
9242 return new TestDupFieldNumber().mergeFrom(this);
9243 }
9244
9245 public TestDupFieldNumber mergeFrom(TestDupFieldNumber other) {
9246 if (other.hasA()) {
9247 setA(other.getA());
9248 }
9249 if (other.hasFoo()) {
9250 if (hasFoo()) {
9251 getFoo().mergeFrom(other.getFoo());
9252 } else {
9253 setFoo(other.getFoo().clone());
9254 }
9255 }
9256 if (other.hasBar()) {
9257 if (hasBar()) {
9258 getBar().mergeFrom(other.getBar());
9259 } else {
9260 setBar(other.getBar().clone());
9261 }
9262 }
9263 return this;
9264 }
9265
9266 public int serializedSizeUnframed() {
9267 if (memoizedSerializedSize != -1)
9268 return memoizedSerializedSize;
9269
9270 int size = 0;
9271 if (hasA()) {
9272 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getA());
9273 }
9274 if (hasFoo()) {
9275 size += computeGroupSize(2, getFoo());
9276 }
9277 if (hasBar()) {
9278 size += computeGroupSize(3, getBar());
9279 }
9280 memoizedSerializedSize = size;
9281 return size;
9282 }
9283
9284 public TestDupFieldNumber mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
9285 while (true) {
9286 int tag = input.readTag();
9287 if ((tag & 0x07) == 4) {
9288 return this;
9289 }
9290 switch (tag) {
9291 case 0:
9292 return this;
9293 default: {
9294 break;
9295 }
9296 case 8:
9297 setA(input.readInt32());
9298 break;
9299 case 19:
9300 if (hasFoo()) {
9301 readGroup(input, 2, getFoo());
9302 } else {
9303 setFoo(readGroup(input, 2,new TestDupFieldNumber.Foo()));
9304 }
9305
9306 break;
9307 case 27:
9308 if (hasBar()) {
9309 readGroup(input, 3, getBar());
9310 } else {
9311 setBar(readGroup(input, 3,new TestDupFieldNumber.Bar()));
9312 }
9313
9314 break;
9315 }
9316 }
9317 }
9318 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
9319 if (hasA()) {
9320 output.writeInt32(1, getA());
9321 }
9322 if (hasFoo()) {
9323 writeGroup(output, 2, getFoo());
9324 }
9325 if (hasBar()) {
9326 writeGroup(output, 3, getBar());
9327 }
9328 }
9329
9330 public static TestDupFieldNumber parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9331 return new TestDupFieldNumber().mergeUnframed(data).checktInitialized();
9332 }
9333
9334 public static TestDupFieldNumber parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9335 return new TestDupFieldNumber().mergeUnframed(data).checktInitialized();
9336 }
9337
9338 public static TestDupFieldNumber parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9339 return new TestDupFieldNumber().mergeUnframed(data).checktInitialized();
9340 }
9341
9342 public static TestDupFieldNumber parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9343 return new TestDupFieldNumber().mergeUnframed(data).checktInitialized();
9344 }
9345
9346 public static TestDupFieldNumber parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9347 return new TestDupFieldNumber().mergeFramed(data).checktInitialized();
9348 }
9349
9350 public static TestDupFieldNumber parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9351 return new TestDupFieldNumber().mergeFramed(data).checktInitialized();
9352 }
9353
9354 public static TestDupFieldNumber parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9355 return new TestDupFieldNumber().mergeFramed(data).checktInitialized();
9356 }
9357
9358 public static TestDupFieldNumber parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9359 return new TestDupFieldNumber().mergeFramed(data).checktInitialized();
9360 }
9361
9362 public String toString() {
9363 return toString(new java.lang.StringBuilder(), "").toString();
9364 }
9365
9366 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
9367 if( hasA() ) {
9368 sb.append(prefix+"a: ");
9369 sb.append(getA());
9370 sb.append("\n");
9371 }
9372 if( hasFoo() ) {
9373 sb.append(prefix+"Foo {\n");
9374 getFoo().toString(sb, prefix+" ");
9375 sb.append(prefix+"}\n");
9376 }
9377 if( hasBar() ) {
9378 sb.append(prefix+"Bar {\n");
9379 getBar().toString(sb, prefix+" ");
9380 sb.append(prefix+"}\n");
9381 }
9382 return sb;
9383 }
9384
9385 public boolean equals(Object obj) {
9386 if( obj==this )
9387 return true;
9388
9389 if( obj==null || obj.getClass()!=TestDupFieldNumber.class )
9390 return false;
9391
9392 return equals((TestDupFieldNumber)obj);
9393 }
9394
9395 public boolean equals(TestDupFieldNumber obj) {
9396 if (hasA() ^ obj.hasA() )
9397 return false;
9398 if (hasA() && ( getA()!=obj.getA() ))
9399 return false;
9400 if (hasFoo() ^ obj.hasFoo() )
9401 return false;
9402 if (hasFoo() && ( !getFoo().equals(obj.getFoo()) ))
9403 return false;
9404 if (hasBar() ^ obj.hasBar() )
9405 return false;
9406 if (hasBar() && ( !getBar().equals(obj.getBar()) ))
9407 return false;
9408 return true;
9409 }
9410
9411 public int hashCode() {
9412 int rc=766338742;
9413 if (hasA()) {
9414 rc ^= ( 65^getA() );
9415 }
9416 if (hasFoo()) {
9417 rc ^= ( 70822^getFoo().hashCode() );
9418 }
9419 if (hasBar()) {
9420 rc ^= ( 66547^getBar().hashCode() );
9421 }
9422 return rc;
9423 }
9424
9425 }
9426
9427 static abstract class TestDupFieldNumberBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
9428
9429 // optional int32 a = 1;
9430 private int f_a = 0;
9431 private boolean b_a;
9432
9433 public boolean hasA() {
9434 return this.b_a;
9435 }
9436
9437 public int getA() {
9438 return this.f_a;
9439 }
9440
9441 public T setA(int a) {
9442 loadAndClear();
9443 this.b_a = true;
9444 this.f_a = a;
9445 return (T)this;
9446 }
9447
9448 public void clearA() {
9449 loadAndClear();
9450 this.b_a = false;
9451 this.f_a = 0;
9452 }
9453
9454 // optional Foo Foo = 2;
9455 private TestDupFieldNumber.Foo f_foo = null;
9456
9457 public boolean hasFoo() {
9458 return this.f_foo!=null;
9459 }
9460
9461 public TestDupFieldNumber.Foo getFoo() {
9462 if( this.f_foo == null ) {
9463 this.f_foo = new TestDupFieldNumber.Foo();
9464 }
9465 return this.f_foo;
9466 }
9467
9468 public T setFoo(TestDupFieldNumber.Foo foo) {
9469 loadAndClear();
9470 this.f_foo = foo;
9471 return (T)this;
9472 }
9473
9474 public void clearFoo() {
9475 loadAndClear();
9476 this.f_foo = null;
9477 }
9478
9479 // optional Bar Bar = 3;
9480 private TestDupFieldNumber.Bar f_bar = null;
9481
9482 public boolean hasBar() {
9483 return this.f_bar!=null;
9484 }
9485
9486 public TestDupFieldNumber.Bar getBar() {
9487 if( this.f_bar == null ) {
9488 this.f_bar = new TestDupFieldNumber.Bar();
9489 }
9490 return this.f_bar;
9491 }
9492
9493 public T setBar(TestDupFieldNumber.Bar bar) {
9494 loadAndClear();
9495 this.f_bar = bar;
9496 return (T)this;
9497 }
9498
9499 public void clearBar() {
9500 loadAndClear();
9501 this.f_bar = null;
9502 }
9503
9504 }
9505
9506
9507 static public final class TestNestedMessageHasBits extends TestNestedMessageHasBitsBase<TestNestedMessageHasBits> {
9508
9509
9510 static public final class NestedMessage extends NestedMessageBase<NestedMessage> {
9511
9512 public java.util.ArrayList<String> missingFields() {
9513 java.util.ArrayList<String> missingFields = super.missingFields();
9514 if( hasNestedmessageRepeatedForeignmessage() ) {
9515 java.util.List<ForeignMessage> l = getNestedmessageRepeatedForeignmessageList();
9516 for( int i=0; i < l.size(); i++ ) {
9517 try {
9518 l.get(i).assertInitialized();
9519 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
9520 missingFields.addAll(prefix(e.getMissingFields(),"nestedmessage_repeated_foreignmessage["+i+"]"));
9521 }
9522 }
9523 }
9524 return missingFields;
9525 }
9526
9527 public void clear() {
9528 super.clear();
9529 clearNestedmessageRepeatedInt32();
9530 clearNestedmessageRepeatedForeignmessage();
9531 }
9532
9533 public NestedMessage clone() {
9534 return new NestedMessage().mergeFrom(this);
9535 }
9536
9537 public NestedMessage mergeFrom(NestedMessage other) {
9538 if (other.hasNestedmessageRepeatedInt32()) {
9539 getNestedmessageRepeatedInt32List().addAll(other.getNestedmessageRepeatedInt32List());
9540 }
9541 if (other.hasNestedmessageRepeatedForeignmessage()) {
9542 for(ForeignMessage element: other.getNestedmessageRepeatedForeignmessageList() ) {
9543 getNestedmessageRepeatedForeignmessageList().add(element.clone());
9544 }
9545 }
9546 return this;
9547 }
9548
9549 public int serializedSizeUnframed() {
9550 if (memoizedSerializedSize != -1)
9551 return memoizedSerializedSize;
9552
9553 int size = 0;
9554 if (hasNestedmessageRepeatedInt32()) {
9555 for (int i : getNestedmessageRepeatedInt32List()) {
9556 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, i);
9557 }
9558 }
9559 if (hasNestedmessageRepeatedForeignmessage()) {
9560 for (ForeignMessage i : getNestedmessageRepeatedForeignmessageList()) {
9561 size += computeMessageSize(2, i);
9562 }
9563 }
9564 memoizedSerializedSize = size;
9565 return size;
9566 }
9567
9568 public NestedMessage mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
9569 while (true) {
9570 int tag = input.readTag();
9571 if ((tag & 0x07) == 4) {
9572 return this;
9573 }
9574 switch (tag) {
9575 case 0:
9576 return this;
9577 default: {
9578 break;
9579 }
9580 case 8:
9581 getNestedmessageRepeatedInt32List().add(input.readInt32());
9582 break;
9583 case 18:
9584 getNestedmessageRepeatedForeignmessageList().add(new ForeignMessage().mergeFramed(input));
9585 break;
9586 }
9587 }
9588 }
9589 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
9590 if (hasNestedmessageRepeatedInt32()) {
9591 for (int i : getNestedmessageRepeatedInt32List()) {
9592 output.writeInt32(1, i);
9593 }
9594 }
9595 if (hasNestedmessageRepeatedForeignmessage()) {
9596 for (ForeignMessage i : getNestedmessageRepeatedForeignmessageList()) {
9597 writeMessage(output, 2, i);
9598 }
9599 }
9600 }
9601
9602 public static NestedMessage parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9603 return new NestedMessage().mergeUnframed(data).checktInitialized();
9604 }
9605
9606 public static NestedMessage parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9607 return new NestedMessage().mergeUnframed(data).checktInitialized();
9608 }
9609
9610 public static NestedMessage parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9611 return new NestedMessage().mergeUnframed(data).checktInitialized();
9612 }
9613
9614 public static NestedMessage parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9615 return new NestedMessage().mergeUnframed(data).checktInitialized();
9616 }
9617
9618 public static NestedMessage parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9619 return new NestedMessage().mergeFramed(data).checktInitialized();
9620 }
9621
9622 public static NestedMessage parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9623 return new NestedMessage().mergeFramed(data).checktInitialized();
9624 }
9625
9626 public static NestedMessage parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9627 return new NestedMessage().mergeFramed(data).checktInitialized();
9628 }
9629
9630 public static NestedMessage parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9631 return new NestedMessage().mergeFramed(data).checktInitialized();
9632 }
9633
9634 public String toString() {
9635 return toString(new java.lang.StringBuilder(), "").toString();
9636 }
9637
9638 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
9639 if( hasNestedmessageRepeatedInt32() ) {
9640 java.util.List<java.lang.Integer> l = getNestedmessageRepeatedInt32List();
9641 for( int i=0; i < l.size(); i++ ) {
9642 sb.append(prefix+"nestedmessage_repeated_int32["+i+"]: ");
9643 sb.append(l.get(i));
9644 sb.append("\n");
9645 }
9646 }
9647 if( hasNestedmessageRepeatedForeignmessage() ) {
9648 java.util.List<ForeignMessage> l = getNestedmessageRepeatedForeignmessageList();
9649 for( int i=0; i < l.size(); i++ ) {
9650 sb.append(prefix+"nestedmessage_repeated_foreignmessage["+i+"] {\n");
9651 l.get(i).toString(sb, prefix+" ");
9652 sb.append(prefix+"}\n");
9653 }
9654 }
9655 return sb;
9656 }
9657
9658 public boolean equals(Object obj) {
9659 if( obj==this )
9660 return true;
9661
9662 if( obj==null || obj.getClass()!=NestedMessage.class )
9663 return false;
9664
9665 return equals((NestedMessage)obj);
9666 }
9667
9668 public boolean equals(NestedMessage obj) {
9669 if (hasNestedmessageRepeatedInt32() ^ obj.hasNestedmessageRepeatedInt32() )
9670 return false;
9671 if (hasNestedmessageRepeatedInt32() && ( !getNestedmessageRepeatedInt32List().equals(obj.getNestedmessageRepeatedInt32List()) ))
9672 return false;
9673 if (hasNestedmessageRepeatedForeignmessage() ^ obj.hasNestedmessageRepeatedForeignmessage() )
9674 return false;
9675 if (hasNestedmessageRepeatedForeignmessage() && ( !getNestedmessageRepeatedForeignmessageList().equals(obj.getNestedmessageRepeatedForeignmessageList()) ))
9676 return false;
9677 return true;
9678 }
9679
9680 public int hashCode() {
9681 int rc=-132205840;
9682 if (hasNestedmessageRepeatedInt32()) {
9683 rc ^= ( 1421433348^getNestedmessageRepeatedInt32List().hashCode() );
9684 }
9685 if (hasNestedmessageRepeatedForeignmessage()) {
9686 rc ^= ( -612421123^getNestedmessageRepeatedForeignmessageList().hashCode() );
9687 }
9688 return rc;
9689 }
9690
9691 }
9692
9693 static abstract class NestedMessageBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
9694
9695 // repeated int32 nestedmessage_repeated_int32 = 1;
9696 private java.util.List<java.lang.Integer> f_nestedmessageRepeatedInt32;
9697
9698 public boolean hasNestedmessageRepeatedInt32() {
9699 return this.f_nestedmessageRepeatedInt32!=null && !this.f_nestedmessageRepeatedInt32.isEmpty();
9700 }
9701
9702 public java.util.List<java.lang.Integer> getNestedmessageRepeatedInt32List() {
9703 if( this.f_nestedmessageRepeatedInt32 == null ) {
9704 this.f_nestedmessageRepeatedInt32 = new java.util.ArrayList<java.lang.Integer>();
9705 }
9706 return this.f_nestedmessageRepeatedInt32;
9707 }
9708
9709 public T setNestedmessageRepeatedInt32List(java.util.List<java.lang.Integer> nestedmessageRepeatedInt32) {
9710 loadAndClear();
9711 this.f_nestedmessageRepeatedInt32 = nestedmessageRepeatedInt32;
9712 return (T)this;
9713 }
9714
9715 public int getNestedmessageRepeatedInt32Count() {
9716 if( this.f_nestedmessageRepeatedInt32 == null ) {
9717 return 0;
9718 }
9719 return this.f_nestedmessageRepeatedInt32.size();
9720 }
9721
9722 public java.lang.Integer getNestedmessageRepeatedInt32(int index) {
9723 if( this.f_nestedmessageRepeatedInt32 == null ) {
9724 return null;
9725 }
9726 return this.f_nestedmessageRepeatedInt32.get(index);
9727 }
9728
9729 public T setNestedmessageRepeatedInt32(int index, java.lang.Integer value) {
9730 loadAndClear();
9731 getNestedmessageRepeatedInt32List().set(index, value);
9732 return (T)this;
9733 }
9734
9735 public T addNestedmessageRepeatedInt32(java.lang.Integer value) {
9736 loadAndClear();
9737 getNestedmessageRepeatedInt32List().add(value);
9738 return (T)this;
9739 }
9740
9741 public T addAllNestedmessageRepeatedInt32(java.lang.Iterable<? extends java.lang.Integer> collection) {
9742 loadAndClear();
9743 super.addAll(collection, getNestedmessageRepeatedInt32List());
9744 return (T)this;
9745 }
9746
9747 public void clearNestedmessageRepeatedInt32() {
9748 loadAndClear();
9749 this.f_nestedmessageRepeatedInt32 = null;
9750 }
9751
9752 // repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2;
9753 private java.util.List<ForeignMessage> f_nestedmessageRepeatedForeignmessage;
9754
9755 public boolean hasNestedmessageRepeatedForeignmessage() {
9756 return this.f_nestedmessageRepeatedForeignmessage!=null && !this.f_nestedmessageRepeatedForeignmessage.isEmpty();
9757 }
9758
9759 public java.util.List<ForeignMessage> getNestedmessageRepeatedForeignmessageList() {
9760 if( this.f_nestedmessageRepeatedForeignmessage == null ) {
9761 this.f_nestedmessageRepeatedForeignmessage = new java.util.ArrayList<ForeignMessage>();
9762 }
9763 return this.f_nestedmessageRepeatedForeignmessage;
9764 }
9765
9766 public T setNestedmessageRepeatedForeignmessageList(java.util.List<ForeignMessage> nestedmessageRepeatedForeignmessage) {
9767 loadAndClear();
9768 this.f_nestedmessageRepeatedForeignmessage = nestedmessageRepeatedForeignmessage;
9769 return (T)this;
9770 }
9771
9772 public int getNestedmessageRepeatedForeignmessageCount() {
9773 if( this.f_nestedmessageRepeatedForeignmessage == null ) {
9774 return 0;
9775 }
9776 return this.f_nestedmessageRepeatedForeignmessage.size();
9777 }
9778
9779 public ForeignMessage getNestedmessageRepeatedForeignmessage(int index) {
9780 if( this.f_nestedmessageRepeatedForeignmessage == null ) {
9781 return null;
9782 }
9783 return this.f_nestedmessageRepeatedForeignmessage.get(index);
9784 }
9785
9786 public T setNestedmessageRepeatedForeignmessage(int index, ForeignMessage value) {
9787 loadAndClear();
9788 getNestedmessageRepeatedForeignmessageList().set(index, value);
9789 return (T)this;
9790 }
9791
9792 public T addNestedmessageRepeatedForeignmessage(ForeignMessage value) {
9793 loadAndClear();
9794 getNestedmessageRepeatedForeignmessageList().add(value);
9795 return (T)this;
9796 }
9797
9798 public T addAllNestedmessageRepeatedForeignmessage(java.lang.Iterable<? extends ForeignMessage> collection) {
9799 loadAndClear();
9800 super.addAll(collection, getNestedmessageRepeatedForeignmessageList());
9801 return (T)this;
9802 }
9803
9804 public void clearNestedmessageRepeatedForeignmessage() {
9805 loadAndClear();
9806 this.f_nestedmessageRepeatedForeignmessage = null;
9807 }
9808
9809 }
9810
9811 public java.util.ArrayList<String> missingFields() {
9812 java.util.ArrayList<String> missingFields = super.missingFields();
9813 if( hasOptionalNestedMessage() ) {
9814 try {
9815 getOptionalNestedMessage().assertInitialized();
9816 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
9817 missingFields.addAll(prefix(e.getMissingFields(),"optional_nested_message."));
9818 }
9819 }
9820 return missingFields;
9821 }
9822
9823 public void clear() {
9824 super.clear();
9825 clearOptionalNestedMessage();
9826 }
9827
9828 public TestNestedMessageHasBits clone() {
9829 return new TestNestedMessageHasBits().mergeFrom(this);
9830 }
9831
9832 public TestNestedMessageHasBits mergeFrom(TestNestedMessageHasBits other) {
9833 if (other.hasOptionalNestedMessage()) {
9834 if (hasOptionalNestedMessage()) {
9835 getOptionalNestedMessage().mergeFrom(other.getOptionalNestedMessage());
9836 } else {
9837 setOptionalNestedMessage(other.getOptionalNestedMessage().clone());
9838 }
9839 }
9840 return this;
9841 }
9842
9843 public int serializedSizeUnframed() {
9844 if (memoizedSerializedSize != -1)
9845 return memoizedSerializedSize;
9846
9847 int size = 0;
9848 if (hasOptionalNestedMessage()) {
9849 size += computeMessageSize(1, getOptionalNestedMessage());
9850 }
9851 memoizedSerializedSize = size;
9852 return size;
9853 }
9854
9855 public TestNestedMessageHasBits mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
9856 while (true) {
9857 int tag = input.readTag();
9858 if ((tag & 0x07) == 4) {
9859 return this;
9860 }
9861 switch (tag) {
9862 case 0:
9863 return this;
9864 default: {
9865 break;
9866 }
9867 case 10:
9868 if (hasOptionalNestedMessage()) {
9869 getOptionalNestedMessage().mergeFramed(input);
9870 } else {
9871 setOptionalNestedMessage(new TestNestedMessageHasBits.NestedMessage().mergeFramed(input));
9872 }
9873 break;
9874 }
9875 }
9876 }
9877 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
9878 if (hasOptionalNestedMessage()) {
9879 writeMessage(output, 1, getOptionalNestedMessage());
9880 }
9881 }
9882
9883 public static TestNestedMessageHasBits parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9884 return new TestNestedMessageHasBits().mergeUnframed(data).checktInitialized();
9885 }
9886
9887 public static TestNestedMessageHasBits parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9888 return new TestNestedMessageHasBits().mergeUnframed(data).checktInitialized();
9889 }
9890
9891 public static TestNestedMessageHasBits parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9892 return new TestNestedMessageHasBits().mergeUnframed(data).checktInitialized();
9893 }
9894
9895 public static TestNestedMessageHasBits parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9896 return new TestNestedMessageHasBits().mergeUnframed(data).checktInitialized();
9897 }
9898
9899 public static TestNestedMessageHasBits parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9900 return new TestNestedMessageHasBits().mergeFramed(data).checktInitialized();
9901 }
9902
9903 public static TestNestedMessageHasBits parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9904 return new TestNestedMessageHasBits().mergeFramed(data).checktInitialized();
9905 }
9906
9907 public static TestNestedMessageHasBits parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
9908 return new TestNestedMessageHasBits().mergeFramed(data).checktInitialized();
9909 }
9910
9911 public static TestNestedMessageHasBits parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
9912 return new TestNestedMessageHasBits().mergeFramed(data).checktInitialized();
9913 }
9914
9915 public String toString() {
9916 return toString(new java.lang.StringBuilder(), "").toString();
9917 }
9918
9919 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
9920 if( hasOptionalNestedMessage() ) {
9921 sb.append(prefix+"optional_nested_message {\n");
9922 getOptionalNestedMessage().toString(sb, prefix+" ");
9923 sb.append(prefix+"}\n");
9924 }
9925 return sb;
9926 }
9927
9928 public boolean equals(Object obj) {
9929 if( obj==this )
9930 return true;
9931
9932 if( obj==null || obj.getClass()!=TestNestedMessageHasBits.class )
9933 return false;
9934
9935 return equals((TestNestedMessageHasBits)obj);
9936 }
9937
9938 public boolean equals(TestNestedMessageHasBits obj) {
9939 if (hasOptionalNestedMessage() ^ obj.hasOptionalNestedMessage() )
9940 return false;
9941 if (hasOptionalNestedMessage() && ( !getOptionalNestedMessage().equals(obj.getOptionalNestedMessage()) ))
9942 return false;
9943 return true;
9944 }
9945
9946 public int hashCode() {
9947 int rc=-459247262;
9948 if (hasOptionalNestedMessage()) {
9949 rc ^= ( 1060320112^getOptionalNestedMessage().hashCode() );
9950 }
9951 return rc;
9952 }
9953
9954 }
9955
9956 static abstract class TestNestedMessageHasBitsBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
9957
9958 // optional NestedMessage optional_nested_message = 1;
9959 private TestNestedMessageHasBits.NestedMessage f_optionalNestedMessage = null;
9960
9961 public boolean hasOptionalNestedMessage() {
9962 return this.f_optionalNestedMessage!=null;
9963 }
9964
9965 public TestNestedMessageHasBits.NestedMessage getOptionalNestedMessage() {
9966 if( this.f_optionalNestedMessage == null ) {
9967 this.f_optionalNestedMessage = new TestNestedMessageHasBits.NestedMessage();
9968 }
9969 return this.f_optionalNestedMessage;
9970 }
9971
9972 public T setOptionalNestedMessage(TestNestedMessageHasBits.NestedMessage optionalNestedMessage) {
9973 loadAndClear();
9974 this.f_optionalNestedMessage = optionalNestedMessage;
9975 return (T)this;
9976 }
9977
9978 public void clearOptionalNestedMessage() {
9979 loadAndClear();
9980 this.f_optionalNestedMessage = null;
9981 }
9982
9983 }
9984
9985
9986 static public final class TestCamelCaseFieldNames extends TestCamelCaseFieldNamesBase<TestCamelCaseFieldNames> {
9987
9988 public java.util.ArrayList<String> missingFields() {
9989 java.util.ArrayList<String> missingFields = super.missingFields();
9990 if( hasMessageField() ) {
9991 try {
9992 getMessageField().assertInitialized();
9993 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
9994 missingFields.addAll(prefix(e.getMissingFields(),"MessageField."));
9995 }
9996 }
9997 if( hasRepeatedMessageField() ) {
9998 java.util.List<ForeignMessage> l = getRepeatedMessageFieldList();
9999 for( int i=0; i < l.size(); i++ ) {
10000 try {
10001 l.get(i).assertInitialized();
10002 } catch (org.apache.activemq.protobuf.UninitializedMessageException e){
10003 missingFields.addAll(prefix(e.getMissingFields(),"RepeatedMessageField["+i+"]"));
10004 }
10005 }
10006 }
10007 return missingFields;
10008 }
10009
10010 public void clear() {
10011 super.clear();
10012 clearPrimitiveField();
10013 clearStringField();
10014 clearEnumField();
10015 clearMessageField();
10016 clearStringPieceField();
10017 clearCordField();
10018 clearRepeatedPrimitiveField();
10019 clearRepeatedStringField();
10020 clearRepeatedEnumField();
10021 clearRepeatedMessageField();
10022 clearRepeatedStringPieceField();
10023 clearRepeatedCordField();
10024 }
10025
10026 public TestCamelCaseFieldNames clone() {
10027 return new TestCamelCaseFieldNames().mergeFrom(this);
10028 }
10029
10030 public TestCamelCaseFieldNames mergeFrom(TestCamelCaseFieldNames other) {
10031 if (other.hasPrimitiveField()) {
10032 setPrimitiveField(other.getPrimitiveField());
10033 }
10034 if (other.hasStringField()) {
10035 setStringField(other.getStringField());
10036 }
10037 if (other.hasEnumField()) {
10038 setEnumField(other.getEnumField());
10039 }
10040 if (other.hasMessageField()) {
10041 if (hasMessageField()) {
10042 getMessageField().mergeFrom(other.getMessageField());
10043 } else {
10044 setMessageField(other.getMessageField().clone());
10045 }
10046 }
10047 if (other.hasStringPieceField()) {
10048 setStringPieceField(other.getStringPieceField());
10049 }
10050 if (other.hasCordField()) {
10051 setCordField(other.getCordField());
10052 }
10053 if (other.hasRepeatedPrimitiveField()) {
10054 getRepeatedPrimitiveFieldList().addAll(other.getRepeatedPrimitiveFieldList());
10055 }
10056 if (other.hasRepeatedStringField()) {
10057 getRepeatedStringFieldList().addAll(other.getRepeatedStringFieldList());
10058 }
10059 if (other.hasRepeatedEnumField()) {
10060 getRepeatedEnumFieldList().addAll(other.getRepeatedEnumFieldList());
10061 }
10062 if (other.hasRepeatedMessageField()) {
10063 for(ForeignMessage element: other.getRepeatedMessageFieldList() ) {
10064 getRepeatedMessageFieldList().add(element.clone());
10065 }
10066 }
10067 if (other.hasRepeatedStringPieceField()) {
10068 getRepeatedStringPieceFieldList().addAll(other.getRepeatedStringPieceFieldList());
10069 }
10070 if (other.hasRepeatedCordField()) {
10071 getRepeatedCordFieldList().addAll(other.getRepeatedCordFieldList());
10072 }
10073 return this;
10074 }
10075
10076 public int serializedSizeUnframed() {
10077 if (memoizedSerializedSize != -1)
10078 return memoizedSerializedSize;
10079
10080 int size = 0;
10081 if (hasPrimitiveField()) {
10082 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(1, getPrimitiveField());
10083 }
10084 if (hasStringField()) {
10085 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(2, getStringField());
10086 }
10087 if (hasEnumField()) {
10088 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(3, getEnumField().getNumber());
10089 }
10090 if (hasMessageField()) {
10091 size += computeMessageSize(4, getMessageField());
10092 }
10093 if (hasStringPieceField()) {
10094 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(5, getStringPieceField());
10095 }
10096 if (hasCordField()) {
10097 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(6, getCordField());
10098 }
10099 if (hasRepeatedPrimitiveField()) {
10100 for (int i : getRepeatedPrimitiveFieldList()) {
10101 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(7, i);
10102 }
10103 }
10104 if (hasRepeatedStringField()) {
10105 for (java.lang.String i : getRepeatedStringFieldList()) {
10106 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(8, i);
10107 }
10108 }
10109 if (hasRepeatedEnumField()) {
10110 for (ForeignEnum i : getRepeatedEnumFieldList()) {
10111 size += org.apache.activemq.protobuf.CodedOutputStream.computeEnumSize(9, i.getNumber());
10112 }
10113 }
10114 if (hasRepeatedMessageField()) {
10115 for (ForeignMessage i : getRepeatedMessageFieldList()) {
10116 size += computeMessageSize(10, i);
10117 }
10118 }
10119 if (hasRepeatedStringPieceField()) {
10120 for (java.lang.String i : getRepeatedStringPieceFieldList()) {
10121 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(11, i);
10122 }
10123 }
10124 if (hasRepeatedCordField()) {
10125 for (java.lang.String i : getRepeatedCordFieldList()) {
10126 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(12, i);
10127 }
10128 }
10129 memoizedSerializedSize = size;
10130 return size;
10131 }
10132
10133 public TestCamelCaseFieldNames mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
10134 while (true) {
10135 int tag = input.readTag();
10136 if ((tag & 0x07) == 4) {
10137 return this;
10138 }
10139 switch (tag) {
10140 case 0:
10141 return this;
10142 default: {
10143 break;
10144 }
10145 case 8:
10146 setPrimitiveField(input.readInt32());
10147 break;
10148 case 18:
10149 setStringField(input.readString());
10150 break;
10151 case 24:
10152 {
10153 int t = input.readEnum();
10154 ForeignEnum value = ForeignEnum.valueOf(t);
10155 if( value !=null ) {
10156 setEnumField(value);
10157 }
10158 }
10159 break;
10160 case 34:
10161 if (hasMessageField()) {
10162 getMessageField().mergeFramed(input);
10163 } else {
10164 setMessageField(new ForeignMessage().mergeFramed(input));
10165 }
10166 break;
10167 case 42:
10168 setStringPieceField(input.readString());
10169 break;
10170 case 50:
10171 setCordField(input.readString());
10172 break;
10173 case 56:
10174 getRepeatedPrimitiveFieldList().add(input.readInt32());
10175 break;
10176 case 66:
10177 getRepeatedStringFieldList().add(input.readString());
10178 break;
10179 case 72:
10180 {
10181 int t = input.readEnum();
10182 ForeignEnum value = ForeignEnum.valueOf(t);
10183 if( value !=null ) {
10184 getRepeatedEnumFieldList().add(value);
10185 }
10186 }
10187 break;
10188 case 82:
10189 getRepeatedMessageFieldList().add(new ForeignMessage().mergeFramed(input));
10190 break;
10191 case 90:
10192 getRepeatedStringPieceFieldList().add(input.readString());
10193 break;
10194 case 98:
10195 getRepeatedCordFieldList().add(input.readString());
10196 break;
10197 }
10198 }
10199 }
10200 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
10201 if (hasPrimitiveField()) {
10202 output.writeInt32(1, getPrimitiveField());
10203 }
10204 if (hasStringField()) {
10205 output.writeString(2, getStringField());
10206 }
10207 if (hasEnumField()) {
10208 output.writeEnum(3, getEnumField().getNumber());
10209 }
10210 if (hasMessageField()) {
10211 writeMessage(output, 4, getMessageField());
10212 }
10213 if (hasStringPieceField()) {
10214 output.writeString(5, getStringPieceField());
10215 }
10216 if (hasCordField()) {
10217 output.writeString(6, getCordField());
10218 }
10219 if (hasRepeatedPrimitiveField()) {
10220 for (int i : getRepeatedPrimitiveFieldList()) {
10221 output.writeInt32(7, i);
10222 }
10223 }
10224 if (hasRepeatedStringField()) {
10225 for (java.lang.String i : getRepeatedStringFieldList()) {
10226 output.writeString(8, i);
10227 }
10228 }
10229 if (hasRepeatedEnumField()) {
10230 for (ForeignEnum i : getRepeatedEnumFieldList()) {
10231 output.writeEnum(9, i.getNumber());
10232 }
10233 }
10234 if (hasRepeatedMessageField()) {
10235 for (ForeignMessage i : getRepeatedMessageFieldList()) {
10236 writeMessage(output, 10, i);
10237 }
10238 }
10239 if (hasRepeatedStringPieceField()) {
10240 for (java.lang.String i : getRepeatedStringPieceFieldList()) {
10241 output.writeString(11, i);
10242 }
10243 }
10244 if (hasRepeatedCordField()) {
10245 for (java.lang.String i : getRepeatedCordFieldList()) {
10246 output.writeString(12, i);
10247 }
10248 }
10249 }
10250
10251 public static TestCamelCaseFieldNames parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
10252 return new TestCamelCaseFieldNames().mergeUnframed(data).checktInitialized();
10253 }
10254
10255 public static TestCamelCaseFieldNames parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
10256 return new TestCamelCaseFieldNames().mergeUnframed(data).checktInitialized();
10257 }
10258
10259 public static TestCamelCaseFieldNames parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
10260 return new TestCamelCaseFieldNames().mergeUnframed(data).checktInitialized();
10261 }
10262
10263 public static TestCamelCaseFieldNames parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
10264 return new TestCamelCaseFieldNames().mergeUnframed(data).checktInitialized();
10265 }
10266
10267 public static TestCamelCaseFieldNames parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
10268 return new TestCamelCaseFieldNames().mergeFramed(data).checktInitialized();
10269 }
10270
10271 public static TestCamelCaseFieldNames parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
10272 return new TestCamelCaseFieldNames().mergeFramed(data).checktInitialized();
10273 }
10274
10275 public static TestCamelCaseFieldNames parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
10276 return new TestCamelCaseFieldNames().mergeFramed(data).checktInitialized();
10277 }
10278
10279 public static TestCamelCaseFieldNames parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
10280 return new TestCamelCaseFieldNames().mergeFramed(data).checktInitialized();
10281 }
10282
10283 public String toString() {
10284 return toString(new java.lang.StringBuilder(), "").toString();
10285 }
10286
10287 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
10288 if( hasPrimitiveField() ) {
10289 sb.append(prefix+"PrimitiveField: ");
10290 sb.append(getPrimitiveField());
10291 sb.append("\n");
10292 }
10293 if( hasStringField() ) {
10294 sb.append(prefix+"StringField: ");
10295 sb.append(getStringField());
10296 sb.append("\n");
10297 }
10298 if( hasEnumField() ) {
10299 sb.append(prefix+"EnumField: ");
10300 sb.append(getEnumField());
10301 sb.append("\n");
10302 }
10303 if( hasMessageField() ) {
10304 sb.append(prefix+"MessageField {\n");
10305 getMessageField().toString(sb, prefix+" ");
10306 sb.append(prefix+"}\n");
10307 }
10308 if( hasStringPieceField() ) {
10309 sb.append(prefix+"StringPieceField: ");
10310 sb.append(getStringPieceField());
10311 sb.append("\n");
10312 }
10313 if( hasCordField() ) {
10314 sb.append(prefix+"CordField: ");
10315 sb.append(getCordField());
10316 sb.append("\n");
10317 }
10318 if( hasRepeatedPrimitiveField() ) {
10319 java.util.List<java.lang.Integer> l = getRepeatedPrimitiveFieldList();
10320 for( int i=0; i < l.size(); i++ ) {
10321 sb.append(prefix+"RepeatedPrimitiveField["+i+"]: ");
10322 sb.append(l.get(i));
10323 sb.append("\n");
10324 }
10325 }
10326 if( hasRepeatedStringField() ) {
10327 java.util.List<java.lang.String> l = getRepeatedStringFieldList();
10328 for( int i=0; i < l.size(); i++ ) {
10329 sb.append(prefix+"RepeatedStringField["+i+"]: ");
10330 sb.append(l.get(i));
10331 sb.append("\n");
10332 }
10333 }
10334 if( hasRepeatedEnumField() ) {
10335 java.util.List<ForeignEnum> l = getRepeatedEnumFieldList();
10336 for( int i=0; i < l.size(); i++ ) {
10337 sb.append(prefix+"RepeatedEnumField["+i+"]: ");
10338 sb.append(l.get(i));
10339 sb.append("\n");
10340 }
10341 }
10342 if( hasRepeatedMessageField() ) {
10343 java.util.List<ForeignMessage> l = getRepeatedMessageFieldList();
10344 for( int i=0; i < l.size(); i++ ) {
10345 sb.append(prefix+"RepeatedMessageField["+i+"] {\n");
10346 l.get(i).toString(sb, prefix+" ");
10347 sb.append(prefix+"}\n");
10348 }
10349 }
10350 if( hasRepeatedStringPieceField() ) {
10351 java.util.List<java.lang.String> l = getRepeatedStringPieceFieldList();
10352 for( int i=0; i < l.size(); i++ ) {
10353 sb.append(prefix+"RepeatedStringPieceField["+i+"]: ");
10354 sb.append(l.get(i));
10355 sb.append("\n");
10356 }
10357 }
10358 if( hasRepeatedCordField() ) {
10359 java.util.List<java.lang.String> l = getRepeatedCordFieldList();
10360 for( int i=0; i < l.size(); i++ ) {
10361 sb.append(prefix+"RepeatedCordField["+i+"]: ");
10362 sb.append(l.get(i));
10363 sb.append("\n");
10364 }
10365 }
10366 return sb;
10367 }
10368
10369 public boolean equals(Object obj) {
10370 if( obj==this )
10371 return true;
10372
10373 if( obj==null || obj.getClass()!=TestCamelCaseFieldNames.class )
10374 return false;
10375
10376 return equals((TestCamelCaseFieldNames)obj);
10377 }
10378
10379 public boolean equals(TestCamelCaseFieldNames obj) {
10380 if (hasPrimitiveField() ^ obj.hasPrimitiveField() )
10381 return false;
10382 if (hasPrimitiveField() && ( getPrimitiveField()!=obj.getPrimitiveField() ))
10383 return false;
10384 if (hasStringField() ^ obj.hasStringField() )
10385 return false;
10386 if (hasStringField() && ( !getStringField().equals(obj.getStringField()) ))
10387 return false;
10388 if (hasEnumField() ^ obj.hasEnumField() )
10389 return false;
10390 if (hasEnumField() && ( !getEnumField().equals(obj.getEnumField()) ))
10391 return false;
10392 if (hasMessageField() ^ obj.hasMessageField() )
10393 return false;
10394 if (hasMessageField() && ( !getMessageField().equals(obj.getMessageField()) ))
10395 return false;
10396 if (hasStringPieceField() ^ obj.hasStringPieceField() )
10397 return false;
10398 if (hasStringPieceField() && ( !getStringPieceField().equals(obj.getStringPieceField()) ))
10399 return false;
10400 if (hasCordField() ^ obj.hasCordField() )
10401 return false;
10402 if (hasCordField() && ( !getCordField().equals(obj.getCordField()) ))
10403 return false;
10404 if (hasRepeatedPrimitiveField() ^ obj.hasRepeatedPrimitiveField() )
10405 return false;
10406 if (hasRepeatedPrimitiveField() && ( !getRepeatedPrimitiveFieldList().equals(obj.getRepeatedPrimitiveFieldList()) ))
10407 return false;
10408 if (hasRepeatedStringField() ^ obj.hasRepeatedStringField() )
10409 return false;
10410 if (hasRepeatedStringField() && ( !getRepeatedStringFieldList().equals(obj.getRepeatedStringFieldList()) ))
10411 return false;
10412 if (hasRepeatedEnumField() ^ obj.hasRepeatedEnumField() )
10413 return false;
10414 if (hasRepeatedEnumField() && ( !getRepeatedEnumFieldList().equals(obj.getRepeatedEnumFieldList()) ))
10415 return false;
10416 if (hasRepeatedMessageField() ^ obj.hasRepeatedMessageField() )
10417 return false;
10418 if (hasRepeatedMessageField() && ( !getRepeatedMessageFieldList().equals(obj.getRepeatedMessageFieldList()) ))
10419 return false;
10420 if (hasRepeatedStringPieceField() ^ obj.hasRepeatedStringPieceField() )
10421 return false;
10422 if (hasRepeatedStringPieceField() && ( !getRepeatedStringPieceFieldList().equals(obj.getRepeatedStringPieceFieldList()) ))
10423 return false;
10424 if (hasRepeatedCordField() ^ obj.hasRepeatedCordField() )
10425 return false;
10426 if (hasRepeatedCordField() && ( !getRepeatedCordFieldList().equals(obj.getRepeatedCordFieldList()) ))
10427 return false;
10428 return true;
10429 }
10430
10431 public int hashCode() {
10432 int rc=-547867134;
10433 if (hasPrimitiveField()) {
10434 rc ^= ( 1743153267^getPrimitiveField() );
10435 }
10436 if (hasStringField()) {
10437 rc ^= ( 134110025^getStringField().hashCode() );
10438 }
10439 if (hasEnumField()) {
10440 rc ^= ( -2072497063^getEnumField().hashCode() );
10441 }
10442 if (hasMessageField()) {
10443 rc ^= ( -1145179821^getMessageField().hashCode() );
10444 }
10445 if (hasStringPieceField()) {
10446 rc ^= ( -1059378755^getStringPieceField().hashCode() );
10447 }
10448 if (hasCordField()) {
10449 rc ^= ( 365048796^getCordField().hashCode() );
10450 }
10451 if (hasRepeatedPrimitiveField()) {
10452 rc ^= ( 312260237^getRepeatedPrimitiveFieldList().hashCode() );
10453 }
10454 if (hasRepeatedStringField()) {
10455 rc ^= ( 1052136303^getRepeatedStringFieldList().hashCode() );
10456 }
10457 if (hasRepeatedEnumField()) {
10458 rc ^= ( -855900673^getRepeatedEnumFieldList().hashCode() );
10459 }
10460 if (hasRepeatedMessageField()) {
10461 rc ^= ( 1543831021^getRepeatedMessageFieldList().hashCode() );
10462 }
10463 if (hasRepeatedStringPieceField()) {
10464 rc ^= ( -1758045865^getRepeatedStringPieceFieldList().hashCode() );
10465 }
10466 if (hasRepeatedCordField()) {
10467 rc ^= ( 1581645186^getRepeatedCordFieldList().hashCode() );
10468 }
10469 return rc;
10470 }
10471
10472 }
10473
10474 static abstract class TestCamelCaseFieldNamesBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
10475
10476 // optional int32 PrimitiveField = 1;
10477 private int f_primitiveField = 0;
10478 private boolean b_primitiveField;
10479
10480 public boolean hasPrimitiveField() {
10481 return this.b_primitiveField;
10482 }
10483
10484 public int getPrimitiveField() {
10485 return this.f_primitiveField;
10486 }
10487
10488 public T setPrimitiveField(int primitiveField) {
10489 loadAndClear();
10490 this.b_primitiveField = true;
10491 this.f_primitiveField = primitiveField;
10492 return (T)this;
10493 }
10494
10495 public void clearPrimitiveField() {
10496 loadAndClear();
10497 this.b_primitiveField = false;
10498 this.f_primitiveField = 0;
10499 }
10500
10501 // optional string StringField = 2;
10502 private java.lang.String f_stringField = null;
10503 private boolean b_stringField;
10504
10505 public boolean hasStringField() {
10506 return this.b_stringField;
10507 }
10508
10509 public java.lang.String getStringField() {
10510 return this.f_stringField;
10511 }
10512
10513 public T setStringField(java.lang.String stringField) {
10514 loadAndClear();
10515 this.b_stringField = true;
10516 this.f_stringField = stringField;
10517 return (T)this;
10518 }
10519
10520 public void clearStringField() {
10521 loadAndClear();
10522 this.b_stringField = false;
10523 this.f_stringField = null;
10524 }
10525
10526 // optional ForeignEnum EnumField = 3;
10527 private ForeignEnum f_enumField = null;
10528 private boolean b_enumField;
10529
10530 public boolean hasEnumField() {
10531 return this.b_enumField;
10532 }
10533
10534 public ForeignEnum getEnumField() {
10535 return this.f_enumField;
10536 }
10537
10538 public T setEnumField(ForeignEnum enumField) {
10539 loadAndClear();
10540 this.b_enumField = true;
10541 this.f_enumField = enumField;
10542 return (T)this;
10543 }
10544
10545 public void clearEnumField() {
10546 loadAndClear();
10547 this.b_enumField = false;
10548 this.f_enumField = null;
10549 }
10550
10551 // optional ForeignMessage MessageField = 4;
10552 private ForeignMessage f_messageField = null;
10553
10554 public boolean hasMessageField() {
10555 return this.f_messageField!=null;
10556 }
10557
10558 public ForeignMessage getMessageField() {
10559 if( this.f_messageField == null ) {
10560 this.f_messageField = new ForeignMessage();
10561 }
10562 return this.f_messageField;
10563 }
10564
10565 public T setMessageField(ForeignMessage messageField) {
10566 loadAndClear();
10567 this.f_messageField = messageField;
10568 return (T)this;
10569 }
10570
10571 public void clearMessageField() {
10572 loadAndClear();
10573 this.f_messageField = null;
10574 }
10575
10576 // optional string StringPieceField = 5;
10577 private java.lang.String f_stringPieceField = null;
10578 private boolean b_stringPieceField;
10579
10580 public boolean hasStringPieceField() {
10581 return this.b_stringPieceField;
10582 }
10583
10584 public java.lang.String getStringPieceField() {
10585 return this.f_stringPieceField;
10586 }
10587
10588 public T setStringPieceField(java.lang.String stringPieceField) {
10589 loadAndClear();
10590 this.b_stringPieceField = true;
10591 this.f_stringPieceField = stringPieceField;
10592 return (T)this;
10593 }
10594
10595 public void clearStringPieceField() {
10596 loadAndClear();
10597 this.b_stringPieceField = false;
10598 this.f_stringPieceField = null;
10599 }
10600
10601 // optional string CordField = 6;
10602 private java.lang.String f_cordField = null;
10603 private boolean b_cordField;
10604
10605 public boolean hasCordField() {
10606 return this.b_cordField;
10607 }
10608
10609 public java.lang.String getCordField() {
10610 return this.f_cordField;
10611 }
10612
10613 public T setCordField(java.lang.String cordField) {
10614 loadAndClear();
10615 this.b_cordField = true;
10616 this.f_cordField = cordField;
10617 return (T)this;
10618 }
10619
10620 public void clearCordField() {
10621 loadAndClear();
10622 this.b_cordField = false;
10623 this.f_cordField = null;
10624 }
10625
10626 // repeated int32 RepeatedPrimitiveField = 7;
10627 private java.util.List<java.lang.Integer> f_repeatedPrimitiveField;
10628
10629 public boolean hasRepeatedPrimitiveField() {
10630 return this.f_repeatedPrimitiveField!=null && !this.f_repeatedPrimitiveField.isEmpty();
10631 }
10632
10633 public java.util.List<java.lang.Integer> getRepeatedPrimitiveFieldList() {
10634 if( this.f_repeatedPrimitiveField == null ) {
10635 this.f_repeatedPrimitiveField = new java.util.ArrayList<java.lang.Integer>();
10636 }
10637 return this.f_repeatedPrimitiveField;
10638 }
10639
10640 public T setRepeatedPrimitiveFieldList(java.util.List<java.lang.Integer> repeatedPrimitiveField) {
10641 loadAndClear();
10642 this.f_repeatedPrimitiveField = repeatedPrimitiveField;
10643 return (T)this;
10644 }
10645
10646 public int getRepeatedPrimitiveFieldCount() {
10647 if( this.f_repeatedPrimitiveField == null ) {
10648 return 0;
10649 }
10650 return this.f_repeatedPrimitiveField.size();
10651 }
10652
10653 public java.lang.Integer getRepeatedPrimitiveField(int index) {
10654 if( this.f_repeatedPrimitiveField == null ) {
10655 return null;
10656 }
10657 return this.f_repeatedPrimitiveField.get(index);
10658 }
10659
10660 public T setRepeatedPrimitiveField(int index, java.lang.Integer value) {
10661 loadAndClear();
10662 getRepeatedPrimitiveFieldList().set(index, value);
10663 return (T)this;
10664 }
10665
10666 public T addRepeatedPrimitiveField(java.lang.Integer value) {
10667 loadAndClear();
10668 getRepeatedPrimitiveFieldList().add(value);
10669 return (T)this;
10670 }
10671
10672 public T addAllRepeatedPrimitiveField(java.lang.Iterable<? extends java.lang.Integer> collection) {
10673 loadAndClear();
10674 super.addAll(collection, getRepeatedPrimitiveFieldList());
10675 return (T)this;
10676 }
10677
10678 public void clearRepeatedPrimitiveField() {
10679 loadAndClear();
10680 this.f_repeatedPrimitiveField = null;
10681 }
10682
10683 // repeated string RepeatedStringField = 8;
10684 private java.util.List<java.lang.String> f_repeatedStringField;
10685
10686 public boolean hasRepeatedStringField() {
10687 return this.f_repeatedStringField!=null && !this.f_repeatedStringField.isEmpty();
10688 }
10689
10690 public java.util.List<java.lang.String> getRepeatedStringFieldList() {
10691 if( this.f_repeatedStringField == null ) {
10692 this.f_repeatedStringField = new java.util.ArrayList<java.lang.String>();
10693 }
10694 return this.f_repeatedStringField;
10695 }
10696
10697 public T setRepeatedStringFieldList(java.util.List<java.lang.String> repeatedStringField) {
10698 loadAndClear();
10699 this.f_repeatedStringField = repeatedStringField;
10700 return (T)this;
10701 }
10702
10703 public int getRepeatedStringFieldCount() {
10704 if( this.f_repeatedStringField == null ) {
10705 return 0;
10706 }
10707 return this.f_repeatedStringField.size();
10708 }
10709
10710 public java.lang.String getRepeatedStringField(int index) {
10711 if( this.f_repeatedStringField == null ) {
10712 return null;
10713 }
10714 return this.f_repeatedStringField.get(index);
10715 }
10716
10717 public T setRepeatedStringField(int index, java.lang.String value) {
10718 loadAndClear();
10719 getRepeatedStringFieldList().set(index, value);
10720 return (T)this;
10721 }
10722
10723 public T addRepeatedStringField(java.lang.String value) {
10724 loadAndClear();
10725 getRepeatedStringFieldList().add(value);
10726 return (T)this;
10727 }
10728
10729 public T addAllRepeatedStringField(java.lang.Iterable<? extends java.lang.String> collection) {
10730 loadAndClear();
10731 super.addAll(collection, getRepeatedStringFieldList());
10732 return (T)this;
10733 }
10734
10735 public void clearRepeatedStringField() {
10736 loadAndClear();
10737 this.f_repeatedStringField = null;
10738 }
10739
10740 // repeated ForeignEnum RepeatedEnumField = 9;
10741 private java.util.List<ForeignEnum> f_repeatedEnumField;
10742
10743 public boolean hasRepeatedEnumField() {
10744 return this.f_repeatedEnumField!=null && !this.f_repeatedEnumField.isEmpty();
10745 }
10746
10747 public java.util.List<ForeignEnum> getRepeatedEnumFieldList() {
10748 if( this.f_repeatedEnumField == null ) {
10749 this.f_repeatedEnumField = new java.util.ArrayList<ForeignEnum>();
10750 }
10751 return this.f_repeatedEnumField;
10752 }
10753
10754 public T setRepeatedEnumFieldList(java.util.List<ForeignEnum> repeatedEnumField) {
10755 loadAndClear();
10756 this.f_repeatedEnumField = repeatedEnumField;
10757 return (T)this;
10758 }
10759
10760 public int getRepeatedEnumFieldCount() {
10761 if( this.f_repeatedEnumField == null ) {
10762 return 0;
10763 }
10764 return this.f_repeatedEnumField.size();
10765 }
10766
10767 public ForeignEnum getRepeatedEnumField(int index) {
10768 if( this.f_repeatedEnumField == null ) {
10769 return null;
10770 }
10771 return this.f_repeatedEnumField.get(index);
10772 }
10773
10774 public T setRepeatedEnumField(int index, ForeignEnum value) {
10775 loadAndClear();
10776 getRepeatedEnumFieldList().set(index, value);
10777 return (T)this;
10778 }
10779
10780 public T addRepeatedEnumField(ForeignEnum value) {
10781 loadAndClear();
10782 getRepeatedEnumFieldList().add(value);
10783 return (T)this;
10784 }
10785
10786 public T addAllRepeatedEnumField(java.lang.Iterable<? extends ForeignEnum> collection) {
10787 loadAndClear();
10788 super.addAll(collection, getRepeatedEnumFieldList());
10789 return (T)this;
10790 }
10791
10792 public void clearRepeatedEnumField() {
10793 loadAndClear();
10794 this.f_repeatedEnumField = null;
10795 }
10796
10797 // repeated ForeignMessage RepeatedMessageField = 10;
10798 private java.util.List<ForeignMessage> f_repeatedMessageField;
10799
10800 public boolean hasRepeatedMessageField() {
10801 return this.f_repeatedMessageField!=null && !this.f_repeatedMessageField.isEmpty();
10802 }
10803
10804 public java.util.List<ForeignMessage> getRepeatedMessageFieldList() {
10805 if( this.f_repeatedMessageField == null ) {
10806 this.f_repeatedMessageField = new java.util.ArrayList<ForeignMessage>();
10807 }
10808 return this.f_repeatedMessageField;
10809 }
10810
10811 public T setRepeatedMessageFieldList(java.util.List<ForeignMessage> repeatedMessageField) {
10812 loadAndClear();
10813 this.f_repeatedMessageField = repeatedMessageField;
10814 return (T)this;
10815 }
10816
10817 public int getRepeatedMessageFieldCount() {
10818 if( this.f_repeatedMessageField == null ) {
10819 return 0;
10820 }
10821 return this.f_repeatedMessageField.size();
10822 }
10823
10824 public ForeignMessage getRepeatedMessageField(int index) {
10825 if( this.f_repeatedMessageField == null ) {
10826 return null;
10827 }
10828 return this.f_repeatedMessageField.get(index);
10829 }
10830
10831 public T setRepeatedMessageField(int index, ForeignMessage value) {
10832 loadAndClear();
10833 getRepeatedMessageFieldList().set(index, value);
10834 return (T)this;
10835 }
10836
10837 public T addRepeatedMessageField(ForeignMessage value) {
10838 loadAndClear();
10839 getRepeatedMessageFieldList().add(value);
10840 return (T)this;
10841 }
10842
10843 public T addAllRepeatedMessageField(java.lang.Iterable<? extends ForeignMessage> collection) {
10844 loadAndClear();
10845 super.addAll(collection, getRepeatedMessageFieldList());
10846 return (T)this;
10847 }
10848
10849 public void clearRepeatedMessageField() {
10850 loadAndClear();
10851 this.f_repeatedMessageField = null;
10852 }
10853
10854 // repeated string RepeatedStringPieceField = 11;
10855 private java.util.List<java.lang.String> f_repeatedStringPieceField;
10856
10857 public boolean hasRepeatedStringPieceField() {
10858 return this.f_repeatedStringPieceField!=null && !this.f_repeatedStringPieceField.isEmpty();
10859 }
10860
10861 public java.util.List<java.lang.String> getRepeatedStringPieceFieldList() {
10862 if( this.f_repeatedStringPieceField == null ) {
10863 this.f_repeatedStringPieceField = new java.util.ArrayList<java.lang.String>();
10864 }
10865 return this.f_repeatedStringPieceField;
10866 }
10867
10868 public T setRepeatedStringPieceFieldList(java.util.List<java.lang.String> repeatedStringPieceField) {
10869 loadAndClear();
10870 this.f_repeatedStringPieceField = repeatedStringPieceField;
10871 return (T)this;
10872 }
10873
10874 public int getRepeatedStringPieceFieldCount() {
10875 if( this.f_repeatedStringPieceField == null ) {
10876 return 0;
10877 }
10878 return this.f_repeatedStringPieceField.size();
10879 }
10880
10881 public java.lang.String getRepeatedStringPieceField(int index) {
10882 if( this.f_repeatedStringPieceField == null ) {
10883 return null;
10884 }
10885 return this.f_repeatedStringPieceField.get(index);
10886 }
10887
10888 public T setRepeatedStringPieceField(int index, java.lang.String value) {
10889 loadAndClear();
10890 getRepeatedStringPieceFieldList().set(index, value);
10891 return (T)this;
10892 }
10893
10894 public T addRepeatedStringPieceField(java.lang.String value) {
10895 loadAndClear();
10896 getRepeatedStringPieceFieldList().add(value);
10897 return (T)this;
10898 }
10899
10900 public T addAllRepeatedStringPieceField(java.lang.Iterable<? extends java.lang.String> collection) {
10901 loadAndClear();
10902 super.addAll(collection, getRepeatedStringPieceFieldList());
10903 return (T)this;
10904 }
10905
10906 public void clearRepeatedStringPieceField() {
10907 loadAndClear();
10908 this.f_repeatedStringPieceField = null;
10909 }
10910
10911 // repeated string RepeatedCordField = 12;
10912 private java.util.List<java.lang.String> f_repeatedCordField;
10913
10914 public boolean hasRepeatedCordField() {
10915 return this.f_repeatedCordField!=null && !this.f_repeatedCordField.isEmpty();
10916 }
10917
10918 public java.util.List<java.lang.String> getRepeatedCordFieldList() {
10919 if( this.f_repeatedCordField == null ) {
10920 this.f_repeatedCordField = new java.util.ArrayList<java.lang.String>();
10921 }
10922 return this.f_repeatedCordField;
10923 }
10924
10925 public T setRepeatedCordFieldList(java.util.List<java.lang.String> repeatedCordField) {
10926 loadAndClear();
10927 this.f_repeatedCordField = repeatedCordField;
10928 return (T)this;
10929 }
10930
10931 public int getRepeatedCordFieldCount() {
10932 if( this.f_repeatedCordField == null ) {
10933 return 0;
10934 }
10935 return this.f_repeatedCordField.size();
10936 }
10937
10938 public java.lang.String getRepeatedCordField(int index) {
10939 if( this.f_repeatedCordField == null ) {
10940 return null;
10941 }
10942 return this.f_repeatedCordField.get(index);
10943 }
10944
10945 public T setRepeatedCordField(int index, java.lang.String value) {
10946 loadAndClear();
10947 getRepeatedCordFieldList().set(index, value);
10948 return (T)this;
10949 }
10950
10951 public T addRepeatedCordField(java.lang.String value) {
10952 loadAndClear();
10953 getRepeatedCordFieldList().add(value);
10954 return (T)this;
10955 }
10956
10957 public T addAllRepeatedCordField(java.lang.Iterable<? extends java.lang.String> collection) {
10958 loadAndClear();
10959 super.addAll(collection, getRepeatedCordFieldList());
10960 return (T)this;
10961 }
10962
10963 public void clearRepeatedCordField() {
10964 loadAndClear();
10965 this.f_repeatedCordField = null;
10966 }
10967
10968 }
10969
10970
10971 static public final class TestFieldOrderings extends TestFieldOrderingsBase<TestFieldOrderings> {
10972
10973 public java.util.ArrayList<String> missingFields() {
10974 java.util.ArrayList<String> missingFields = super.missingFields();
10975 return missingFields;
10976 }
10977
10978 public void clear() {
10979 super.clear();
10980 clearMyString();
10981 clearMyInt();
10982 clearMyFloat();
10983 }
10984
10985 public TestFieldOrderings clone() {
10986 return new TestFieldOrderings().mergeFrom(this);
10987 }
10988
10989 public TestFieldOrderings mergeFrom(TestFieldOrderings other) {
10990 if (other.hasMyString()) {
10991 setMyString(other.getMyString());
10992 }
10993 if (other.hasMyInt()) {
10994 setMyInt(other.getMyInt());
10995 }
10996 if (other.hasMyFloat()) {
10997 setMyFloat(other.getMyFloat());
10998 }
10999 return this;
11000 }
11001
11002 public int serializedSizeUnframed() {
11003 if (memoizedSerializedSize != -1)
11004 return memoizedSerializedSize;
11005
11006 int size = 0;
11007 if (hasMyString()) {
11008 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(11, getMyString());
11009 }
11010 if (hasMyInt()) {
11011 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt64Size(1, getMyInt());
11012 }
11013 if (hasMyFloat()) {
11014 size += org.apache.activemq.protobuf.CodedOutputStream.computeFloatSize(101, getMyFloat());
11015 }
11016 memoizedSerializedSize = size;
11017 return size;
11018 }
11019
11020 public TestFieldOrderings mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
11021 while (true) {
11022 int tag = input.readTag();
11023 if ((tag & 0x07) == 4) {
11024 return this;
11025 }
11026 switch (tag) {
11027 case 0:
11028 return this;
11029 default: {
11030 break;
11031 }
11032 case 90:
11033 setMyString(input.readString());
11034 break;
11035 case 8:
11036 setMyInt(input.readInt64());
11037 break;
11038 case 813:
11039 setMyFloat(input.readFloat());
11040 break;
11041 }
11042 }
11043 }
11044 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
11045 if (hasMyString()) {
11046 output.writeString(11, getMyString());
11047 }
11048 if (hasMyInt()) {
11049 output.writeInt64(1, getMyInt());
11050 }
11051 if (hasMyFloat()) {
11052 output.writeFloat(101, getMyFloat());
11053 }
11054 }
11055
11056 public static TestFieldOrderings parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11057 return new TestFieldOrderings().mergeUnframed(data).checktInitialized();
11058 }
11059
11060 public static TestFieldOrderings parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11061 return new TestFieldOrderings().mergeUnframed(data).checktInitialized();
11062 }
11063
11064 public static TestFieldOrderings parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11065 return new TestFieldOrderings().mergeUnframed(data).checktInitialized();
11066 }
11067
11068 public static TestFieldOrderings parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11069 return new TestFieldOrderings().mergeUnframed(data).checktInitialized();
11070 }
11071
11072 public static TestFieldOrderings parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11073 return new TestFieldOrderings().mergeFramed(data).checktInitialized();
11074 }
11075
11076 public static TestFieldOrderings parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11077 return new TestFieldOrderings().mergeFramed(data).checktInitialized();
11078 }
11079
11080 public static TestFieldOrderings parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11081 return new TestFieldOrderings().mergeFramed(data).checktInitialized();
11082 }
11083
11084 public static TestFieldOrderings parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11085 return new TestFieldOrderings().mergeFramed(data).checktInitialized();
11086 }
11087
11088 public String toString() {
11089 return toString(new java.lang.StringBuilder(), "").toString();
11090 }
11091
11092 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
11093 if( hasMyString() ) {
11094 sb.append(prefix+"my_string: ");
11095 sb.append(getMyString());
11096 sb.append("\n");
11097 }
11098 if( hasMyInt() ) {
11099 sb.append(prefix+"my_int: ");
11100 sb.append(getMyInt());
11101 sb.append("\n");
11102 }
11103 if( hasMyFloat() ) {
11104 sb.append(prefix+"my_float: ");
11105 sb.append(getMyFloat());
11106 sb.append("\n");
11107 }
11108 return sb;
11109 }
11110
11111 public boolean equals(Object obj) {
11112 if( obj==this )
11113 return true;
11114
11115 if( obj==null || obj.getClass()!=TestFieldOrderings.class )
11116 return false;
11117
11118 return equals((TestFieldOrderings)obj);
11119 }
11120
11121 public boolean equals(TestFieldOrderings obj) {
11122 if (hasMyString() ^ obj.hasMyString() )
11123 return false;
11124 if (hasMyString() && ( !getMyString().equals(obj.getMyString()) ))
11125 return false;
11126 if (hasMyInt() ^ obj.hasMyInt() )
11127 return false;
11128 if (hasMyInt() && ( getMyInt()!=obj.getMyInt() ))
11129 return false;
11130 if (hasMyFloat() ^ obj.hasMyFloat() )
11131 return false;
11132 if (hasMyFloat() && ( getMyFloat()!=obj.getMyFloat() ))
11133 return false;
11134 return true;
11135 }
11136
11137 public int hashCode() {
11138 int rc=-1684082025;
11139 if (hasMyString()) {
11140 rc ^= ( -741946115^getMyString().hashCode() );
11141 }
11142 if (hasMyInt()) {
11143 rc ^= ( 74789507^(new Long(getMyInt())).hashCode() );
11144 }
11145 if (hasMyFloat()) {
11146 rc ^= ( -1144559632^(new Double(getMyFloat())).hashCode() );
11147 }
11148 return rc;
11149 }
11150
11151 }
11152
11153 static abstract class TestFieldOrderingsBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
11154
11155 // optional string my_string = 11;
11156 private java.lang.String f_myString = null;
11157 private boolean b_myString;
11158
11159 public boolean hasMyString() {
11160 return this.b_myString;
11161 }
11162
11163 public java.lang.String getMyString() {
11164 return this.f_myString;
11165 }
11166
11167 public T setMyString(java.lang.String myString) {
11168 loadAndClear();
11169 this.b_myString = true;
11170 this.f_myString = myString;
11171 return (T)this;
11172 }
11173
11174 public void clearMyString() {
11175 loadAndClear();
11176 this.b_myString = false;
11177 this.f_myString = null;
11178 }
11179
11180 // optional int64 my_int = 1;
11181 private long f_myInt = 0;
11182 private boolean b_myInt;
11183
11184 public boolean hasMyInt() {
11185 return this.b_myInt;
11186 }
11187
11188 public long getMyInt() {
11189 return this.f_myInt;
11190 }
11191
11192 public T setMyInt(long myInt) {
11193 loadAndClear();
11194 this.b_myInt = true;
11195 this.f_myInt = myInt;
11196 return (T)this;
11197 }
11198
11199 public void clearMyInt() {
11200 loadAndClear();
11201 this.b_myInt = false;
11202 this.f_myInt = 0;
11203 }
11204
11205 // optional float my_float = 101;
11206 private float f_myFloat = 0;
11207 private boolean b_myFloat;
11208
11209 public boolean hasMyFloat() {
11210 return this.b_myFloat;
11211 }
11212
11213 public float getMyFloat() {
11214 return this.f_myFloat;
11215 }
11216
11217 public T setMyFloat(float myFloat) {
11218 loadAndClear();
11219 this.b_myFloat = true;
11220 this.f_myFloat = myFloat;
11221 return (T)this;
11222 }
11223
11224 public void clearMyFloat() {
11225 loadAndClear();
11226 this.b_myFloat = false;
11227 this.f_myFloat = 0;
11228 }
11229
11230 }
11231
11232
11233 static public final class TestExtremeDefaultValues extends TestExtremeDefaultValuesBase<TestExtremeDefaultValues> {
11234
11235 public java.util.ArrayList<String> missingFields() {
11236 java.util.ArrayList<String> missingFields = super.missingFields();
11237 return missingFields;
11238 }
11239
11240 public void clear() {
11241 super.clear();
11242 clearEscapedBytes();
11243 clearLargeUint32();
11244 clearLargeUint64();
11245 clearSmallInt32();
11246 clearSmallInt64();
11247 clearUtf8String();
11248 }
11249
11250 public TestExtremeDefaultValues clone() {
11251 return new TestExtremeDefaultValues().mergeFrom(this);
11252 }
11253
11254 public TestExtremeDefaultValues mergeFrom(TestExtremeDefaultValues other) {
11255 if (other.hasEscapedBytes()) {
11256 setEscapedBytes(other.getEscapedBytes());
11257 }
11258 if (other.hasLargeUint32()) {
11259 setLargeUint32(other.getLargeUint32());
11260 }
11261 if (other.hasLargeUint64()) {
11262 setLargeUint64(other.getLargeUint64());
11263 }
11264 if (other.hasSmallInt32()) {
11265 setSmallInt32(other.getSmallInt32());
11266 }
11267 if (other.hasSmallInt64()) {
11268 setSmallInt64(other.getSmallInt64());
11269 }
11270 if (other.hasUtf8String()) {
11271 setUtf8String(other.getUtf8String());
11272 }
11273 return this;
11274 }
11275
11276 public int serializedSizeUnframed() {
11277 if (memoizedSerializedSize != -1)
11278 return memoizedSerializedSize;
11279
11280 int size = 0;
11281 if (hasEscapedBytes()) {
11282 size += org.apache.activemq.protobuf.CodedOutputStream.computeBytesSize(1, getEscapedBytes());
11283 }
11284 if (hasLargeUint32()) {
11285 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt32Size(2, getLargeUint32());
11286 }
11287 if (hasLargeUint64()) {
11288 size += org.apache.activemq.protobuf.CodedOutputStream.computeUInt64Size(3, getLargeUint64());
11289 }
11290 if (hasSmallInt32()) {
11291 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt32Size(4, getSmallInt32());
11292 }
11293 if (hasSmallInt64()) {
11294 size += org.apache.activemq.protobuf.CodedOutputStream.computeInt64Size(5, getSmallInt64());
11295 }
11296 if (hasUtf8String()) {
11297 size += org.apache.activemq.protobuf.CodedOutputStream.computeStringSize(6, getUtf8String());
11298 }
11299 memoizedSerializedSize = size;
11300 return size;
11301 }
11302
11303 public TestExtremeDefaultValues mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
11304 while (true) {
11305 int tag = input.readTag();
11306 if ((tag & 0x07) == 4) {
11307 return this;
11308 }
11309 switch (tag) {
11310 case 0:
11311 return this;
11312 default: {
11313 break;
11314 }
11315 case 10:
11316 setEscapedBytes(input.readBytes());
11317 break;
11318 case 16:
11319 setLargeUint32(input.readUInt32());
11320 break;
11321 case 24:
11322 setLargeUint64(input.readUInt64());
11323 break;
11324 case 32:
11325 setSmallInt32(input.readInt32());
11326 break;
11327 case 40:
11328 setSmallInt64(input.readInt64());
11329 break;
11330 case 50:
11331 setUtf8String(input.readString());
11332 break;
11333 }
11334 }
11335 }
11336 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
11337 if (hasEscapedBytes()) {
11338 output.writeBytes(1, getEscapedBytes());
11339 }
11340 if (hasLargeUint32()) {
11341 output.writeUInt32(2, getLargeUint32());
11342 }
11343 if (hasLargeUint64()) {
11344 output.writeUInt64(3, getLargeUint64());
11345 }
11346 if (hasSmallInt32()) {
11347 output.writeInt32(4, getSmallInt32());
11348 }
11349 if (hasSmallInt64()) {
11350 output.writeInt64(5, getSmallInt64());
11351 }
11352 if (hasUtf8String()) {
11353 output.writeString(6, getUtf8String());
11354 }
11355 }
11356
11357 public static TestExtremeDefaultValues parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11358 return new TestExtremeDefaultValues().mergeUnframed(data).checktInitialized();
11359 }
11360
11361 public static TestExtremeDefaultValues parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11362 return new TestExtremeDefaultValues().mergeUnframed(data).checktInitialized();
11363 }
11364
11365 public static TestExtremeDefaultValues parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11366 return new TestExtremeDefaultValues().mergeUnframed(data).checktInitialized();
11367 }
11368
11369 public static TestExtremeDefaultValues parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11370 return new TestExtremeDefaultValues().mergeUnframed(data).checktInitialized();
11371 }
11372
11373 public static TestExtremeDefaultValues parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11374 return new TestExtremeDefaultValues().mergeFramed(data).checktInitialized();
11375 }
11376
11377 public static TestExtremeDefaultValues parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11378 return new TestExtremeDefaultValues().mergeFramed(data).checktInitialized();
11379 }
11380
11381 public static TestExtremeDefaultValues parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11382 return new TestExtremeDefaultValues().mergeFramed(data).checktInitialized();
11383 }
11384
11385 public static TestExtremeDefaultValues parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11386 return new TestExtremeDefaultValues().mergeFramed(data).checktInitialized();
11387 }
11388
11389 public String toString() {
11390 return toString(new java.lang.StringBuilder(), "").toString();
11391 }
11392
11393 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
11394 if( hasEscapedBytes() ) {
11395 sb.append(prefix+"escaped_bytes: ");
11396 sb.append(getEscapedBytes());
11397 sb.append("\n");
11398 }
11399 if( hasLargeUint32() ) {
11400 sb.append(prefix+"large_uint32: ");
11401 sb.append(getLargeUint32());
11402 sb.append("\n");
11403 }
11404 if( hasLargeUint64() ) {
11405 sb.append(prefix+"large_uint64: ");
11406 sb.append(getLargeUint64());
11407 sb.append("\n");
11408 }
11409 if( hasSmallInt32() ) {
11410 sb.append(prefix+"small_int32: ");
11411 sb.append(getSmallInt32());
11412 sb.append("\n");
11413 }
11414 if( hasSmallInt64() ) {
11415 sb.append(prefix+"small_int64: ");
11416 sb.append(getSmallInt64());
11417 sb.append("\n");
11418 }
11419 if( hasUtf8String() ) {
11420 sb.append(prefix+"utf8_string: ");
11421 sb.append(getUtf8String());
11422 sb.append("\n");
11423 }
11424 return sb;
11425 }
11426
11427 public boolean equals(Object obj) {
11428 if( obj==this )
11429 return true;
11430
11431 if( obj==null || obj.getClass()!=TestExtremeDefaultValues.class )
11432 return false;
11433
11434 return equals((TestExtremeDefaultValues)obj);
11435 }
11436
11437 public boolean equals(TestExtremeDefaultValues obj) {
11438 if (hasEscapedBytes() ^ obj.hasEscapedBytes() )
11439 return false;
11440 if (hasEscapedBytes() && ( !getEscapedBytes().equals(obj.getEscapedBytes()) ))
11441 return false;
11442 if (hasLargeUint32() ^ obj.hasLargeUint32() )
11443 return false;
11444 if (hasLargeUint32() && ( getLargeUint32()!=obj.getLargeUint32() ))
11445 return false;
11446 if (hasLargeUint64() ^ obj.hasLargeUint64() )
11447 return false;
11448 if (hasLargeUint64() && ( getLargeUint64()!=obj.getLargeUint64() ))
11449 return false;
11450 if (hasSmallInt32() ^ obj.hasSmallInt32() )
11451 return false;
11452 if (hasSmallInt32() && ( getSmallInt32()!=obj.getSmallInt32() ))
11453 return false;
11454 if (hasSmallInt64() ^ obj.hasSmallInt64() )
11455 return false;
11456 if (hasSmallInt64() && ( getSmallInt64()!=obj.getSmallInt64() ))
11457 return false;
11458 if (hasUtf8String() ^ obj.hasUtf8String() )
11459 return false;
11460 if (hasUtf8String() && ( !getUtf8String().equals(obj.getUtf8String()) ))
11461 return false;
11462 return true;
11463 }
11464
11465 public int hashCode() {
11466 int rc=-1192901303;
11467 if (hasEscapedBytes()) {
11468 rc ^= ( -1681187256^getEscapedBytes().hashCode() );
11469 }
11470 if (hasLargeUint32()) {
11471 rc ^= ( 195565108^getLargeUint32() );
11472 }
11473 if (hasLargeUint64()) {
11474 rc ^= ( 195565203^(new Long(getLargeUint64())).hashCode() );
11475 }
11476 if (hasSmallInt32()) {
11477 rc ^= ( -1091976729^getSmallInt32() );
11478 }
11479 if (hasSmallInt64()) {
11480 rc ^= ( -1091976634^(new Long(getSmallInt64())).hashCode() );
11481 }
11482 if (hasUtf8String()) {
11483 rc ^= ( -709624062^getUtf8String().hashCode() );
11484 }
11485 return rc;
11486 }
11487
11488 }
11489
11490 static abstract class TestExtremeDefaultValuesBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
11491
11492 // optional bytes escaped_bytes = 1;
11493 private org.apache.activemq.protobuf.Buffer f_escapedBytes = new org.apache.activemq.protobuf.Buffer("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\ufffd");
11494 private boolean b_escapedBytes;
11495
11496 public boolean hasEscapedBytes() {
11497 return this.b_escapedBytes;
11498 }
11499
11500 public org.apache.activemq.protobuf.Buffer getEscapedBytes() {
11501 return this.f_escapedBytes;
11502 }
11503
11504 public T setEscapedBytes(org.apache.activemq.protobuf.Buffer escapedBytes) {
11505 loadAndClear();
11506 this.b_escapedBytes = true;
11507 this.f_escapedBytes = escapedBytes;
11508 return (T)this;
11509 }
11510
11511 public void clearEscapedBytes() {
11512 loadAndClear();
11513 this.b_escapedBytes = false;
11514 this.f_escapedBytes = new org.apache.activemq.protobuf.Buffer("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\ufffd");
11515 }
11516
11517 // optional uint32 large_uint32 = 2;
11518 private int f_largeUint32 = -1;
11519 private boolean b_largeUint32;
11520
11521 public boolean hasLargeUint32() {
11522 return this.b_largeUint32;
11523 }
11524
11525 public int getLargeUint32() {
11526 return this.f_largeUint32;
11527 }
11528
11529 public T setLargeUint32(int largeUint32) {
11530 loadAndClear();
11531 this.b_largeUint32 = true;
11532 this.f_largeUint32 = largeUint32;
11533 return (T)this;
11534 }
11535
11536 public void clearLargeUint32() {
11537 loadAndClear();
11538 this.b_largeUint32 = false;
11539 this.f_largeUint32 = -1;
11540 }
11541
11542 // optional uint64 large_uint64 = 3;
11543 private long f_largeUint64 = -1l;
11544 private boolean b_largeUint64;
11545
11546 public boolean hasLargeUint64() {
11547 return this.b_largeUint64;
11548 }
11549
11550 public long getLargeUint64() {
11551 return this.f_largeUint64;
11552 }
11553
11554 public T setLargeUint64(long largeUint64) {
11555 loadAndClear();
11556 this.b_largeUint64 = true;
11557 this.f_largeUint64 = largeUint64;
11558 return (T)this;
11559 }
11560
11561 public void clearLargeUint64() {
11562 loadAndClear();
11563 this.b_largeUint64 = false;
11564 this.f_largeUint64 = -1l;
11565 }
11566
11567 // optional int32 small_int32 = 4;
11568 private int f_smallInt32 = -2147483647;
11569 private boolean b_smallInt32;
11570
11571 public boolean hasSmallInt32() {
11572 return this.b_smallInt32;
11573 }
11574
11575 public int getSmallInt32() {
11576 return this.f_smallInt32;
11577 }
11578
11579 public T setSmallInt32(int smallInt32) {
11580 loadAndClear();
11581 this.b_smallInt32 = true;
11582 this.f_smallInt32 = smallInt32;
11583 return (T)this;
11584 }
11585
11586 public void clearSmallInt32() {
11587 loadAndClear();
11588 this.b_smallInt32 = false;
11589 this.f_smallInt32 = -2147483647;
11590 }
11591
11592 // optional int64 small_int64 = 5;
11593 private long f_smallInt64 = -9223372036854775807l;
11594 private boolean b_smallInt64;
11595
11596 public boolean hasSmallInt64() {
11597 return this.b_smallInt64;
11598 }
11599
11600 public long getSmallInt64() {
11601 return this.f_smallInt64;
11602 }
11603
11604 public T setSmallInt64(long smallInt64) {
11605 loadAndClear();
11606 this.b_smallInt64 = true;
11607 this.f_smallInt64 = smallInt64;
11608 return (T)this;
11609 }
11610
11611 public void clearSmallInt64() {
11612 loadAndClear();
11613 this.b_smallInt64 = false;
11614 this.f_smallInt64 = -9223372036854775807l;
11615 }
11616
11617 // optional string utf8_string = 6;
11618 private java.lang.String f_utf8String = "\u1234";
11619 private boolean b_utf8String;
11620
11621 public boolean hasUtf8String() {
11622 return this.b_utf8String;
11623 }
11624
11625 public java.lang.String getUtf8String() {
11626 return this.f_utf8String;
11627 }
11628
11629 public T setUtf8String(java.lang.String utf8String) {
11630 loadAndClear();
11631 this.b_utf8String = true;
11632 this.f_utf8String = utf8String;
11633 return (T)this;
11634 }
11635
11636 public void clearUtf8String() {
11637 loadAndClear();
11638 this.b_utf8String = false;
11639 this.f_utf8String = "\u1234";
11640 }
11641
11642 }
11643
11644
11645 static public final class FooRequest extends FooRequestBase<FooRequest> {
11646
11647 public java.util.ArrayList<String> missingFields() {
11648 java.util.ArrayList<String> missingFields = super.missingFields();
11649 return missingFields;
11650 }
11651
11652 public void clear() {
11653 super.clear();
11654 }
11655
11656 public FooRequest clone() {
11657 return new FooRequest().mergeFrom(this);
11658 }
11659
11660 public FooRequest mergeFrom(FooRequest other) {
11661 return this;
11662 }
11663
11664 public int serializedSizeUnframed() {
11665 if (memoizedSerializedSize != -1)
11666 return memoizedSerializedSize;
11667
11668 int size = 0;
11669 memoizedSerializedSize = size;
11670 return size;
11671 }
11672
11673 public FooRequest mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
11674 while (true) {
11675 int tag = input.readTag();
11676 if ((tag & 0x07) == 4) {
11677 return this;
11678 }
11679 switch (tag) {
11680 case 0:
11681 return this;
11682 default: {
11683 break;
11684 }
11685 }
11686 }
11687 }
11688 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
11689 }
11690
11691 public static FooRequest parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11692 return new FooRequest().mergeUnframed(data).checktInitialized();
11693 }
11694
11695 public static FooRequest parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11696 return new FooRequest().mergeUnframed(data).checktInitialized();
11697 }
11698
11699 public static FooRequest parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11700 return new FooRequest().mergeUnframed(data).checktInitialized();
11701 }
11702
11703 public static FooRequest parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11704 return new FooRequest().mergeUnframed(data).checktInitialized();
11705 }
11706
11707 public static FooRequest parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11708 return new FooRequest().mergeFramed(data).checktInitialized();
11709 }
11710
11711 public static FooRequest parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11712 return new FooRequest().mergeFramed(data).checktInitialized();
11713 }
11714
11715 public static FooRequest parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11716 return new FooRequest().mergeFramed(data).checktInitialized();
11717 }
11718
11719 public static FooRequest parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11720 return new FooRequest().mergeFramed(data).checktInitialized();
11721 }
11722
11723 public String toString() {
11724 return toString(new java.lang.StringBuilder(), "").toString();
11725 }
11726
11727 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
11728 return sb;
11729 }
11730
11731 public boolean equals(Object obj) {
11732 if( obj==this )
11733 return true;
11734
11735 if( obj==null || obj.getClass()!=FooRequest.class )
11736 return false;
11737
11738 return equals((FooRequest)obj);
11739 }
11740
11741 public boolean equals(FooRequest obj) {
11742 return true;
11743 }
11744
11745 public int hashCode() {
11746 int rc=-991228151;
11747 return rc;
11748 }
11749
11750 }
11751
11752 static abstract class FooRequestBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
11753
11754 }
11755
11756
11757 static public final class FooResponse extends FooResponseBase<FooResponse> {
11758
11759 public java.util.ArrayList<String> missingFields() {
11760 java.util.ArrayList<String> missingFields = super.missingFields();
11761 return missingFields;
11762 }
11763
11764 public void clear() {
11765 super.clear();
11766 }
11767
11768 public FooResponse clone() {
11769 return new FooResponse().mergeFrom(this);
11770 }
11771
11772 public FooResponse mergeFrom(FooResponse other) {
11773 return this;
11774 }
11775
11776 public int serializedSizeUnframed() {
11777 if (memoizedSerializedSize != -1)
11778 return memoizedSerializedSize;
11779
11780 int size = 0;
11781 memoizedSerializedSize = size;
11782 return size;
11783 }
11784
11785 public FooResponse mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
11786 while (true) {
11787 int tag = input.readTag();
11788 if ((tag & 0x07) == 4) {
11789 return this;
11790 }
11791 switch (tag) {
11792 case 0:
11793 return this;
11794 default: {
11795 break;
11796 }
11797 }
11798 }
11799 }
11800 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
11801 }
11802
11803 public static FooResponse parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11804 return new FooResponse().mergeUnframed(data).checktInitialized();
11805 }
11806
11807 public static FooResponse parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11808 return new FooResponse().mergeUnframed(data).checktInitialized();
11809 }
11810
11811 public static FooResponse parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11812 return new FooResponse().mergeUnframed(data).checktInitialized();
11813 }
11814
11815 public static FooResponse parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11816 return new FooResponse().mergeUnframed(data).checktInitialized();
11817 }
11818
11819 public static FooResponse parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11820 return new FooResponse().mergeFramed(data).checktInitialized();
11821 }
11822
11823 public static FooResponse parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11824 return new FooResponse().mergeFramed(data).checktInitialized();
11825 }
11826
11827 public static FooResponse parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11828 return new FooResponse().mergeFramed(data).checktInitialized();
11829 }
11830
11831 public static FooResponse parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11832 return new FooResponse().mergeFramed(data).checktInitialized();
11833 }
11834
11835 public String toString() {
11836 return toString(new java.lang.StringBuilder(), "").toString();
11837 }
11838
11839 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
11840 return sb;
11841 }
11842
11843 public boolean equals(Object obj) {
11844 if( obj==this )
11845 return true;
11846
11847 if( obj==null || obj.getClass()!=FooResponse.class )
11848 return false;
11849
11850 return equals((FooResponse)obj);
11851 }
11852
11853 public boolean equals(FooResponse obj) {
11854 return true;
11855 }
11856
11857 public int hashCode() {
11858 int rc=-610367737;
11859 return rc;
11860 }
11861
11862 }
11863
11864 static abstract class FooResponseBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
11865
11866 }
11867
11868
11869 static public final class BarRequest extends BarRequestBase<BarRequest> {
11870
11871 public java.util.ArrayList<String> missingFields() {
11872 java.util.ArrayList<String> missingFields = super.missingFields();
11873 return missingFields;
11874 }
11875
11876 public void clear() {
11877 super.clear();
11878 }
11879
11880 public BarRequest clone() {
11881 return new BarRequest().mergeFrom(this);
11882 }
11883
11884 public BarRequest mergeFrom(BarRequest other) {
11885 return this;
11886 }
11887
11888 public int serializedSizeUnframed() {
11889 if (memoizedSerializedSize != -1)
11890 return memoizedSerializedSize;
11891
11892 int size = 0;
11893 memoizedSerializedSize = size;
11894 return size;
11895 }
11896
11897 public BarRequest mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
11898 while (true) {
11899 int tag = input.readTag();
11900 if ((tag & 0x07) == 4) {
11901 return this;
11902 }
11903 switch (tag) {
11904 case 0:
11905 return this;
11906 default: {
11907 break;
11908 }
11909 }
11910 }
11911 }
11912 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
11913 }
11914
11915 public static BarRequest parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11916 return new BarRequest().mergeUnframed(data).checktInitialized();
11917 }
11918
11919 public static BarRequest parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11920 return new BarRequest().mergeUnframed(data).checktInitialized();
11921 }
11922
11923 public static BarRequest parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11924 return new BarRequest().mergeUnframed(data).checktInitialized();
11925 }
11926
11927 public static BarRequest parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11928 return new BarRequest().mergeUnframed(data).checktInitialized();
11929 }
11930
11931 public static BarRequest parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11932 return new BarRequest().mergeFramed(data).checktInitialized();
11933 }
11934
11935 public static BarRequest parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11936 return new BarRequest().mergeFramed(data).checktInitialized();
11937 }
11938
11939 public static BarRequest parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
11940 return new BarRequest().mergeFramed(data).checktInitialized();
11941 }
11942
11943 public static BarRequest parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
11944 return new BarRequest().mergeFramed(data).checktInitialized();
11945 }
11946
11947 public String toString() {
11948 return toString(new java.lang.StringBuilder(), "").toString();
11949 }
11950
11951 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
11952 return sb;
11953 }
11954
11955 public boolean equals(Object obj) {
11956 if( obj==this )
11957 return true;
11958
11959 if( obj==null || obj.getClass()!=BarRequest.class )
11960 return false;
11961
11962 return equals((BarRequest)obj);
11963 }
11964
11965 public boolean equals(BarRequest obj) {
11966 return true;
11967 }
11968
11969 public int hashCode() {
11970 int rc=262848284;
11971 return rc;
11972 }
11973
11974 }
11975
11976 static abstract class BarRequestBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
11977
11978 }
11979
11980
11981 static public final class BarResponse extends BarResponseBase<BarResponse> {
11982
11983 public java.util.ArrayList<String> missingFields() {
11984 java.util.ArrayList<String> missingFields = super.missingFields();
11985 return missingFields;
11986 }
11987
11988 public void clear() {
11989 super.clear();
11990 }
11991
11992 public BarResponse clone() {
11993 return new BarResponse().mergeFrom(this);
11994 }
11995
11996 public BarResponse mergeFrom(BarResponse other) {
11997 return this;
11998 }
11999
12000 public int serializedSizeUnframed() {
12001 if (memoizedSerializedSize != -1)
12002 return memoizedSerializedSize;
12003
12004 int size = 0;
12005 memoizedSerializedSize = size;
12006 return size;
12007 }
12008
12009 public BarResponse mergeUnframed(org.apache.activemq.protobuf.CodedInputStream input) throws java.io.IOException {
12010 while (true) {
12011 int tag = input.readTag();
12012 if ((tag & 0x07) == 4) {
12013 return this;
12014 }
12015 switch (tag) {
12016 case 0:
12017 return this;
12018 default: {
12019 break;
12020 }
12021 }
12022 }
12023 }
12024 public void writeUnframed(org.apache.activemq.protobuf.CodedOutputStream output) throws java.io.IOException {
12025 }
12026
12027 public static BarResponse parseUnframed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
12028 return new BarResponse().mergeUnframed(data).checktInitialized();
12029 }
12030
12031 public static BarResponse parseUnframed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
12032 return new BarResponse().mergeUnframed(data).checktInitialized();
12033 }
12034
12035 public static BarResponse parseUnframed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
12036 return new BarResponse().mergeUnframed(data).checktInitialized();
12037 }
12038
12039 public static BarResponse parseUnframed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
12040 return new BarResponse().mergeUnframed(data).checktInitialized();
12041 }
12042
12043 public static BarResponse parseFramed(org.apache.activemq.protobuf.CodedInputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
12044 return new BarResponse().mergeFramed(data).checktInitialized();
12045 }
12046
12047 public static BarResponse parseFramed(org.apache.activemq.protobuf.Buffer data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
12048 return new BarResponse().mergeFramed(data).checktInitialized();
12049 }
12050
12051 public static BarResponse parseFramed(byte[] data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException {
12052 return new BarResponse().mergeFramed(data).checktInitialized();
12053 }
12054
12055 public static BarResponse parseFramed(java.io.InputStream data) throws org.apache.activemq.protobuf.InvalidProtocolBufferException, java.io.IOException {
12056 return new BarResponse().mergeFramed(data).checktInitialized();
12057 }
12058
12059 public String toString() {
12060 return toString(new java.lang.StringBuilder(), "").toString();
12061 }
12062
12063 public java.lang.StringBuilder toString(java.lang.StringBuilder sb, String prefix) {
12064 return sb;
12065 }
12066
12067 public boolean equals(Object obj) {
12068 if( obj==this )
12069 return true;
12070
12071 if( obj==null || obj.getClass()!=BarResponse.class )
12072 return false;
12073
12074 return equals((BarResponse)obj);
12075 }
12076
12077 public boolean equals(BarResponse obj) {
12078 return true;
12079 }
12080
12081 public int hashCode() {
12082 int rc=-388703916;
12083 return rc;
12084 }
12085
12086 }
12087
12088 static abstract class BarResponseBase<T> extends org.apache.activemq.protobuf.BaseMessage<T> {
12089
12090 }
12091
12092 }