1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package io.netty.example.worldclock;
21
22 @SuppressWarnings("all")
23 public final class WorldClockProtocol {
24 private WorldClockProtocol() {}
25 public static void registerAllExtensions(
26 com.google.protobuf.ExtensionRegistry registry) {
27 }
28
29
30
31 public enum Continent
32 implements com.google.protobuf.ProtocolMessageEnum {
33
34
35
36 AFRICA(0, 0),
37
38
39
40 AMERICA(1, 1),
41
42
43
44 ANTARCTICA(2, 2),
45
46
47
48 ARCTIC(3, 3),
49
50
51
52 ASIA(4, 4),
53
54
55
56 ATLANTIC(5, 5),
57
58
59
60 AUSTRALIA(6, 6),
61
62
63
64 EUROPE(7, 7),
65
66
67
68 INDIAN(8, 8),
69
70
71
72 MIDEAST(9, 9),
73
74
75
76 PACIFIC(10, 10),
77 ;
78
79
80
81
82 public static final int AFRICA_VALUE = 0;
83
84
85
86 public static final int AMERICA_VALUE = 1;
87
88
89
90 public static final int ANTARCTICA_VALUE = 2;
91
92
93
94 public static final int ARCTIC_VALUE = 3;
95
96
97
98 public static final int ASIA_VALUE = 4;
99
100
101
102 public static final int ATLANTIC_VALUE = 5;
103
104
105
106 public static final int AUSTRALIA_VALUE = 6;
107
108
109
110 public static final int EUROPE_VALUE = 7;
111
112
113
114 public static final int INDIAN_VALUE = 8;
115
116
117
118 public static final int MIDEAST_VALUE = 9;
119
120
121
122 public static final int PACIFIC_VALUE = 10;
123
124
125 public final int getNumber() { return value; }
126
127 public static Continent valueOf(int value) {
128 switch (value) {
129 case 0: return AFRICA;
130 case 1: return AMERICA;
131 case 2: return ANTARCTICA;
132 case 3: return ARCTIC;
133 case 4: return ASIA;
134 case 5: return ATLANTIC;
135 case 6: return AUSTRALIA;
136 case 7: return EUROPE;
137 case 8: return INDIAN;
138 case 9: return MIDEAST;
139 case 10: return PACIFIC;
140 default: return null;
141 }
142 }
143
144 public static com.google.protobuf.Internal.EnumLiteMap<Continent>
145 internalGetValueMap() {
146 return internalValueMap;
147 }
148 private static com.google.protobuf.Internal.EnumLiteMap<Continent>
149 internalValueMap =
150 new com.google.protobuf.Internal.EnumLiteMap<Continent>() {
151 public Continent findValueByNumber(int number) {
152 return Continent.valueOf(number);
153 }
154 };
155
156 public final com.google.protobuf.Descriptors.EnumValueDescriptor
157 getValueDescriptor() {
158 return getDescriptor().getValues().get(index);
159 }
160 public final com.google.protobuf.Descriptors.EnumDescriptor
161 getDescriptorForType() {
162 return getDescriptor();
163 }
164 public static final com.google.protobuf.Descriptors.EnumDescriptor
165 getDescriptor() {
166 return io.netty.example.worldclock.WorldClockProtocol.getDescriptor().getEnumTypes().get(0);
167 }
168
169 private static final Continent[] VALUES = values();
170
171 public static Continent valueOf(
172 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
173 if (desc.getType() != getDescriptor()) {
174 throw new java.lang.IllegalArgumentException(
175 "EnumValueDescriptor is not for this type.");
176 }
177 return VALUES[desc.getIndex()];
178 }
179
180 private final int index;
181 private final int value;
182
183 private Continent(int index, int value) {
184 this.index = index;
185 this.value = value;
186 }
187
188
189 }
190
191
192
193
194 public enum DayOfWeek
195 implements com.google.protobuf.ProtocolMessageEnum {
196
197
198
199 SUNDAY(0, 1),
200
201
202
203 MONDAY(1, 2),
204
205
206
207 TUESDAY(2, 3),
208
209
210
211 WEDNESDAY(3, 4),
212
213
214
215 THURSDAY(4, 5),
216
217
218
219 FRIDAY(5, 6),
220
221
222
223 SATURDAY(6, 7),
224 ;
225
226
227
228
229 public static final int SUNDAY_VALUE = 1;
230
231
232
233 public static final int MONDAY_VALUE = 2;
234
235
236
237 public static final int TUESDAY_VALUE = 3;
238
239
240
241 public static final int WEDNESDAY_VALUE = 4;
242
243
244
245 public static final int THURSDAY_VALUE = 5;
246
247
248
249 public static final int FRIDAY_VALUE = 6;
250
251
252
253 public static final int SATURDAY_VALUE = 7;
254
255
256 public final int getNumber() { return value; }
257
258 public static DayOfWeek valueOf(int value) {
259 switch (value) {
260 case 1: return SUNDAY;
261 case 2: return MONDAY;
262 case 3: return TUESDAY;
263 case 4: return WEDNESDAY;
264 case 5: return THURSDAY;
265 case 6: return FRIDAY;
266 case 7: return SATURDAY;
267 default: return null;
268 }
269 }
270
271 public static com.google.protobuf.Internal.EnumLiteMap<DayOfWeek>
272 internalGetValueMap() {
273 return internalValueMap;
274 }
275 private static com.google.protobuf.Internal.EnumLiteMap<DayOfWeek>
276 internalValueMap =
277 new com.google.protobuf.Internal.EnumLiteMap<DayOfWeek>() {
278 public DayOfWeek findValueByNumber(int number) {
279 return DayOfWeek.valueOf(number);
280 }
281 };
282
283 public final com.google.protobuf.Descriptors.EnumValueDescriptor
284 getValueDescriptor() {
285 return getDescriptor().getValues().get(index);
286 }
287 public final com.google.protobuf.Descriptors.EnumDescriptor
288 getDescriptorForType() {
289 return getDescriptor();
290 }
291 public static final com.google.protobuf.Descriptors.EnumDescriptor
292 getDescriptor() {
293 return io.netty.example.worldclock.WorldClockProtocol.getDescriptor().getEnumTypes().get(1);
294 }
295
296 private static final DayOfWeek[] VALUES = values();
297
298 public static DayOfWeek valueOf(
299 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
300 if (desc.getType() != getDescriptor()) {
301 throw new java.lang.IllegalArgumentException(
302 "EnumValueDescriptor is not for this type.");
303 }
304 return VALUES[desc.getIndex()];
305 }
306
307 private final int index;
308 private final int value;
309
310 private DayOfWeek(int index, int value) {
311 this.index = index;
312 this.value = value;
313 }
314
315
316 }
317
318 public interface LocationOrBuilder
319 extends com.google.protobuf.MessageOrBuilder {
320
321
322
323
324
325 boolean hasContinent();
326
327
328
329 io.netty.example.worldclock.WorldClockProtocol.Continent getContinent();
330
331
332
333
334
335 boolean hasCity();
336
337
338
339 java.lang.String getCity();
340
341
342
343 com.google.protobuf.ByteString
344 getCityBytes();
345 }
346
347
348
349 public static final class Location extends
350 com.google.protobuf.GeneratedMessage
351 implements LocationOrBuilder {
352
353 private Location(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
354 super(builder);
355 this.unknownFields = builder.getUnknownFields();
356 }
357 private Location(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
358
359 private static final Location defaultInstance;
360 public static Location getDefaultInstance() {
361 return defaultInstance;
362 }
363
364 public Location getDefaultInstanceForType() {
365 return defaultInstance;
366 }
367
368 private final com.google.protobuf.UnknownFieldSet unknownFields;
369 @java.lang.Override
370 public final com.google.protobuf.UnknownFieldSet
371 getUnknownFields() {
372 return this.unknownFields;
373 }
374 private Location(
375 com.google.protobuf.CodedInputStream input,
376 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
377 throws com.google.protobuf.InvalidProtocolBufferException {
378 initFields();
379 int mutable_bitField0_ = 0;
380 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
381 com.google.protobuf.UnknownFieldSet.newBuilder();
382 try {
383 boolean done = false;
384 while (!done) {
385 int tag = input.readTag();
386 switch (tag) {
387 case 0:
388 done = true;
389 break;
390 default: {
391 if (!parseUnknownField(input, unknownFields,
392 extensionRegistry, tag)) {
393 done = true;
394 }
395 break;
396 }
397 case 8: {
398 int rawValue = input.readEnum();
399 io.netty.example.worldclock.WorldClockProtocol.Continent value = io.netty.example.worldclock.WorldClockProtocol.Continent.valueOf(rawValue);
400 if (value == null) {
401 unknownFields.mergeVarintField(1, rawValue);
402 } else {
403 bitField0_ |= 0x00000001;
404 continent_ = value;
405 }
406 break;
407 }
408 case 18: {
409 bitField0_ |= 0x00000002;
410 city_ = input.readBytes();
411 break;
412 }
413 }
414 }
415 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
416 throw e.setUnfinishedMessage(this);
417 } catch (java.io.IOException e) {
418 throw new com.google.protobuf.InvalidProtocolBufferException(
419 e.getMessage()).setUnfinishedMessage(this);
420 } finally {
421 this.unknownFields = unknownFields.build();
422 makeExtensionsImmutable();
423 }
424 }
425 public static final com.google.protobuf.Descriptors.Descriptor
426 getDescriptor() {
427 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Location_descriptor;
428 }
429
430 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
431 internalGetFieldAccessorTable() {
432 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Location_fieldAccessorTable
433 .ensureFieldAccessorsInitialized(
434 io.netty.example.worldclock.WorldClockProtocol.Location.class, io.netty.example.worldclock.WorldClockProtocol.Location.Builder.class);
435 }
436
437 public static com.google.protobuf.Parser<Location> PARSER =
438 new com.google.protobuf.AbstractParser<Location>() {
439 public Location parsePartialFrom(
440 com.google.protobuf.CodedInputStream input,
441 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
442 throws com.google.protobuf.InvalidProtocolBufferException {
443 return new Location(input, extensionRegistry);
444 }
445 };
446
447 @java.lang.Override
448 public com.google.protobuf.Parser<Location> getParserForType() {
449 return PARSER;
450 }
451
452 private int bitField0_;
453
454 public static final int CONTINENT_FIELD_NUMBER = 1;
455 private io.netty.example.worldclock.WorldClockProtocol.Continent continent_;
456
457
458
459 public boolean hasContinent() {
460 return ((bitField0_ & 0x00000001) == 0x00000001);
461 }
462
463
464
465 public io.netty.example.worldclock.WorldClockProtocol.Continent getContinent() {
466 return continent_;
467 }
468
469
470 public static final int CITY_FIELD_NUMBER = 2;
471 private java.lang.Object city_;
472
473
474
475 public boolean hasCity() {
476 return ((bitField0_ & 0x00000002) == 0x00000002);
477 }
478
479
480
481 public java.lang.String getCity() {
482 java.lang.Object ref = city_;
483 if (ref instanceof java.lang.String) {
484 return (java.lang.String) ref;
485 } else {
486 com.google.protobuf.ByteString bs =
487 (com.google.protobuf.ByteString) ref;
488 java.lang.String s = bs.toStringUtf8();
489 if (bs.isValidUtf8()) {
490 city_ = s;
491 }
492 return s;
493 }
494 }
495
496
497
498 public com.google.protobuf.ByteString
499 getCityBytes() {
500 java.lang.Object ref = city_;
501 if (ref instanceof java.lang.String) {
502 com.google.protobuf.ByteString b =
503 com.google.protobuf.ByteString.copyFromUtf8(
504 (java.lang.String) ref);
505 city_ = b;
506 return b;
507 } else {
508 return (com.google.protobuf.ByteString) ref;
509 }
510 }
511
512 private void initFields() {
513 continent_ = io.netty.example.worldclock.WorldClockProtocol.Continent.AFRICA;
514 city_ = "";
515 }
516 private byte memoizedIsInitialized = -1;
517 public final boolean isInitialized() {
518 byte isInitialized = memoizedIsInitialized;
519 if (isInitialized != -1) return isInitialized == 1;
520
521 if (!hasContinent()) {
522 memoizedIsInitialized = 0;
523 return false;
524 }
525 if (!hasCity()) {
526 memoizedIsInitialized = 0;
527 return false;
528 }
529 memoizedIsInitialized = 1;
530 return true;
531 }
532
533 public void writeTo(com.google.protobuf.CodedOutputStream output)
534 throws java.io.IOException {
535 getSerializedSize();
536 if (((bitField0_ & 0x00000001) == 0x00000001)) {
537 output.writeEnum(1, continent_.getNumber());
538 }
539 if (((bitField0_ & 0x00000002) == 0x00000002)) {
540 output.writeBytes(2, getCityBytes());
541 }
542 getUnknownFields().writeTo(output);
543 }
544
545 private int memoizedSerializedSize = -1;
546 public int getSerializedSize() {
547 int size = memoizedSerializedSize;
548 if (size != -1) return size;
549
550 size = 0;
551 if (((bitField0_ & 0x00000001) == 0x00000001)) {
552 size += com.google.protobuf.CodedOutputStream
553 .computeEnumSize(1, continent_.getNumber());
554 }
555 if (((bitField0_ & 0x00000002) == 0x00000002)) {
556 size += com.google.protobuf.CodedOutputStream
557 .computeBytesSize(2, getCityBytes());
558 }
559 size += getUnknownFields().getSerializedSize();
560 memoizedSerializedSize = size;
561 return size;
562 }
563
564 private static final long serialVersionUID = 0L;
565 @java.lang.Override
566 protected java.lang.Object writeReplace()
567 throws java.io.ObjectStreamException {
568 return super.writeReplace();
569 }
570
571 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(
572 com.google.protobuf.ByteString data)
573 throws com.google.protobuf.InvalidProtocolBufferException {
574 return PARSER.parseFrom(data);
575 }
576 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(
577 com.google.protobuf.ByteString data,
578 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
579 throws com.google.protobuf.InvalidProtocolBufferException {
580 return PARSER.parseFrom(data, extensionRegistry);
581 }
582 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(byte[] data)
583 throws com.google.protobuf.InvalidProtocolBufferException {
584 return PARSER.parseFrom(data);
585 }
586 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(
587 byte[] data,
588 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
589 throws com.google.protobuf.InvalidProtocolBufferException {
590 return PARSER.parseFrom(data, extensionRegistry);
591 }
592 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(java.io.InputStream input)
593 throws java.io.IOException {
594 return PARSER.parseFrom(input);
595 }
596 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(
597 java.io.InputStream input,
598 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
599 throws java.io.IOException {
600 return PARSER.parseFrom(input, extensionRegistry);
601 }
602 public static io.netty.example.worldclock.WorldClockProtocol.Location parseDelimitedFrom(java.io.InputStream input)
603 throws java.io.IOException {
604 return PARSER.parseDelimitedFrom(input);
605 }
606 public static io.netty.example.worldclock.WorldClockProtocol.Location parseDelimitedFrom(
607 java.io.InputStream input,
608 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
609 throws java.io.IOException {
610 return PARSER.parseDelimitedFrom(input, extensionRegistry);
611 }
612 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(
613 com.google.protobuf.CodedInputStream input)
614 throws java.io.IOException {
615 return PARSER.parseFrom(input);
616 }
617 public static io.netty.example.worldclock.WorldClockProtocol.Location parseFrom(
618 com.google.protobuf.CodedInputStream input,
619 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
620 throws java.io.IOException {
621 return PARSER.parseFrom(input, extensionRegistry);
622 }
623
624 public static Builder newBuilder() { return Builder.create(); }
625 public Builder newBuilderForType() { return newBuilder(); }
626 public static Builder newBuilder(io.netty.example.worldclock.WorldClockProtocol.Location prototype) {
627 return newBuilder().mergeFrom(prototype);
628 }
629 public Builder toBuilder() { return newBuilder(this); }
630
631 @java.lang.Override
632 protected Builder newBuilderForType(
633 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
634 Builder builder = new Builder(parent);
635 return builder;
636 }
637
638
639
640 public static final class Builder extends
641 com.google.protobuf.GeneratedMessage.Builder<Builder>
642 implements io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder {
643 public static final com.google.protobuf.Descriptors.Descriptor
644 getDescriptor() {
645 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Location_descriptor;
646 }
647
648 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
649 internalGetFieldAccessorTable() {
650 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Location_fieldAccessorTable
651 .ensureFieldAccessorsInitialized(
652 io.netty.example.worldclock.WorldClockProtocol.Location.class, io.netty.example.worldclock.WorldClockProtocol.Location.Builder.class);
653 }
654
655
656 private Builder() {
657 maybeForceBuilderInitialization();
658 }
659
660 private Builder(
661 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
662 super(parent);
663 maybeForceBuilderInitialization();
664 }
665 private void maybeForceBuilderInitialization() {
666 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
667 }
668 }
669 private static Builder create() {
670 return new Builder();
671 }
672
673 public Builder clear() {
674 super.clear();
675 continent_ = io.netty.example.worldclock.WorldClockProtocol.Continent.AFRICA;
676 bitField0_ = (bitField0_ & ~0x00000001);
677 city_ = "";
678 bitField0_ = (bitField0_ & ~0x00000002);
679 return this;
680 }
681
682 public Builder clone() {
683 return create().mergeFrom(buildPartial());
684 }
685
686 public com.google.protobuf.Descriptors.Descriptor
687 getDescriptorForType() {
688 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Location_descriptor;
689 }
690
691 public io.netty.example.worldclock.WorldClockProtocol.Location getDefaultInstanceForType() {
692 return io.netty.example.worldclock.WorldClockProtocol.Location.getDefaultInstance();
693 }
694
695 public io.netty.example.worldclock.WorldClockProtocol.Location build() {
696 io.netty.example.worldclock.WorldClockProtocol.Location result = buildPartial();
697 if (!result.isInitialized()) {
698 throw newUninitializedMessageException(result);
699 }
700 return result;
701 }
702
703 public io.netty.example.worldclock.WorldClockProtocol.Location buildPartial() {
704 io.netty.example.worldclock.WorldClockProtocol.Location result = new io.netty.example.worldclock.WorldClockProtocol.Location(this);
705 int from_bitField0_ = bitField0_;
706 int to_bitField0_ = 0;
707 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
708 to_bitField0_ |= 0x00000001;
709 }
710 result.continent_ = continent_;
711 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
712 to_bitField0_ |= 0x00000002;
713 }
714 result.city_ = city_;
715 result.bitField0_ = to_bitField0_;
716 onBuilt();
717 return result;
718 }
719
720 public Builder mergeFrom(com.google.protobuf.Message other) {
721 if (other instanceof io.netty.example.worldclock.WorldClockProtocol.Location) {
722 return mergeFrom((io.netty.example.worldclock.WorldClockProtocol.Location)other);
723 } else {
724 super.mergeFrom(other);
725 return this;
726 }
727 }
728
729 public Builder mergeFrom(io.netty.example.worldclock.WorldClockProtocol.Location other) {
730 if (other == io.netty.example.worldclock.WorldClockProtocol.Location.getDefaultInstance()) return this;
731 if (other.hasContinent()) {
732 setContinent(other.getContinent());
733 }
734 if (other.hasCity()) {
735 bitField0_ |= 0x00000002;
736 city_ = other.city_;
737 onChanged();
738 }
739 this.mergeUnknownFields(other.getUnknownFields());
740 return this;
741 }
742
743 public final boolean isInitialized() {
744 if (!hasContinent()) {
745
746 return false;
747 }
748 if (!hasCity()) {
749
750 return false;
751 }
752 return true;
753 }
754
755 public Builder mergeFrom(
756 com.google.protobuf.CodedInputStream input,
757 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
758 throws java.io.IOException {
759 io.netty.example.worldclock.WorldClockProtocol.Location parsedMessage = null;
760 try {
761 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
762 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
763 parsedMessage = (io.netty.example.worldclock.WorldClockProtocol.Location) e.getUnfinishedMessage();
764 throw e;
765 } finally {
766 if (parsedMessage != null) {
767 mergeFrom(parsedMessage);
768 }
769 }
770 return this;
771 }
772 private int bitField0_;
773
774
775 private io.netty.example.worldclock.WorldClockProtocol.Continent continent_ = io.netty.example.worldclock.WorldClockProtocol.Continent.AFRICA;
776
777
778
779 public boolean hasContinent() {
780 return ((bitField0_ & 0x00000001) == 0x00000001);
781 }
782
783
784
785 public io.netty.example.worldclock.WorldClockProtocol.Continent getContinent() {
786 return continent_;
787 }
788
789
790
791 public Builder setContinent(io.netty.example.worldclock.WorldClockProtocol.Continent value) {
792 if (value == null) {
793 throw new NullPointerException();
794 }
795 bitField0_ |= 0x00000001;
796 continent_ = value;
797 onChanged();
798 return this;
799 }
800
801
802
803 public Builder clearContinent() {
804 bitField0_ = (bitField0_ & ~0x00000001);
805 continent_ = io.netty.example.worldclock.WorldClockProtocol.Continent.AFRICA;
806 onChanged();
807 return this;
808 }
809
810
811 private java.lang.Object city_ = "";
812
813
814
815 public boolean hasCity() {
816 return ((bitField0_ & 0x00000002) == 0x00000002);
817 }
818
819
820
821 public java.lang.String getCity() {
822 java.lang.Object ref = city_;
823 if (!(ref instanceof java.lang.String)) {
824 java.lang.String s = ((com.google.protobuf.ByteString) ref)
825 .toStringUtf8();
826 city_ = s;
827 return s;
828 } else {
829 return (java.lang.String) ref;
830 }
831 }
832
833
834
835 public com.google.protobuf.ByteString
836 getCityBytes() {
837 java.lang.Object ref = city_;
838 if (ref instanceof String) {
839 com.google.protobuf.ByteString b =
840 com.google.protobuf.ByteString.copyFromUtf8(
841 (java.lang.String) ref);
842 city_ = b;
843 return b;
844 } else {
845 return (com.google.protobuf.ByteString) ref;
846 }
847 }
848
849
850
851 public Builder setCity(
852 java.lang.String value) {
853 if (value == null) {
854 throw new NullPointerException();
855 }
856 bitField0_ |= 0x00000002;
857 city_ = value;
858 onChanged();
859 return this;
860 }
861
862
863
864 public Builder clearCity() {
865 bitField0_ = (bitField0_ & ~0x00000002);
866 city_ = getDefaultInstance().getCity();
867 onChanged();
868 return this;
869 }
870
871
872
873 public Builder setCityBytes(
874 com.google.protobuf.ByteString value) {
875 if (value == null) {
876 throw new NullPointerException();
877 }
878 bitField0_ |= 0x00000002;
879 city_ = value;
880 onChanged();
881 return this;
882 }
883
884
885 }
886
887 static {
888 defaultInstance = new Location(true);
889 defaultInstance.initFields();
890 }
891
892
893 }
894
895 public interface LocationsOrBuilder
896 extends com.google.protobuf.MessageOrBuilder {
897
898
899
900
901
902 java.util.List<io.netty.example.worldclock.WorldClockProtocol.Location>
903 getLocationList();
904
905
906
907 io.netty.example.worldclock.WorldClockProtocol.Location getLocation(int index);
908
909
910
911 int getLocationCount();
912
913
914
915 java.util.List<? extends io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder>
916 getLocationOrBuilderList();
917
918
919
920 io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder getLocationOrBuilder(
921 int index);
922 }
923
924
925
926 public static final class Locations extends
927 com.google.protobuf.GeneratedMessage
928 implements LocationsOrBuilder {
929
930 private Locations(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
931 super(builder);
932 this.unknownFields = builder.getUnknownFields();
933 }
934 private Locations(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
935
936 private static final Locations defaultInstance;
937 public static Locations getDefaultInstance() {
938 return defaultInstance;
939 }
940
941 public Locations getDefaultInstanceForType() {
942 return defaultInstance;
943 }
944
945 private final com.google.protobuf.UnknownFieldSet unknownFields;
946 @java.lang.Override
947 public final com.google.protobuf.UnknownFieldSet
948 getUnknownFields() {
949 return this.unknownFields;
950 }
951 private Locations(
952 com.google.protobuf.CodedInputStream input,
953 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
954 throws com.google.protobuf.InvalidProtocolBufferException {
955 initFields();
956 int mutable_bitField0_ = 0;
957 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
958 com.google.protobuf.UnknownFieldSet.newBuilder();
959 try {
960 boolean done = false;
961 while (!done) {
962 int tag = input.readTag();
963 switch (tag) {
964 case 0:
965 done = true;
966 break;
967 default: {
968 if (!parseUnknownField(input, unknownFields,
969 extensionRegistry, tag)) {
970 done = true;
971 }
972 break;
973 }
974 case 10: {
975 if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
976 location_ = new java.util.ArrayList<io.netty.example.worldclock.WorldClockProtocol.Location>();
977 mutable_bitField0_ |= 0x00000001;
978 }
979 location_.add(input.readMessage(io.netty.example.worldclock.WorldClockProtocol.Location.PARSER, extensionRegistry));
980 break;
981 }
982 }
983 }
984 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
985 throw e.setUnfinishedMessage(this);
986 } catch (java.io.IOException e) {
987 throw new com.google.protobuf.InvalidProtocolBufferException(
988 e.getMessage()).setUnfinishedMessage(this);
989 } finally {
990 if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
991 location_ = java.util.Collections.unmodifiableList(location_);
992 }
993 this.unknownFields = unknownFields.build();
994 makeExtensionsImmutable();
995 }
996 }
997 public static final com.google.protobuf.Descriptors.Descriptor
998 getDescriptor() {
999 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Locations_descriptor;
1000 }
1001
1002 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1003 internalGetFieldAccessorTable() {
1004 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Locations_fieldAccessorTable
1005 .ensureFieldAccessorsInitialized(
1006 io.netty.example.worldclock.WorldClockProtocol.Locations.class, io.netty.example.worldclock.WorldClockProtocol.Locations.Builder.class);
1007 }
1008
1009 public static com.google.protobuf.Parser<Locations> PARSER =
1010 new com.google.protobuf.AbstractParser<Locations>() {
1011 public Locations parsePartialFrom(
1012 com.google.protobuf.CodedInputStream input,
1013 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1014 throws com.google.protobuf.InvalidProtocolBufferException {
1015 return new Locations(input, extensionRegistry);
1016 }
1017 };
1018
1019 @java.lang.Override
1020 public com.google.protobuf.Parser<Locations> getParserForType() {
1021 return PARSER;
1022 }
1023
1024
1025 public static final int LOCATION_FIELD_NUMBER = 1;
1026 private java.util.List<io.netty.example.worldclock.WorldClockProtocol.Location> location_;
1027
1028
1029
1030 public java.util.List<io.netty.example.worldclock.WorldClockProtocol.Location> getLocationList() {
1031 return location_;
1032 }
1033
1034
1035
1036 public java.util.List<? extends io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder>
1037 getLocationOrBuilderList() {
1038 return location_;
1039 }
1040
1041
1042
1043 public int getLocationCount() {
1044 return location_.size();
1045 }
1046
1047
1048
1049 public io.netty.example.worldclock.WorldClockProtocol.Location getLocation(int index) {
1050 return location_.get(index);
1051 }
1052
1053
1054
1055 public io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder getLocationOrBuilder(
1056 int index) {
1057 return location_.get(index);
1058 }
1059
1060 private void initFields() {
1061 location_ = java.util.Collections.emptyList();
1062 }
1063 private byte memoizedIsInitialized = -1;
1064 public final boolean isInitialized() {
1065 byte isInitialized = memoizedIsInitialized;
1066 if (isInitialized != -1) return isInitialized == 1;
1067
1068 for (int i = 0; i < getLocationCount(); i++) {
1069 if (!getLocation(i).isInitialized()) {
1070 memoizedIsInitialized = 0;
1071 return false;
1072 }
1073 }
1074 memoizedIsInitialized = 1;
1075 return true;
1076 }
1077
1078 public void writeTo(com.google.protobuf.CodedOutputStream output)
1079 throws java.io.IOException {
1080 getSerializedSize();
1081 for (int i = 0; i < location_.size(); i++) {
1082 output.writeMessage(1, location_.get(i));
1083 }
1084 getUnknownFields().writeTo(output);
1085 }
1086
1087 private int memoizedSerializedSize = -1;
1088 public int getSerializedSize() {
1089 int size = memoizedSerializedSize;
1090 if (size != -1) return size;
1091
1092 size = 0;
1093 for (int i = 0; i < location_.size(); i++) {
1094 size += com.google.protobuf.CodedOutputStream
1095 .computeMessageSize(1, location_.get(i));
1096 }
1097 size += getUnknownFields().getSerializedSize();
1098 memoizedSerializedSize = size;
1099 return size;
1100 }
1101
1102 private static final long serialVersionUID = 0L;
1103 @java.lang.Override
1104 protected java.lang.Object writeReplace()
1105 throws java.io.ObjectStreamException {
1106 return super.writeReplace();
1107 }
1108
1109 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(
1110 com.google.protobuf.ByteString data)
1111 throws com.google.protobuf.InvalidProtocolBufferException {
1112 return PARSER.parseFrom(data);
1113 }
1114 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(
1115 com.google.protobuf.ByteString data,
1116 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1117 throws com.google.protobuf.InvalidProtocolBufferException {
1118 return PARSER.parseFrom(data, extensionRegistry);
1119 }
1120 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(byte[] data)
1121 throws com.google.protobuf.InvalidProtocolBufferException {
1122 return PARSER.parseFrom(data);
1123 }
1124 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(
1125 byte[] data,
1126 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1127 throws com.google.protobuf.InvalidProtocolBufferException {
1128 return PARSER.parseFrom(data, extensionRegistry);
1129 }
1130 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(java.io.InputStream input)
1131 throws java.io.IOException {
1132 return PARSER.parseFrom(input);
1133 }
1134 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(
1135 java.io.InputStream input,
1136 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1137 throws java.io.IOException {
1138 return PARSER.parseFrom(input, extensionRegistry);
1139 }
1140 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseDelimitedFrom(java.io.InputStream input)
1141 throws java.io.IOException {
1142 return PARSER.parseDelimitedFrom(input);
1143 }
1144 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseDelimitedFrom(
1145 java.io.InputStream input,
1146 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1147 throws java.io.IOException {
1148 return PARSER.parseDelimitedFrom(input, extensionRegistry);
1149 }
1150 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(
1151 com.google.protobuf.CodedInputStream input)
1152 throws java.io.IOException {
1153 return PARSER.parseFrom(input);
1154 }
1155 public static io.netty.example.worldclock.WorldClockProtocol.Locations parseFrom(
1156 com.google.protobuf.CodedInputStream input,
1157 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1158 throws java.io.IOException {
1159 return PARSER.parseFrom(input, extensionRegistry);
1160 }
1161
1162 public static Builder newBuilder() { return Builder.create(); }
1163 public Builder newBuilderForType() { return newBuilder(); }
1164 public static Builder newBuilder(io.netty.example.worldclock.WorldClockProtocol.Locations prototype) {
1165 return newBuilder().mergeFrom(prototype);
1166 }
1167 public Builder toBuilder() { return newBuilder(this); }
1168
1169 @java.lang.Override
1170 protected Builder newBuilderForType(
1171 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1172 Builder builder = new Builder(parent);
1173 return builder;
1174 }
1175
1176
1177
1178 public static final class Builder extends
1179 com.google.protobuf.GeneratedMessage.Builder<Builder>
1180 implements io.netty.example.worldclock.WorldClockProtocol.LocationsOrBuilder {
1181 public static final com.google.protobuf.Descriptors.Descriptor
1182 getDescriptor() {
1183 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Locations_descriptor;
1184 }
1185
1186 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1187 internalGetFieldAccessorTable() {
1188 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Locations_fieldAccessorTable
1189 .ensureFieldAccessorsInitialized(
1190 io.netty.example.worldclock.WorldClockProtocol.Locations.class, io.netty.example.worldclock.WorldClockProtocol.Locations.Builder.class);
1191 }
1192
1193
1194 private Builder() {
1195 maybeForceBuilderInitialization();
1196 }
1197
1198 private Builder(
1199 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1200 super(parent);
1201 maybeForceBuilderInitialization();
1202 }
1203 private void maybeForceBuilderInitialization() {
1204 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1205 getLocationFieldBuilder();
1206 }
1207 }
1208 private static Builder create() {
1209 return new Builder();
1210 }
1211
1212 public Builder clear() {
1213 super.clear();
1214 if (locationBuilder_ == null) {
1215 location_ = java.util.Collections.emptyList();
1216 bitField0_ = (bitField0_ & ~0x00000001);
1217 } else {
1218 locationBuilder_.clear();
1219 }
1220 return this;
1221 }
1222
1223 public Builder clone() {
1224 return create().mergeFrom(buildPartial());
1225 }
1226
1227 public com.google.protobuf.Descriptors.Descriptor
1228 getDescriptorForType() {
1229 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_Locations_descriptor;
1230 }
1231
1232 public io.netty.example.worldclock.WorldClockProtocol.Locations getDefaultInstanceForType() {
1233 return io.netty.example.worldclock.WorldClockProtocol.Locations.getDefaultInstance();
1234 }
1235
1236 public io.netty.example.worldclock.WorldClockProtocol.Locations build() {
1237 io.netty.example.worldclock.WorldClockProtocol.Locations result = buildPartial();
1238 if (!result.isInitialized()) {
1239 throw newUninitializedMessageException(result);
1240 }
1241 return result;
1242 }
1243
1244 public io.netty.example.worldclock.WorldClockProtocol.Locations buildPartial() {
1245 io.netty.example.worldclock.WorldClockProtocol.Locations result = new io.netty.example.worldclock.WorldClockProtocol.Locations(this);
1246 int from_bitField0_ = bitField0_;
1247 if (locationBuilder_ == null) {
1248 if (((bitField0_ & 0x00000001) == 0x00000001)) {
1249 location_ = java.util.Collections.unmodifiableList(location_);
1250 bitField0_ = (bitField0_ & ~0x00000001);
1251 }
1252 result.location_ = location_;
1253 } else {
1254 result.location_ = locationBuilder_.build();
1255 }
1256 onBuilt();
1257 return result;
1258 }
1259
1260 public Builder mergeFrom(com.google.protobuf.Message other) {
1261 if (other instanceof io.netty.example.worldclock.WorldClockProtocol.Locations) {
1262 return mergeFrom((io.netty.example.worldclock.WorldClockProtocol.Locations)other);
1263 } else {
1264 super.mergeFrom(other);
1265 return this;
1266 }
1267 }
1268
1269 public Builder mergeFrom(io.netty.example.worldclock.WorldClockProtocol.Locations other) {
1270 if (other == io.netty.example.worldclock.WorldClockProtocol.Locations.getDefaultInstance()) return this;
1271 if (locationBuilder_ == null) {
1272 if (!other.location_.isEmpty()) {
1273 if (location_.isEmpty()) {
1274 location_ = other.location_;
1275 bitField0_ = (bitField0_ & ~0x00000001);
1276 } else {
1277 ensureLocationIsMutable();
1278 location_.addAll(other.location_);
1279 }
1280 onChanged();
1281 }
1282 } else {
1283 if (!other.location_.isEmpty()) {
1284 if (locationBuilder_.isEmpty()) {
1285 locationBuilder_.dispose();
1286 locationBuilder_ = null;
1287 location_ = other.location_;
1288 bitField0_ = (bitField0_ & ~0x00000001);
1289 locationBuilder_ =
1290 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
1291 getLocationFieldBuilder() : null;
1292 } else {
1293 locationBuilder_.addAllMessages(other.location_);
1294 }
1295 }
1296 }
1297 this.mergeUnknownFields(other.getUnknownFields());
1298 return this;
1299 }
1300
1301 public final boolean isInitialized() {
1302 for (int i = 0; i < getLocationCount(); i++) {
1303 if (!getLocation(i).isInitialized()) {
1304
1305 return false;
1306 }
1307 }
1308 return true;
1309 }
1310
1311 public Builder mergeFrom(
1312 com.google.protobuf.CodedInputStream input,
1313 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1314 throws java.io.IOException {
1315 io.netty.example.worldclock.WorldClockProtocol.Locations parsedMessage = null;
1316 try {
1317 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1318 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1319 parsedMessage = (io.netty.example.worldclock.WorldClockProtocol.Locations) e.getUnfinishedMessage();
1320 throw e;
1321 } finally {
1322 if (parsedMessage != null) {
1323 mergeFrom(parsedMessage);
1324 }
1325 }
1326 return this;
1327 }
1328 private int bitField0_;
1329
1330
1331 private java.util.List<io.netty.example.worldclock.WorldClockProtocol.Location> location_ =
1332 java.util.Collections.emptyList();
1333 private void ensureLocationIsMutable() {
1334 if (!((bitField0_ & 0x00000001) == 0x00000001)) {
1335 location_ = new java.util.ArrayList<io.netty.example.worldclock.WorldClockProtocol.Location>(location_);
1336 bitField0_ |= 0x00000001;
1337 }
1338 }
1339
1340 private com.google.protobuf.RepeatedFieldBuilder<
1341 io.netty.example.worldclock.WorldClockProtocol.Location, io.netty.example.worldclock.WorldClockProtocol.Location.Builder, io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder> locationBuilder_;
1342
1343
1344
1345
1346 public java.util.List<io.netty.example.worldclock.WorldClockProtocol.Location> getLocationList() {
1347 if (locationBuilder_ == null) {
1348 return java.util.Collections.unmodifiableList(location_);
1349 } else {
1350 return locationBuilder_.getMessageList();
1351 }
1352 }
1353
1354
1355
1356 public int getLocationCount() {
1357 if (locationBuilder_ == null) {
1358 return location_.size();
1359 } else {
1360 return locationBuilder_.getCount();
1361 }
1362 }
1363
1364
1365
1366 public io.netty.example.worldclock.WorldClockProtocol.Location getLocation(int index) {
1367 if (locationBuilder_ == null) {
1368 return location_.get(index);
1369 } else {
1370 return locationBuilder_.getMessage(index);
1371 }
1372 }
1373
1374
1375
1376 public Builder setLocation(
1377 int index, io.netty.example.worldclock.WorldClockProtocol.Location value) {
1378 if (locationBuilder_ == null) {
1379 if (value == null) {
1380 throw new NullPointerException();
1381 }
1382 ensureLocationIsMutable();
1383 location_.set(index, value);
1384 onChanged();
1385 } else {
1386 locationBuilder_.setMessage(index, value);
1387 }
1388 return this;
1389 }
1390
1391
1392
1393 public Builder setLocation(
1394 int index, io.netty.example.worldclock.WorldClockProtocol.Location.Builder builderForValue) {
1395 if (locationBuilder_ == null) {
1396 ensureLocationIsMutable();
1397 location_.set(index, builderForValue.build());
1398 onChanged();
1399 } else {
1400 locationBuilder_.setMessage(index, builderForValue.build());
1401 }
1402 return this;
1403 }
1404
1405
1406
1407 public Builder addLocation(io.netty.example.worldclock.WorldClockProtocol.Location value) {
1408 if (locationBuilder_ == null) {
1409 if (value == null) {
1410 throw new NullPointerException();
1411 }
1412 ensureLocationIsMutable();
1413 location_.add(value);
1414 onChanged();
1415 } else {
1416 locationBuilder_.addMessage(value);
1417 }
1418 return this;
1419 }
1420
1421
1422
1423 public Builder addLocation(
1424 int index, io.netty.example.worldclock.WorldClockProtocol.Location value) {
1425 if (locationBuilder_ == null) {
1426 if (value == null) {
1427 throw new NullPointerException();
1428 }
1429 ensureLocationIsMutable();
1430 location_.add(index, value);
1431 onChanged();
1432 } else {
1433 locationBuilder_.addMessage(index, value);
1434 }
1435 return this;
1436 }
1437
1438
1439
1440 public Builder addLocation(
1441 io.netty.example.worldclock.WorldClockProtocol.Location.Builder builderForValue) {
1442 if (locationBuilder_ == null) {
1443 ensureLocationIsMutable();
1444 location_.add(builderForValue.build());
1445 onChanged();
1446 } else {
1447 locationBuilder_.addMessage(builderForValue.build());
1448 }
1449 return this;
1450 }
1451
1452
1453
1454 public Builder addLocation(
1455 int index, io.netty.example.worldclock.WorldClockProtocol.Location.Builder builderForValue) {
1456 if (locationBuilder_ == null) {
1457 ensureLocationIsMutable();
1458 location_.add(index, builderForValue.build());
1459 onChanged();
1460 } else {
1461 locationBuilder_.addMessage(index, builderForValue.build());
1462 }
1463 return this;
1464 }
1465
1466
1467
1468 public Builder addAllLocation(
1469 java.lang.Iterable<? extends io.netty.example.worldclock.WorldClockProtocol.Location> values) {
1470 if (locationBuilder_ == null) {
1471 ensureLocationIsMutable();
1472 super.addAll(values, location_);
1473 onChanged();
1474 } else {
1475 locationBuilder_.addAllMessages(values);
1476 }
1477 return this;
1478 }
1479
1480
1481
1482 public Builder clearLocation() {
1483 if (locationBuilder_ == null) {
1484 location_ = java.util.Collections.emptyList();
1485 bitField0_ = (bitField0_ & ~0x00000001);
1486 onChanged();
1487 } else {
1488 locationBuilder_.clear();
1489 }
1490 return this;
1491 }
1492
1493
1494
1495 public Builder removeLocation(int index) {
1496 if (locationBuilder_ == null) {
1497 ensureLocationIsMutable();
1498 location_.remove(index);
1499 onChanged();
1500 } else {
1501 locationBuilder_.remove(index);
1502 }
1503 return this;
1504 }
1505
1506
1507
1508 public io.netty.example.worldclock.WorldClockProtocol.Location.Builder getLocationBuilder(
1509 int index) {
1510 return getLocationFieldBuilder().getBuilder(index);
1511 }
1512
1513
1514
1515 public io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder getLocationOrBuilder(
1516 int index) {
1517 if (locationBuilder_ == null) {
1518 return location_.get(index); } else {
1519 return locationBuilder_.getMessageOrBuilder(index);
1520 }
1521 }
1522
1523
1524
1525 public java.util.List<? extends io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder>
1526 getLocationOrBuilderList() {
1527 if (locationBuilder_ != null) {
1528 return locationBuilder_.getMessageOrBuilderList();
1529 } else {
1530 return java.util.Collections.unmodifiableList(location_);
1531 }
1532 }
1533
1534
1535
1536 public io.netty.example.worldclock.WorldClockProtocol.Location.Builder addLocationBuilder() {
1537 return getLocationFieldBuilder().addBuilder(
1538 io.netty.example.worldclock.WorldClockProtocol.Location.getDefaultInstance());
1539 }
1540
1541
1542
1543 public io.netty.example.worldclock.WorldClockProtocol.Location.Builder addLocationBuilder(
1544 int index) {
1545 return getLocationFieldBuilder().addBuilder(
1546 index, io.netty.example.worldclock.WorldClockProtocol.Location.getDefaultInstance());
1547 }
1548
1549
1550
1551 public java.util.List<io.netty.example.worldclock.WorldClockProtocol.Location.Builder>
1552 getLocationBuilderList() {
1553 return getLocationFieldBuilder().getBuilderList();
1554 }
1555 private com.google.protobuf.RepeatedFieldBuilder<
1556 io.netty.example.worldclock.WorldClockProtocol.Location, io.netty.example.worldclock.WorldClockProtocol.Location.Builder, io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder>
1557 getLocationFieldBuilder() {
1558 if (locationBuilder_ == null) {
1559 locationBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
1560 io.netty.example.worldclock.WorldClockProtocol.Location, io.netty.example.worldclock.WorldClockProtocol.Location.Builder, io.netty.example.worldclock.WorldClockProtocol.LocationOrBuilder>(
1561 location_,
1562 ((bitField0_ & 0x00000001) == 0x00000001),
1563 getParentForChildren(),
1564 isClean());
1565 location_ = null;
1566 }
1567 return locationBuilder_;
1568 }
1569
1570
1571 }
1572
1573 static {
1574 defaultInstance = new Locations(true);
1575 defaultInstance.initFields();
1576 }
1577
1578
1579 }
1580
1581 public interface LocalTimeOrBuilder
1582 extends com.google.protobuf.MessageOrBuilder {
1583
1584
1585
1586
1587
1588 boolean hasYear();
1589
1590
1591
1592 int getYear();
1593
1594
1595
1596
1597
1598 boolean hasMonth();
1599
1600
1601
1602 int getMonth();
1603
1604
1605
1606
1607
1608 boolean hasDayOfMonth();
1609
1610
1611
1612 int getDayOfMonth();
1613
1614
1615
1616
1617
1618 boolean hasDayOfWeek();
1619
1620
1621
1622 io.netty.example.worldclock.WorldClockProtocol.DayOfWeek getDayOfWeek();
1623
1624
1625
1626
1627
1628 boolean hasHour();
1629
1630
1631
1632 int getHour();
1633
1634
1635
1636
1637
1638 boolean hasMinute();
1639
1640
1641
1642 int getMinute();
1643
1644
1645
1646
1647
1648 boolean hasSecond();
1649
1650
1651
1652 int getSecond();
1653 }
1654
1655
1656
1657 public static final class LocalTime extends
1658 com.google.protobuf.GeneratedMessage
1659 implements LocalTimeOrBuilder {
1660
1661 private LocalTime(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1662 super(builder);
1663 this.unknownFields = builder.getUnknownFields();
1664 }
1665 private LocalTime(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1666
1667 private static final LocalTime defaultInstance;
1668 public static LocalTime getDefaultInstance() {
1669 return defaultInstance;
1670 }
1671
1672 public LocalTime getDefaultInstanceForType() {
1673 return defaultInstance;
1674 }
1675
1676 private final com.google.protobuf.UnknownFieldSet unknownFields;
1677 @java.lang.Override
1678 public final com.google.protobuf.UnknownFieldSet
1679 getUnknownFields() {
1680 return this.unknownFields;
1681 }
1682 private LocalTime(
1683 com.google.protobuf.CodedInputStream input,
1684 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1685 throws com.google.protobuf.InvalidProtocolBufferException {
1686 initFields();
1687 int mutable_bitField0_ = 0;
1688 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1689 com.google.protobuf.UnknownFieldSet.newBuilder();
1690 try {
1691 boolean done = false;
1692 while (!done) {
1693 int tag = input.readTag();
1694 switch (tag) {
1695 case 0:
1696 done = true;
1697 break;
1698 default: {
1699 if (!parseUnknownField(input, unknownFields,
1700 extensionRegistry, tag)) {
1701 done = true;
1702 }
1703 break;
1704 }
1705 case 8: {
1706 bitField0_ |= 0x00000001;
1707 year_ = input.readUInt32();
1708 break;
1709 }
1710 case 16: {
1711 bitField0_ |= 0x00000002;
1712 month_ = input.readUInt32();
1713 break;
1714 }
1715 case 32: {
1716 bitField0_ |= 0x00000004;
1717 dayOfMonth_ = input.readUInt32();
1718 break;
1719 }
1720 case 40: {
1721 int rawValue = input.readEnum();
1722 io.netty.example.worldclock.WorldClockProtocol.DayOfWeek value = io.netty.example.worldclock.WorldClockProtocol.DayOfWeek.valueOf(rawValue);
1723 if (value == null) {
1724 unknownFields.mergeVarintField(5, rawValue);
1725 } else {
1726 bitField0_ |= 0x00000008;
1727 dayOfWeek_ = value;
1728 }
1729 break;
1730 }
1731 case 48: {
1732 bitField0_ |= 0x00000010;
1733 hour_ = input.readUInt32();
1734 break;
1735 }
1736 case 56: {
1737 bitField0_ |= 0x00000020;
1738 minute_ = input.readUInt32();
1739 break;
1740 }
1741 case 64: {
1742 bitField0_ |= 0x00000040;
1743 second_ = input.readUInt32();
1744 break;
1745 }
1746 }
1747 }
1748 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1749 throw e.setUnfinishedMessage(this);
1750 } catch (java.io.IOException e) {
1751 throw new com.google.protobuf.InvalidProtocolBufferException(
1752 e.getMessage()).setUnfinishedMessage(this);
1753 } finally {
1754 this.unknownFields = unknownFields.build();
1755 makeExtensionsImmutable();
1756 }
1757 }
1758 public static final com.google.protobuf.Descriptors.Descriptor
1759 getDescriptor() {
1760 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTime_descriptor;
1761 }
1762
1763 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1764 internalGetFieldAccessorTable() {
1765 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTime_fieldAccessorTable
1766 .ensureFieldAccessorsInitialized(
1767 io.netty.example.worldclock.WorldClockProtocol.LocalTime.class, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder.class);
1768 }
1769
1770 public static com.google.protobuf.Parser<LocalTime> PARSER =
1771 new com.google.protobuf.AbstractParser<LocalTime>() {
1772 public LocalTime parsePartialFrom(
1773 com.google.protobuf.CodedInputStream input,
1774 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1775 throws com.google.protobuf.InvalidProtocolBufferException {
1776 return new LocalTime(input, extensionRegistry);
1777 }
1778 };
1779
1780 @java.lang.Override
1781 public com.google.protobuf.Parser<LocalTime> getParserForType() {
1782 return PARSER;
1783 }
1784
1785 private int bitField0_;
1786
1787 public static final int YEAR_FIELD_NUMBER = 1;
1788 private int year_;
1789
1790
1791
1792 public boolean hasYear() {
1793 return ((bitField0_ & 0x00000001) == 0x00000001);
1794 }
1795
1796
1797
1798 public int getYear() {
1799 return year_;
1800 }
1801
1802
1803 public static final int MONTH_FIELD_NUMBER = 2;
1804 private int month_;
1805
1806
1807
1808 public boolean hasMonth() {
1809 return ((bitField0_ & 0x00000002) == 0x00000002);
1810 }
1811
1812
1813
1814 public int getMonth() {
1815 return month_;
1816 }
1817
1818
1819 public static final int DAYOFMONTH_FIELD_NUMBER = 4;
1820 private int dayOfMonth_;
1821
1822
1823
1824 public boolean hasDayOfMonth() {
1825 return ((bitField0_ & 0x00000004) == 0x00000004);
1826 }
1827
1828
1829
1830 public int getDayOfMonth() {
1831 return dayOfMonth_;
1832 }
1833
1834
1835 public static final int DAYOFWEEK_FIELD_NUMBER = 5;
1836 private io.netty.example.worldclock.WorldClockProtocol.DayOfWeek dayOfWeek_;
1837
1838
1839
1840 public boolean hasDayOfWeek() {
1841 return ((bitField0_ & 0x00000008) == 0x00000008);
1842 }
1843
1844
1845
1846 public io.netty.example.worldclock.WorldClockProtocol.DayOfWeek getDayOfWeek() {
1847 return dayOfWeek_;
1848 }
1849
1850
1851 public static final int HOUR_FIELD_NUMBER = 6;
1852 private int hour_;
1853
1854
1855
1856 public boolean hasHour() {
1857 return ((bitField0_ & 0x00000010) == 0x00000010);
1858 }
1859
1860
1861
1862 public int getHour() {
1863 return hour_;
1864 }
1865
1866
1867 public static final int MINUTE_FIELD_NUMBER = 7;
1868 private int minute_;
1869
1870
1871
1872 public boolean hasMinute() {
1873 return ((bitField0_ & 0x00000020) == 0x00000020);
1874 }
1875
1876
1877
1878 public int getMinute() {
1879 return minute_;
1880 }
1881
1882
1883 public static final int SECOND_FIELD_NUMBER = 8;
1884 private int second_;
1885
1886
1887
1888 public boolean hasSecond() {
1889 return ((bitField0_ & 0x00000040) == 0x00000040);
1890 }
1891
1892
1893
1894 public int getSecond() {
1895 return second_;
1896 }
1897
1898 private void initFields() {
1899 year_ = 0;
1900 month_ = 0;
1901 dayOfMonth_ = 0;
1902 dayOfWeek_ = io.netty.example.worldclock.WorldClockProtocol.DayOfWeek.SUNDAY;
1903 hour_ = 0;
1904 minute_ = 0;
1905 second_ = 0;
1906 }
1907 private byte memoizedIsInitialized = -1;
1908 public final boolean isInitialized() {
1909 byte isInitialized = memoizedIsInitialized;
1910 if (isInitialized != -1) return isInitialized == 1;
1911
1912 if (!hasYear()) {
1913 memoizedIsInitialized = 0;
1914 return false;
1915 }
1916 if (!hasMonth()) {
1917 memoizedIsInitialized = 0;
1918 return false;
1919 }
1920 if (!hasDayOfMonth()) {
1921 memoizedIsInitialized = 0;
1922 return false;
1923 }
1924 if (!hasDayOfWeek()) {
1925 memoizedIsInitialized = 0;
1926 return false;
1927 }
1928 if (!hasHour()) {
1929 memoizedIsInitialized = 0;
1930 return false;
1931 }
1932 if (!hasMinute()) {
1933 memoizedIsInitialized = 0;
1934 return false;
1935 }
1936 if (!hasSecond()) {
1937 memoizedIsInitialized = 0;
1938 return false;
1939 }
1940 memoizedIsInitialized = 1;
1941 return true;
1942 }
1943
1944 public void writeTo(com.google.protobuf.CodedOutputStream output)
1945 throws java.io.IOException {
1946 getSerializedSize();
1947 if (((bitField0_ & 0x00000001) == 0x00000001)) {
1948 output.writeUInt32(1, year_);
1949 }
1950 if (((bitField0_ & 0x00000002) == 0x00000002)) {
1951 output.writeUInt32(2, month_);
1952 }
1953 if (((bitField0_ & 0x00000004) == 0x00000004)) {
1954 output.writeUInt32(4, dayOfMonth_);
1955 }
1956 if (((bitField0_ & 0x00000008) == 0x00000008)) {
1957 output.writeEnum(5, dayOfWeek_.getNumber());
1958 }
1959 if (((bitField0_ & 0x00000010) == 0x00000010)) {
1960 output.writeUInt32(6, hour_);
1961 }
1962 if (((bitField0_ & 0x00000020) == 0x00000020)) {
1963 output.writeUInt32(7, minute_);
1964 }
1965 if (((bitField0_ & 0x00000040) == 0x00000040)) {
1966 output.writeUInt32(8, second_);
1967 }
1968 getUnknownFields().writeTo(output);
1969 }
1970
1971 private int memoizedSerializedSize = -1;
1972 public int getSerializedSize() {
1973 int size = memoizedSerializedSize;
1974 if (size != -1) return size;
1975
1976 size = 0;
1977 if (((bitField0_ & 0x00000001) == 0x00000001)) {
1978 size += com.google.protobuf.CodedOutputStream
1979 .computeUInt32Size(1, year_);
1980 }
1981 if (((bitField0_ & 0x00000002) == 0x00000002)) {
1982 size += com.google.protobuf.CodedOutputStream
1983 .computeUInt32Size(2, month_);
1984 }
1985 if (((bitField0_ & 0x00000004) == 0x00000004)) {
1986 size += com.google.protobuf.CodedOutputStream
1987 .computeUInt32Size(4, dayOfMonth_);
1988 }
1989 if (((bitField0_ & 0x00000008) == 0x00000008)) {
1990 size += com.google.protobuf.CodedOutputStream
1991 .computeEnumSize(5, dayOfWeek_.getNumber());
1992 }
1993 if (((bitField0_ & 0x00000010) == 0x00000010)) {
1994 size += com.google.protobuf.CodedOutputStream
1995 .computeUInt32Size(6, hour_);
1996 }
1997 if (((bitField0_ & 0x00000020) == 0x00000020)) {
1998 size += com.google.protobuf.CodedOutputStream
1999 .computeUInt32Size(7, minute_);
2000 }
2001 if (((bitField0_ & 0x00000040) == 0x00000040)) {
2002 size += com.google.protobuf.CodedOutputStream
2003 .computeUInt32Size(8, second_);
2004 }
2005 size += getUnknownFields().getSerializedSize();
2006 memoizedSerializedSize = size;
2007 return size;
2008 }
2009
2010 private static final long serialVersionUID = 0L;
2011 @java.lang.Override
2012 protected java.lang.Object writeReplace()
2013 throws java.io.ObjectStreamException {
2014 return super.writeReplace();
2015 }
2016
2017 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(
2018 com.google.protobuf.ByteString data)
2019 throws com.google.protobuf.InvalidProtocolBufferException {
2020 return PARSER.parseFrom(data);
2021 }
2022 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(
2023 com.google.protobuf.ByteString data,
2024 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2025 throws com.google.protobuf.InvalidProtocolBufferException {
2026 return PARSER.parseFrom(data, extensionRegistry);
2027 }
2028 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(byte[] data)
2029 throws com.google.protobuf.InvalidProtocolBufferException {
2030 return PARSER.parseFrom(data);
2031 }
2032 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(
2033 byte[] data,
2034 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2035 throws com.google.protobuf.InvalidProtocolBufferException {
2036 return PARSER.parseFrom(data, extensionRegistry);
2037 }
2038 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(java.io.InputStream input)
2039 throws java.io.IOException {
2040 return PARSER.parseFrom(input);
2041 }
2042 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(
2043 java.io.InputStream input,
2044 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2045 throws java.io.IOException {
2046 return PARSER.parseFrom(input, extensionRegistry);
2047 }
2048 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseDelimitedFrom(java.io.InputStream input)
2049 throws java.io.IOException {
2050 return PARSER.parseDelimitedFrom(input);
2051 }
2052 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseDelimitedFrom(
2053 java.io.InputStream input,
2054 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2055 throws java.io.IOException {
2056 return PARSER.parseDelimitedFrom(input, extensionRegistry);
2057 }
2058 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(
2059 com.google.protobuf.CodedInputStream input)
2060 throws java.io.IOException {
2061 return PARSER.parseFrom(input);
2062 }
2063 public static io.netty.example.worldclock.WorldClockProtocol.LocalTime parseFrom(
2064 com.google.protobuf.CodedInputStream input,
2065 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2066 throws java.io.IOException {
2067 return PARSER.parseFrom(input, extensionRegistry);
2068 }
2069
2070 public static Builder newBuilder() { return Builder.create(); }
2071 public Builder newBuilderForType() { return newBuilder(); }
2072 public static Builder newBuilder(io.netty.example.worldclock.WorldClockProtocol.LocalTime prototype) {
2073 return newBuilder().mergeFrom(prototype);
2074 }
2075 public Builder toBuilder() { return newBuilder(this); }
2076
2077 @java.lang.Override
2078 protected Builder newBuilderForType(
2079 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2080 Builder builder = new Builder(parent);
2081 return builder;
2082 }
2083
2084
2085
2086 public static final class Builder extends
2087 com.google.protobuf.GeneratedMessage.Builder<Builder>
2088 implements io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder {
2089 public static final com.google.protobuf.Descriptors.Descriptor
2090 getDescriptor() {
2091 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTime_descriptor;
2092 }
2093
2094 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2095 internalGetFieldAccessorTable() {
2096 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTime_fieldAccessorTable
2097 .ensureFieldAccessorsInitialized(
2098 io.netty.example.worldclock.WorldClockProtocol.LocalTime.class, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder.class);
2099 }
2100
2101
2102 private Builder() {
2103 maybeForceBuilderInitialization();
2104 }
2105
2106 private Builder(
2107 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2108 super(parent);
2109 maybeForceBuilderInitialization();
2110 }
2111 private void maybeForceBuilderInitialization() {
2112 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2113 }
2114 }
2115 private static Builder create() {
2116 return new Builder();
2117 }
2118
2119 public Builder clear() {
2120 super.clear();
2121 year_ = 0;
2122 bitField0_ = (bitField0_ & ~0x00000001);
2123 month_ = 0;
2124 bitField0_ = (bitField0_ & ~0x00000002);
2125 dayOfMonth_ = 0;
2126 bitField0_ = (bitField0_ & ~0x00000004);
2127 dayOfWeek_ = io.netty.example.worldclock.WorldClockProtocol.DayOfWeek.SUNDAY;
2128 bitField0_ = (bitField0_ & ~0x00000008);
2129 hour_ = 0;
2130 bitField0_ = (bitField0_ & ~0x00000010);
2131 minute_ = 0;
2132 bitField0_ = (bitField0_ & ~0x00000020);
2133 second_ = 0;
2134 bitField0_ = (bitField0_ & ~0x00000040);
2135 return this;
2136 }
2137
2138 public Builder clone() {
2139 return create().mergeFrom(buildPartial());
2140 }
2141
2142 public com.google.protobuf.Descriptors.Descriptor
2143 getDescriptorForType() {
2144 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTime_descriptor;
2145 }
2146
2147 public io.netty.example.worldclock.WorldClockProtocol.LocalTime getDefaultInstanceForType() {
2148 return io.netty.example.worldclock.WorldClockProtocol.LocalTime.getDefaultInstance();
2149 }
2150
2151 public io.netty.example.worldclock.WorldClockProtocol.LocalTime build() {
2152 io.netty.example.worldclock.WorldClockProtocol.LocalTime result = buildPartial();
2153 if (!result.isInitialized()) {
2154 throw newUninitializedMessageException(result);
2155 }
2156 return result;
2157 }
2158
2159 public io.netty.example.worldclock.WorldClockProtocol.LocalTime buildPartial() {
2160 io.netty.example.worldclock.WorldClockProtocol.LocalTime result = new io.netty.example.worldclock.WorldClockProtocol.LocalTime(this);
2161 int from_bitField0_ = bitField0_;
2162 int to_bitField0_ = 0;
2163 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2164 to_bitField0_ |= 0x00000001;
2165 }
2166 result.year_ = year_;
2167 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2168 to_bitField0_ |= 0x00000002;
2169 }
2170 result.month_ = month_;
2171 if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2172 to_bitField0_ |= 0x00000004;
2173 }
2174 result.dayOfMonth_ = dayOfMonth_;
2175 if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2176 to_bitField0_ |= 0x00000008;
2177 }
2178 result.dayOfWeek_ = dayOfWeek_;
2179 if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2180 to_bitField0_ |= 0x00000010;
2181 }
2182 result.hour_ = hour_;
2183 if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2184 to_bitField0_ |= 0x00000020;
2185 }
2186 result.minute_ = minute_;
2187 if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2188 to_bitField0_ |= 0x00000040;
2189 }
2190 result.second_ = second_;
2191 result.bitField0_ = to_bitField0_;
2192 onBuilt();
2193 return result;
2194 }
2195
2196 public Builder mergeFrom(com.google.protobuf.Message other) {
2197 if (other instanceof io.netty.example.worldclock.WorldClockProtocol.LocalTime) {
2198 return mergeFrom((io.netty.example.worldclock.WorldClockProtocol.LocalTime)other);
2199 } else {
2200 super.mergeFrom(other);
2201 return this;
2202 }
2203 }
2204
2205 public Builder mergeFrom(io.netty.example.worldclock.WorldClockProtocol.LocalTime other) {
2206 if (other == io.netty.example.worldclock.WorldClockProtocol.LocalTime.getDefaultInstance()) return this;
2207 if (other.hasYear()) {
2208 setYear(other.getYear());
2209 }
2210 if (other.hasMonth()) {
2211 setMonth(other.getMonth());
2212 }
2213 if (other.hasDayOfMonth()) {
2214 setDayOfMonth(other.getDayOfMonth());
2215 }
2216 if (other.hasDayOfWeek()) {
2217 setDayOfWeek(other.getDayOfWeek());
2218 }
2219 if (other.hasHour()) {
2220 setHour(other.getHour());
2221 }
2222 if (other.hasMinute()) {
2223 setMinute(other.getMinute());
2224 }
2225 if (other.hasSecond()) {
2226 setSecond(other.getSecond());
2227 }
2228 this.mergeUnknownFields(other.getUnknownFields());
2229 return this;
2230 }
2231
2232 public final boolean isInitialized() {
2233 if (!hasYear()) {
2234
2235 return false;
2236 }
2237 if (!hasMonth()) {
2238
2239 return false;
2240 }
2241 if (!hasDayOfMonth()) {
2242
2243 return false;
2244 }
2245 if (!hasDayOfWeek()) {
2246
2247 return false;
2248 }
2249 if (!hasHour()) {
2250
2251 return false;
2252 }
2253 if (!hasMinute()) {
2254
2255 return false;
2256 }
2257 if (!hasSecond()) {
2258
2259 return false;
2260 }
2261 return true;
2262 }
2263
2264 public Builder mergeFrom(
2265 com.google.protobuf.CodedInputStream input,
2266 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2267 throws java.io.IOException {
2268 io.netty.example.worldclock.WorldClockProtocol.LocalTime parsedMessage = null;
2269 try {
2270 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2271 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2272 parsedMessage = (io.netty.example.worldclock.WorldClockProtocol.LocalTime) e.getUnfinishedMessage();
2273 throw e;
2274 } finally {
2275 if (parsedMessage != null) {
2276 mergeFrom(parsedMessage);
2277 }
2278 }
2279 return this;
2280 }
2281 private int bitField0_;
2282
2283
2284 private int year_ ;
2285
2286
2287
2288 public boolean hasYear() {
2289 return ((bitField0_ & 0x00000001) == 0x00000001);
2290 }
2291
2292
2293
2294 public int getYear() {
2295 return year_;
2296 }
2297
2298
2299
2300 public Builder setYear(int value) {
2301 bitField0_ |= 0x00000001;
2302 year_ = value;
2303 onChanged();
2304 return this;
2305 }
2306
2307
2308
2309 public Builder clearYear() {
2310 bitField0_ = (bitField0_ & ~0x00000001);
2311 year_ = 0;
2312 onChanged();
2313 return this;
2314 }
2315
2316
2317 private int month_ ;
2318
2319
2320
2321 public boolean hasMonth() {
2322 return ((bitField0_ & 0x00000002) == 0x00000002);
2323 }
2324
2325
2326
2327 public int getMonth() {
2328 return month_;
2329 }
2330
2331
2332
2333 public Builder setMonth(int value) {
2334 bitField0_ |= 0x00000002;
2335 month_ = value;
2336 onChanged();
2337 return this;
2338 }
2339
2340
2341
2342 public Builder clearMonth() {
2343 bitField0_ = (bitField0_ & ~0x00000002);
2344 month_ = 0;
2345 onChanged();
2346 return this;
2347 }
2348
2349
2350 private int dayOfMonth_ ;
2351
2352
2353
2354 public boolean hasDayOfMonth() {
2355 return ((bitField0_ & 0x00000004) == 0x00000004);
2356 }
2357
2358
2359
2360 public int getDayOfMonth() {
2361 return dayOfMonth_;
2362 }
2363
2364
2365
2366 public Builder setDayOfMonth(int value) {
2367 bitField0_ |= 0x00000004;
2368 dayOfMonth_ = value;
2369 onChanged();
2370 return this;
2371 }
2372
2373
2374
2375 public Builder clearDayOfMonth() {
2376 bitField0_ = (bitField0_ & ~0x00000004);
2377 dayOfMonth_ = 0;
2378 onChanged();
2379 return this;
2380 }
2381
2382
2383 private io.netty.example.worldclock.WorldClockProtocol.DayOfWeek dayOfWeek_ = io.netty.example.worldclock.WorldClockProtocol.DayOfWeek.SUNDAY;
2384
2385
2386
2387 public boolean hasDayOfWeek() {
2388 return ((bitField0_ & 0x00000008) == 0x00000008);
2389 }
2390
2391
2392
2393 public io.netty.example.worldclock.WorldClockProtocol.DayOfWeek getDayOfWeek() {
2394 return dayOfWeek_;
2395 }
2396
2397
2398
2399 public Builder setDayOfWeek(io.netty.example.worldclock.WorldClockProtocol.DayOfWeek value) {
2400 if (value == null) {
2401 throw new NullPointerException();
2402 }
2403 bitField0_ |= 0x00000008;
2404 dayOfWeek_ = value;
2405 onChanged();
2406 return this;
2407 }
2408
2409
2410
2411 public Builder clearDayOfWeek() {
2412 bitField0_ = (bitField0_ & ~0x00000008);
2413 dayOfWeek_ = io.netty.example.worldclock.WorldClockProtocol.DayOfWeek.SUNDAY;
2414 onChanged();
2415 return this;
2416 }
2417
2418
2419 private int hour_ ;
2420
2421
2422
2423 public boolean hasHour() {
2424 return ((bitField0_ & 0x00000010) == 0x00000010);
2425 }
2426
2427
2428
2429 public int getHour() {
2430 return hour_;
2431 }
2432
2433
2434
2435 public Builder setHour(int value) {
2436 bitField0_ |= 0x00000010;
2437 hour_ = value;
2438 onChanged();
2439 return this;
2440 }
2441
2442
2443
2444 public Builder clearHour() {
2445 bitField0_ = (bitField0_ & ~0x00000010);
2446 hour_ = 0;
2447 onChanged();
2448 return this;
2449 }
2450
2451
2452 private int minute_ ;
2453
2454
2455
2456 public boolean hasMinute() {
2457 return ((bitField0_ & 0x00000020) == 0x00000020);
2458 }
2459
2460
2461
2462 public int getMinute() {
2463 return minute_;
2464 }
2465
2466
2467
2468 public Builder setMinute(int value) {
2469 bitField0_ |= 0x00000020;
2470 minute_ = value;
2471 onChanged();
2472 return this;
2473 }
2474
2475
2476
2477 public Builder clearMinute() {
2478 bitField0_ = (bitField0_ & ~0x00000020);
2479 minute_ = 0;
2480 onChanged();
2481 return this;
2482 }
2483
2484
2485 private int second_ ;
2486
2487
2488
2489 public boolean hasSecond() {
2490 return ((bitField0_ & 0x00000040) == 0x00000040);
2491 }
2492
2493
2494
2495 public int getSecond() {
2496 return second_;
2497 }
2498
2499
2500
2501 public Builder setSecond(int value) {
2502 bitField0_ |= 0x00000040;
2503 second_ = value;
2504 onChanged();
2505 return this;
2506 }
2507
2508
2509
2510 public Builder clearSecond() {
2511 bitField0_ = (bitField0_ & ~0x00000040);
2512 second_ = 0;
2513 onChanged();
2514 return this;
2515 }
2516
2517
2518 }
2519
2520 static {
2521 defaultInstance = new LocalTime(true);
2522 defaultInstance.initFields();
2523 }
2524
2525
2526 }
2527
2528 public interface LocalTimesOrBuilder
2529 extends com.google.protobuf.MessageOrBuilder {
2530
2531
2532
2533
2534
2535 java.util.List<io.netty.example.worldclock.WorldClockProtocol.LocalTime>
2536 getLocalTimeList();
2537
2538
2539
2540 io.netty.example.worldclock.WorldClockProtocol.LocalTime getLocalTime(int index);
2541
2542
2543
2544 int getLocalTimeCount();
2545
2546
2547
2548 java.util.List<? extends io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder>
2549 getLocalTimeOrBuilderList();
2550
2551
2552
2553 io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder getLocalTimeOrBuilder(
2554 int index);
2555 }
2556
2557
2558
2559 public static final class LocalTimes extends
2560 com.google.protobuf.GeneratedMessage
2561 implements LocalTimesOrBuilder {
2562
2563 private LocalTimes(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2564 super(builder);
2565 this.unknownFields = builder.getUnknownFields();
2566 }
2567 private LocalTimes(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2568
2569 private static final LocalTimes defaultInstance;
2570 public static LocalTimes getDefaultInstance() {
2571 return defaultInstance;
2572 }
2573
2574 public LocalTimes getDefaultInstanceForType() {
2575 return defaultInstance;
2576 }
2577
2578 private final com.google.protobuf.UnknownFieldSet unknownFields;
2579 @java.lang.Override
2580 public final com.google.protobuf.UnknownFieldSet
2581 getUnknownFields() {
2582 return this.unknownFields;
2583 }
2584 private LocalTimes(
2585 com.google.protobuf.CodedInputStream input,
2586 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2587 throws com.google.protobuf.InvalidProtocolBufferException {
2588 initFields();
2589 int mutable_bitField0_ = 0;
2590 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2591 com.google.protobuf.UnknownFieldSet.newBuilder();
2592 try {
2593 boolean done = false;
2594 while (!done) {
2595 int tag = input.readTag();
2596 switch (tag) {
2597 case 0:
2598 done = true;
2599 break;
2600 default: {
2601 if (!parseUnknownField(input, unknownFields,
2602 extensionRegistry, tag)) {
2603 done = true;
2604 }
2605 break;
2606 }
2607 case 10: {
2608 if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
2609 localTime_ = new java.util.ArrayList<io.netty.example.worldclock.WorldClockProtocol.LocalTime>();
2610 mutable_bitField0_ |= 0x00000001;
2611 }
2612 localTime_.add(input.readMessage(io.netty.example.worldclock.WorldClockProtocol.LocalTime.PARSER, extensionRegistry));
2613 break;
2614 }
2615 }
2616 }
2617 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2618 throw e.setUnfinishedMessage(this);
2619 } catch (java.io.IOException e) {
2620 throw new com.google.protobuf.InvalidProtocolBufferException(
2621 e.getMessage()).setUnfinishedMessage(this);
2622 } finally {
2623 if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
2624 localTime_ = java.util.Collections.unmodifiableList(localTime_);
2625 }
2626 this.unknownFields = unknownFields.build();
2627 makeExtensionsImmutable();
2628 }
2629 }
2630 public static final com.google.protobuf.Descriptors.Descriptor
2631 getDescriptor() {
2632 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTimes_descriptor;
2633 }
2634
2635 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2636 internalGetFieldAccessorTable() {
2637 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTimes_fieldAccessorTable
2638 .ensureFieldAccessorsInitialized(
2639 io.netty.example.worldclock.WorldClockProtocol.LocalTimes.class, io.netty.example.worldclock.WorldClockProtocol.LocalTimes.Builder.class);
2640 }
2641
2642 public static com.google.protobuf.Parser<LocalTimes> PARSER =
2643 new com.google.protobuf.AbstractParser<LocalTimes>() {
2644 public LocalTimes parsePartialFrom(
2645 com.google.protobuf.CodedInputStream input,
2646 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2647 throws com.google.protobuf.InvalidProtocolBufferException {
2648 return new LocalTimes(input, extensionRegistry);
2649 }
2650 };
2651
2652 @java.lang.Override
2653 public com.google.protobuf.Parser<LocalTimes> getParserForType() {
2654 return PARSER;
2655 }
2656
2657
2658 public static final int LOCALTIME_FIELD_NUMBER = 1;
2659 private java.util.List<io.netty.example.worldclock.WorldClockProtocol.LocalTime> localTime_;
2660
2661
2662
2663 public java.util.List<io.netty.example.worldclock.WorldClockProtocol.LocalTime> getLocalTimeList() {
2664 return localTime_;
2665 }
2666
2667
2668
2669 public java.util.List<? extends io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder>
2670 getLocalTimeOrBuilderList() {
2671 return localTime_;
2672 }
2673
2674
2675
2676 public int getLocalTimeCount() {
2677 return localTime_.size();
2678 }
2679
2680
2681
2682 public io.netty.example.worldclock.WorldClockProtocol.LocalTime getLocalTime(int index) {
2683 return localTime_.get(index);
2684 }
2685
2686
2687
2688 public io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder getLocalTimeOrBuilder(
2689 int index) {
2690 return localTime_.get(index);
2691 }
2692
2693 private void initFields() {
2694 localTime_ = java.util.Collections.emptyList();
2695 }
2696 private byte memoizedIsInitialized = -1;
2697 public final boolean isInitialized() {
2698 byte isInitialized = memoizedIsInitialized;
2699 if (isInitialized != -1) return isInitialized == 1;
2700
2701 for (int i = 0; i < getLocalTimeCount(); i++) {
2702 if (!getLocalTime(i).isInitialized()) {
2703 memoizedIsInitialized = 0;
2704 return false;
2705 }
2706 }
2707 memoizedIsInitialized = 1;
2708 return true;
2709 }
2710
2711 public void writeTo(com.google.protobuf.CodedOutputStream output)
2712 throws java.io.IOException {
2713 getSerializedSize();
2714 for (int i = 0; i < localTime_.size(); i++) {
2715 output.writeMessage(1, localTime_.get(i));
2716 }
2717 getUnknownFields().writeTo(output);
2718 }
2719
2720 private int memoizedSerializedSize = -1;
2721 public int getSerializedSize() {
2722 int size = memoizedSerializedSize;
2723 if (size != -1) return size;
2724
2725 size = 0;
2726 for (int i = 0; i < localTime_.size(); i++) {
2727 size += com.google.protobuf.CodedOutputStream
2728 .computeMessageSize(1, localTime_.get(i));
2729 }
2730 size += getUnknownFields().getSerializedSize();
2731 memoizedSerializedSize = size;
2732 return size;
2733 }
2734
2735 private static final long serialVersionUID = 0L;
2736 @java.lang.Override
2737 protected java.lang.Object writeReplace()
2738 throws java.io.ObjectStreamException {
2739 return super.writeReplace();
2740 }
2741
2742 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(
2743 com.google.protobuf.ByteString data)
2744 throws com.google.protobuf.InvalidProtocolBufferException {
2745 return PARSER.parseFrom(data);
2746 }
2747 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(
2748 com.google.protobuf.ByteString data,
2749 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2750 throws com.google.protobuf.InvalidProtocolBufferException {
2751 return PARSER.parseFrom(data, extensionRegistry);
2752 }
2753 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(byte[] data)
2754 throws com.google.protobuf.InvalidProtocolBufferException {
2755 return PARSER.parseFrom(data);
2756 }
2757 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(
2758 byte[] data,
2759 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2760 throws com.google.protobuf.InvalidProtocolBufferException {
2761 return PARSER.parseFrom(data, extensionRegistry);
2762 }
2763 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(java.io.InputStream input)
2764 throws java.io.IOException {
2765 return PARSER.parseFrom(input);
2766 }
2767 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(
2768 java.io.InputStream input,
2769 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2770 throws java.io.IOException {
2771 return PARSER.parseFrom(input, extensionRegistry);
2772 }
2773 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseDelimitedFrom(java.io.InputStream input)
2774 throws java.io.IOException {
2775 return PARSER.parseDelimitedFrom(input);
2776 }
2777 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseDelimitedFrom(
2778 java.io.InputStream input,
2779 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2780 throws java.io.IOException {
2781 return PARSER.parseDelimitedFrom(input, extensionRegistry);
2782 }
2783 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(
2784 com.google.protobuf.CodedInputStream input)
2785 throws java.io.IOException {
2786 return PARSER.parseFrom(input);
2787 }
2788 public static io.netty.example.worldclock.WorldClockProtocol.LocalTimes parseFrom(
2789 com.google.protobuf.CodedInputStream input,
2790 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2791 throws java.io.IOException {
2792 return PARSER.parseFrom(input, extensionRegistry);
2793 }
2794
2795 public static Builder newBuilder() { return Builder.create(); }
2796 public Builder newBuilderForType() { return newBuilder(); }
2797 public static Builder newBuilder(io.netty.example.worldclock.WorldClockProtocol.LocalTimes prototype) {
2798 return newBuilder().mergeFrom(prototype);
2799 }
2800 public Builder toBuilder() { return newBuilder(this); }
2801
2802 @java.lang.Override
2803 protected Builder newBuilderForType(
2804 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2805 Builder builder = new Builder(parent);
2806 return builder;
2807 }
2808
2809
2810
2811 public static final class Builder extends
2812 com.google.protobuf.GeneratedMessage.Builder<Builder>
2813 implements io.netty.example.worldclock.WorldClockProtocol.LocalTimesOrBuilder {
2814 public static final com.google.protobuf.Descriptors.Descriptor
2815 getDescriptor() {
2816 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTimes_descriptor;
2817 }
2818
2819 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2820 internalGetFieldAccessorTable() {
2821 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTimes_fieldAccessorTable
2822 .ensureFieldAccessorsInitialized(
2823 io.netty.example.worldclock.WorldClockProtocol.LocalTimes.class, io.netty.example.worldclock.WorldClockProtocol.LocalTimes.Builder.class);
2824 }
2825
2826
2827 private Builder() {
2828 maybeForceBuilderInitialization();
2829 }
2830
2831 private Builder(
2832 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2833 super(parent);
2834 maybeForceBuilderInitialization();
2835 }
2836 private void maybeForceBuilderInitialization() {
2837 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2838 getLocalTimeFieldBuilder();
2839 }
2840 }
2841 private static Builder create() {
2842 return new Builder();
2843 }
2844
2845 public Builder clear() {
2846 super.clear();
2847 if (localTimeBuilder_ == null) {
2848 localTime_ = java.util.Collections.emptyList();
2849 bitField0_ = (bitField0_ & ~0x00000001);
2850 } else {
2851 localTimeBuilder_.clear();
2852 }
2853 return this;
2854 }
2855
2856 public Builder clone() {
2857 return create().mergeFrom(buildPartial());
2858 }
2859
2860 public com.google.protobuf.Descriptors.Descriptor
2861 getDescriptorForType() {
2862 return io.netty.example.worldclock.WorldClockProtocol.internal_static_io_netty_example_worldclock_LocalTimes_descriptor;
2863 }
2864
2865 public io.netty.example.worldclock.WorldClockProtocol.LocalTimes getDefaultInstanceForType() {
2866 return io.netty.example.worldclock.WorldClockProtocol.LocalTimes.getDefaultInstance();
2867 }
2868
2869 public io.netty.example.worldclock.WorldClockProtocol.LocalTimes build() {
2870 io.netty.example.worldclock.WorldClockProtocol.LocalTimes result = buildPartial();
2871 if (!result.isInitialized()) {
2872 throw newUninitializedMessageException(result);
2873 }
2874 return result;
2875 }
2876
2877 public io.netty.example.worldclock.WorldClockProtocol.LocalTimes buildPartial() {
2878 io.netty.example.worldclock.WorldClockProtocol.LocalTimes result = new io.netty.example.worldclock.WorldClockProtocol.LocalTimes(this);
2879 int from_bitField0_ = bitField0_;
2880 if (localTimeBuilder_ == null) {
2881 if (((bitField0_ & 0x00000001) == 0x00000001)) {
2882 localTime_ = java.util.Collections.unmodifiableList(localTime_);
2883 bitField0_ = (bitField0_ & ~0x00000001);
2884 }
2885 result.localTime_ = localTime_;
2886 } else {
2887 result.localTime_ = localTimeBuilder_.build();
2888 }
2889 onBuilt();
2890 return result;
2891 }
2892
2893 public Builder mergeFrom(com.google.protobuf.Message other) {
2894 if (other instanceof io.netty.example.worldclock.WorldClockProtocol.LocalTimes) {
2895 return mergeFrom((io.netty.example.worldclock.WorldClockProtocol.LocalTimes)other);
2896 } else {
2897 super.mergeFrom(other);
2898 return this;
2899 }
2900 }
2901
2902 public Builder mergeFrom(io.netty.example.worldclock.WorldClockProtocol.LocalTimes other) {
2903 if (other == io.netty.example.worldclock.WorldClockProtocol.LocalTimes.getDefaultInstance()) return this;
2904 if (localTimeBuilder_ == null) {
2905 if (!other.localTime_.isEmpty()) {
2906 if (localTime_.isEmpty()) {
2907 localTime_ = other.localTime_;
2908 bitField0_ = (bitField0_ & ~0x00000001);
2909 } else {
2910 ensureLocalTimeIsMutable();
2911 localTime_.addAll(other.localTime_);
2912 }
2913 onChanged();
2914 }
2915 } else {
2916 if (!other.localTime_.isEmpty()) {
2917 if (localTimeBuilder_.isEmpty()) {
2918 localTimeBuilder_.dispose();
2919 localTimeBuilder_ = null;
2920 localTime_ = other.localTime_;
2921 bitField0_ = (bitField0_ & ~0x00000001);
2922 localTimeBuilder_ =
2923 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
2924 getLocalTimeFieldBuilder() : null;
2925 } else {
2926 localTimeBuilder_.addAllMessages(other.localTime_);
2927 }
2928 }
2929 }
2930 this.mergeUnknownFields(other.getUnknownFields());
2931 return this;
2932 }
2933
2934 public final boolean isInitialized() {
2935 for (int i = 0; i < getLocalTimeCount(); i++) {
2936 if (!getLocalTime(i).isInitialized()) {
2937
2938 return false;
2939 }
2940 }
2941 return true;
2942 }
2943
2944 public Builder mergeFrom(
2945 com.google.protobuf.CodedInputStream input,
2946 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2947 throws java.io.IOException {
2948 io.netty.example.worldclock.WorldClockProtocol.LocalTimes parsedMessage = null;
2949 try {
2950 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2951 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2952 parsedMessage = (io.netty.example.worldclock.WorldClockProtocol.LocalTimes) e.getUnfinishedMessage();
2953 throw e;
2954 } finally {
2955 if (parsedMessage != null) {
2956 mergeFrom(parsedMessage);
2957 }
2958 }
2959 return this;
2960 }
2961 private int bitField0_;
2962
2963
2964 private java.util.List<io.netty.example.worldclock.WorldClockProtocol.LocalTime> localTime_ =
2965 java.util.Collections.emptyList();
2966 private void ensureLocalTimeIsMutable() {
2967 if (!((bitField0_ & 0x00000001) == 0x00000001)) {
2968 localTime_ = new java.util.ArrayList<io.netty.example.worldclock.WorldClockProtocol.LocalTime>(localTime_);
2969 bitField0_ |= 0x00000001;
2970 }
2971 }
2972
2973 private com.google.protobuf.RepeatedFieldBuilder<
2974 io.netty.example.worldclock.WorldClockProtocol.LocalTime, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder, io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder> localTimeBuilder_;
2975
2976
2977
2978
2979 public java.util.List<io.netty.example.worldclock.WorldClockProtocol.LocalTime> getLocalTimeList() {
2980 if (localTimeBuilder_ == null) {
2981 return java.util.Collections.unmodifiableList(localTime_);
2982 } else {
2983 return localTimeBuilder_.getMessageList();
2984 }
2985 }
2986
2987
2988
2989 public int getLocalTimeCount() {
2990 if (localTimeBuilder_ == null) {
2991 return localTime_.size();
2992 } else {
2993 return localTimeBuilder_.getCount();
2994 }
2995 }
2996
2997
2998
2999 public io.netty.example.worldclock.WorldClockProtocol.LocalTime getLocalTime(int index) {
3000 if (localTimeBuilder_ == null) {
3001 return localTime_.get(index);
3002 } else {
3003 return localTimeBuilder_.getMessage(index);
3004 }
3005 }
3006
3007
3008
3009 public Builder setLocalTime(
3010 int index, io.netty.example.worldclock.WorldClockProtocol.LocalTime value) {
3011 if (localTimeBuilder_ == null) {
3012 if (value == null) {
3013 throw new NullPointerException();
3014 }
3015 ensureLocalTimeIsMutable();
3016 localTime_.set(index, value);
3017 onChanged();
3018 } else {
3019 localTimeBuilder_.setMessage(index, value);
3020 }
3021 return this;
3022 }
3023
3024
3025
3026 public Builder setLocalTime(
3027 int index, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder builderForValue) {
3028 if (localTimeBuilder_ == null) {
3029 ensureLocalTimeIsMutable();
3030 localTime_.set(index, builderForValue.build());
3031 onChanged();
3032 } else {
3033 localTimeBuilder_.setMessage(index, builderForValue.build());
3034 }
3035 return this;
3036 }
3037
3038
3039
3040 public Builder addLocalTime(io.netty.example.worldclock.WorldClockProtocol.LocalTime value) {
3041 if (localTimeBuilder_ == null) {
3042 if (value == null) {
3043 throw new NullPointerException();
3044 }
3045 ensureLocalTimeIsMutable();
3046 localTime_.add(value);
3047 onChanged();
3048 } else {
3049 localTimeBuilder_.addMessage(value);
3050 }
3051 return this;
3052 }
3053
3054
3055
3056 public Builder addLocalTime(
3057 int index, io.netty.example.worldclock.WorldClockProtocol.LocalTime value) {
3058 if (localTimeBuilder_ == null) {
3059 if (value == null) {
3060 throw new NullPointerException();
3061 }
3062 ensureLocalTimeIsMutable();
3063 localTime_.add(index, value);
3064 onChanged();
3065 } else {
3066 localTimeBuilder_.addMessage(index, value);
3067 }
3068 return this;
3069 }
3070
3071
3072
3073 public Builder addLocalTime(
3074 io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder builderForValue) {
3075 if (localTimeBuilder_ == null) {
3076 ensureLocalTimeIsMutable();
3077 localTime_.add(builderForValue.build());
3078 onChanged();
3079 } else {
3080 localTimeBuilder_.addMessage(builderForValue.build());
3081 }
3082 return this;
3083 }
3084
3085
3086
3087 public Builder addLocalTime(
3088 int index, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder builderForValue) {
3089 if (localTimeBuilder_ == null) {
3090 ensureLocalTimeIsMutable();
3091 localTime_.add(index, builderForValue.build());
3092 onChanged();
3093 } else {
3094 localTimeBuilder_.addMessage(index, builderForValue.build());
3095 }
3096 return this;
3097 }
3098
3099
3100
3101 public Builder addAllLocalTime(
3102 java.lang.Iterable<? extends io.netty.example.worldclock.WorldClockProtocol.LocalTime> values) {
3103 if (localTimeBuilder_ == null) {
3104 ensureLocalTimeIsMutable();
3105 super.addAll(values, localTime_);
3106 onChanged();
3107 } else {
3108 localTimeBuilder_.addAllMessages(values);
3109 }
3110 return this;
3111 }
3112
3113
3114
3115 public Builder clearLocalTime() {
3116 if (localTimeBuilder_ == null) {
3117 localTime_ = java.util.Collections.emptyList();
3118 bitField0_ = (bitField0_ & ~0x00000001);
3119 onChanged();
3120 } else {
3121 localTimeBuilder_.clear();
3122 }
3123 return this;
3124 }
3125
3126
3127
3128 public Builder removeLocalTime(int index) {
3129 if (localTimeBuilder_ == null) {
3130 ensureLocalTimeIsMutable();
3131 localTime_.remove(index);
3132 onChanged();
3133 } else {
3134 localTimeBuilder_.remove(index);
3135 }
3136 return this;
3137 }
3138
3139
3140
3141 public io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder getLocalTimeBuilder(
3142 int index) {
3143 return getLocalTimeFieldBuilder().getBuilder(index);
3144 }
3145
3146
3147
3148 public io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder getLocalTimeOrBuilder(
3149 int index) {
3150 if (localTimeBuilder_ == null) {
3151 return localTime_.get(index); } else {
3152 return localTimeBuilder_.getMessageOrBuilder(index);
3153 }
3154 }
3155
3156
3157
3158 public java.util.List<? extends io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder>
3159 getLocalTimeOrBuilderList() {
3160 if (localTimeBuilder_ != null) {
3161 return localTimeBuilder_.getMessageOrBuilderList();
3162 } else {
3163 return java.util.Collections.unmodifiableList(localTime_);
3164 }
3165 }
3166
3167
3168
3169 public io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder addLocalTimeBuilder() {
3170 return getLocalTimeFieldBuilder().addBuilder(
3171 io.netty.example.worldclock.WorldClockProtocol.LocalTime.getDefaultInstance());
3172 }
3173
3174
3175
3176 public io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder addLocalTimeBuilder(
3177 int index) {
3178 return getLocalTimeFieldBuilder().addBuilder(
3179 index, io.netty.example.worldclock.WorldClockProtocol.LocalTime.getDefaultInstance());
3180 }
3181
3182
3183
3184 public java.util.List<io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder>
3185 getLocalTimeBuilderList() {
3186 return getLocalTimeFieldBuilder().getBuilderList();
3187 }
3188 private com.google.protobuf.RepeatedFieldBuilder<
3189 io.netty.example.worldclock.WorldClockProtocol.LocalTime, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder, io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder>
3190 getLocalTimeFieldBuilder() {
3191 if (localTimeBuilder_ == null) {
3192 localTimeBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
3193 io.netty.example.worldclock.WorldClockProtocol.LocalTime, io.netty.example.worldclock.WorldClockProtocol.LocalTime.Builder, io.netty.example.worldclock.WorldClockProtocol.LocalTimeOrBuilder>(
3194 localTime_,
3195 ((bitField0_ & 0x00000001) == 0x00000001),
3196 getParentForChildren(),
3197 isClean());
3198 localTime_ = null;
3199 }
3200 return localTimeBuilder_;
3201 }
3202
3203
3204 }
3205
3206 static {
3207 defaultInstance = new LocalTimes(true);
3208 defaultInstance.initFields();
3209 }
3210
3211
3212 }
3213
3214 private static com.google.protobuf.Descriptors.Descriptor
3215 internal_static_io_netty_example_worldclock_Location_descriptor;
3216 private static
3217 com.google.protobuf.GeneratedMessage.FieldAccessorTable
3218 internal_static_io_netty_example_worldclock_Location_fieldAccessorTable;
3219 private static com.google.protobuf.Descriptors.Descriptor
3220 internal_static_io_netty_example_worldclock_Locations_descriptor;
3221 private static
3222 com.google.protobuf.GeneratedMessage.FieldAccessorTable
3223 internal_static_io_netty_example_worldclock_Locations_fieldAccessorTable;
3224 private static com.google.protobuf.Descriptors.Descriptor
3225 internal_static_io_netty_example_worldclock_LocalTime_descriptor;
3226 private static
3227 com.google.protobuf.GeneratedMessage.FieldAccessorTable
3228 internal_static_io_netty_example_worldclock_LocalTime_fieldAccessorTable;
3229 private static com.google.protobuf.Descriptors.Descriptor
3230 internal_static_io_netty_example_worldclock_LocalTimes_descriptor;
3231 private static
3232 com.google.protobuf.GeneratedMessage.FieldAccessorTable
3233 internal_static_io_netty_example_worldclock_LocalTimes_fieldAccessorTable;
3234
3235 public static com.google.protobuf.Descriptors.FileDescriptor
3236 getDescriptor() {
3237 return descriptor;
3238 }
3239 private static com.google.protobuf.Descriptors.FileDescriptor
3240 descriptor;
3241 static {
3242 java.lang.String[] descriptorData = {
3243 "\nBsrc/main/java/io/netty/example/worldcl" +
3244 "ock/WorldClockProtocol.proto\022\033io.netty.e" +
3245 "xample.worldclock\"S\n\010Location\0229\n\tcontine" +
3246 "nt\030\001 \002(\0162&.io.netty.example.worldclock.C" +
3247 "ontinent\022\014\n\004city\030\002 \002(\t\"D\n\tLocations\0227\n\010l" +
3248 "ocation\030\001 \003(\0132%.io.netty.example.worldcl" +
3249 "ock.Location\"\245\001\n\tLocalTime\022\014\n\004year\030\001 \002(\r" +
3250 "\022\r\n\005month\030\002 \002(\r\022\022\n\ndayOfMonth\030\004 \002(\r\0229\n\td" +
3251 "ayOfWeek\030\005 \002(\0162&.io.netty.example.worldc" +
3252 "lock.DayOfWeek\022\014\n\004hour\030\006 \002(\r\022\016\n\006minute\030\007",
3253 " \002(\r\022\016\n\006second\030\010 \002(\r\"G\n\nLocalTimes\0229\n\tlo" +
3254 "calTime\030\001 \003(\0132&.io.netty.example.worldcl" +
3255 "ock.LocalTime*\231\001\n\tContinent\022\n\n\006AFRICA\020\000\022" +
3256 "\013\n\007AMERICA\020\001\022\016\n\nANTARCTICA\020\002\022\n\n\006ARCTIC\020\003" +
3257 "\022\010\n\004ASIA\020\004\022\014\n\010ATLANTIC\020\005\022\r\n\tAUSTRALIA\020\006\022" +
3258 "\n\n\006EUROPE\020\007\022\n\n\006INDIAN\020\010\022\013\n\007MIDEAST\020\t\022\013\n\007" +
3259 "PACIFIC\020\n*g\n\tDayOfWeek\022\n\n\006SUNDAY\020\001\022\n\n\006MO" +
3260 "NDAY\020\002\022\013\n\007TUESDAY\020\003\022\r\n\tWEDNESDAY\020\004\022\014\n\010TH" +
3261 "URSDAY\020\005\022\n\n\006FRIDAY\020\006\022\014\n\010SATURDAY\020\007B\002H\001"
3262 };
3263 com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
3264 new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
3265 public com.google.protobuf.ExtensionRegistry assignDescriptors(
3266 com.google.protobuf.Descriptors.FileDescriptor root) {
3267 descriptor = root;
3268 internal_static_io_netty_example_worldclock_Location_descriptor =
3269 getDescriptor().getMessageTypes().get(0);
3270 internal_static_io_netty_example_worldclock_Location_fieldAccessorTable = new
3271 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3272 internal_static_io_netty_example_worldclock_Location_descriptor,
3273 new java.lang.String[] { "Continent", "City", });
3274 internal_static_io_netty_example_worldclock_Locations_descriptor =
3275 getDescriptor().getMessageTypes().get(1);
3276 internal_static_io_netty_example_worldclock_Locations_fieldAccessorTable = new
3277 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3278 internal_static_io_netty_example_worldclock_Locations_descriptor,
3279 new java.lang.String[] { "Location", });
3280 internal_static_io_netty_example_worldclock_LocalTime_descriptor =
3281 getDescriptor().getMessageTypes().get(2);
3282 internal_static_io_netty_example_worldclock_LocalTime_fieldAccessorTable = new
3283 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3284 internal_static_io_netty_example_worldclock_LocalTime_descriptor,
3285 new java.lang.String[] { "Year", "Month", "DayOfMonth", "DayOfWeek", "Hour", "Minute", "Second", });
3286 internal_static_io_netty_example_worldclock_LocalTimes_descriptor =
3287 getDescriptor().getMessageTypes().get(3);
3288 internal_static_io_netty_example_worldclock_LocalTimes_fieldAccessorTable = new
3289 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3290 internal_static_io_netty_example_worldclock_LocalTimes_descriptor,
3291 new java.lang.String[] { "LocalTime", });
3292 return null;
3293 }
3294 };
3295 com.google.protobuf.Descriptors.FileDescriptor
3296 .internalBuildGeneratedFileFrom(descriptorData,
3297 new com.google.protobuf.Descriptors.FileDescriptor[] {
3298 }, assigner);
3299 }
3300
3301
3302 }