Bug 1112: Update toaster to use async best practices
[controller.git] / opendaylight / md-sal / sal-protocolbuffer-encoding / src / main / java / org / opendaylight / controller / cluster / datastore / datachange / notification / DataChangeListenerMessages.java
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: DataChangeListener.proto
3
4 package org.opendaylight.controller.cluster.datastore.datachange.notification;
5
6 public final class DataChangeListenerMessages {
7   private DataChangeListenerMessages() {}
8
9   public static void registerAllExtensions(
10       com.google.protobuf.ExtensionRegistry registry) {}
11
12   public interface DataChangedOrBuilder extends
13       com.google.protobuf.MessageOrBuilder {
14
15     // repeated string instanceIdentifierPathArguments = 1;
16     /**
17      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
18      */
19     java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList();
20
21     /**
22      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
23      */
24     int getInstanceIdentifierPathArgumentsCount();
25
26     /**
27      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
28      */
29     java.lang.String getInstanceIdentifierPathArguments(int index);
30
31     /**
32      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
33      */
34     com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
35         int index);
36
37     // required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;
38     /**
39      * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
40      */
41     boolean hasNormalizedNodeXml();
42
43     /**
44      * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
45      */
46     org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml();
47
48     /**
49      * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
50      */
51     org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder();
52   }
53   /**
54    * Protobuf type {@code org.opendaylight.controller.mdsal.DataChanged}
55    */
56   public static final class DataChanged extends
57       com.google.protobuf.GeneratedMessage implements DataChangedOrBuilder {
58     // Use DataChanged.newBuilder() to construct.
59     private DataChanged(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
60       super(builder);
61       this.unknownFields = builder.getUnknownFields();
62     }
63
64     private DataChanged(boolean noInit) {
65       this.unknownFields =
66           com.google.protobuf.UnknownFieldSet.getDefaultInstance();
67     }
68
69     private static final DataChanged defaultInstance;
70
71     public static DataChanged getDefaultInstance() {
72       return defaultInstance;
73     }
74
75     public DataChanged getDefaultInstanceForType() {
76       return defaultInstance;
77     }
78
79     private final com.google.protobuf.UnknownFieldSet unknownFields;
80
81     @java.lang.Override
82     public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
83       return this.unknownFields;
84     }
85
86     private DataChanged(com.google.protobuf.CodedInputStream input,
87         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
88         throws com.google.protobuf.InvalidProtocolBufferException {
89       initFields();
90       int mutable_bitField0_ = 0;
91       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
92           com.google.protobuf.UnknownFieldSet.newBuilder();
93       try {
94         boolean done = false;
95         while (!done) {
96           int tag = input.readTag();
97           switch (tag) {
98             case 0:
99               done = true;
100               break;
101             default: {
102               if (!parseUnknownField(input, unknownFields, extensionRegistry,
103                   tag)) {
104                 done = true;
105               }
106               break;
107             }
108             case 10: {
109               if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
110                 instanceIdentifierPathArguments_ =
111                     new com.google.protobuf.LazyStringArrayList();
112                 mutable_bitField0_ |= 0x00000001;
113               }
114               instanceIdentifierPathArguments_.add(input.readBytes());
115               break;
116             }
117             case 18: {
118               org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder =
119                   null;
120               if (((bitField0_ & 0x00000001) == 0x00000001)) {
121                 subBuilder = normalizedNodeXml_.toBuilder();
122               }
123               normalizedNodeXml_ =
124                   input
125                       .readMessage(
126                           org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER,
127                           extensionRegistry);
128               if (subBuilder != null) {
129                 subBuilder.mergeFrom(normalizedNodeXml_);
130                 normalizedNodeXml_ = subBuilder.buildPartial();
131               }
132               bitField0_ |= 0x00000001;
133               break;
134             }
135           }
136         }
137       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
138         throw e.setUnfinishedMessage(this);
139       } catch (java.io.IOException e) {
140         throw new com.google.protobuf.InvalidProtocolBufferException(
141             e.getMessage()).setUnfinishedMessage(this);
142       } finally {
143         if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
144           instanceIdentifierPathArguments_ =
145               new com.google.protobuf.UnmodifiableLazyStringList(
146                   instanceIdentifierPathArguments_);
147         }
148         this.unknownFields = unknownFields.build();
149         makeExtensionsImmutable();
150       }
151     }
152
153     public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
154       return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
155     }
156
157     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
158       return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable
159           .ensureFieldAccessorsInitialized(
160               org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.class,
161               org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.Builder.class);
162     }
163
164     public static com.google.protobuf.Parser<DataChanged> PARSER =
165         new com.google.protobuf.AbstractParser<DataChanged>() {
166           public DataChanged parsePartialFrom(
167               com.google.protobuf.CodedInputStream input,
168               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
169               throws com.google.protobuf.InvalidProtocolBufferException {
170             return new DataChanged(input, extensionRegistry);
171           }
172         };
173
174     @java.lang.Override
175     public com.google.protobuf.Parser<DataChanged> getParserForType() {
176       return PARSER;
177     }
178
179     private int bitField0_;
180     // repeated string instanceIdentifierPathArguments = 1;
181     public static final int INSTANCEIDENTIFIERPATHARGUMENTS_FIELD_NUMBER = 1;
182     private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_;
183
184     /**
185      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
186      */
187     public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
188       return instanceIdentifierPathArguments_;
189     }
190
191     /**
192      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
193      */
194     public int getInstanceIdentifierPathArgumentsCount() {
195       return instanceIdentifierPathArguments_.size();
196     }
197
198     /**
199      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
200      */
201     public java.lang.String getInstanceIdentifierPathArguments(int index) {
202       return instanceIdentifierPathArguments_.get(index);
203     }
204
205     /**
206      * <code>repeated string instanceIdentifierPathArguments = 1;</code>
207      */
208     public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
209         int index) {
210       return instanceIdentifierPathArguments_.getByteString(index);
211     }
212
213     // required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;
214     public static final int NORMALIZEDNODEXML_FIELD_NUMBER = 2;
215     private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNodeXml_;
216
217     /**
218      * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
219      */
220     public boolean hasNormalizedNodeXml() {
221       return ((bitField0_ & 0x00000001) == 0x00000001);
222     }
223
224     /**
225      * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
226      */
227     public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml() {
228       return normalizedNodeXml_;
229     }
230
231     /**
232      * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
233      */
234     public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder() {
235       return normalizedNodeXml_;
236     }
237
238     private void initFields() {
239       instanceIdentifierPathArguments_ =
240           com.google.protobuf.LazyStringArrayList.EMPTY;
241       normalizedNodeXml_ =
242           org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
243               .getDefaultInstance();
244     }
245
246     private byte memoizedIsInitialized = -1;
247
248     public final boolean isInitialized() {
249       byte isInitialized = memoizedIsInitialized;
250       if (isInitialized != -1)
251         return isInitialized == 1;
252
253       if (!hasNormalizedNodeXml()) {
254         memoizedIsInitialized = 0;
255         return false;
256       }
257       if (!getNormalizedNodeXml().isInitialized()) {
258         memoizedIsInitialized = 0;
259         return false;
260       }
261       memoizedIsInitialized = 1;
262       return true;
263     }
264
265     public void writeTo(com.google.protobuf.CodedOutputStream output)
266         throws java.io.IOException {
267       getSerializedSize();
268       for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
269         output.writeBytes(1, instanceIdentifierPathArguments_.getByteString(i));
270       }
271       if (((bitField0_ & 0x00000001) == 0x00000001)) {
272         output.writeMessage(2, normalizedNodeXml_);
273       }
274       getUnknownFields().writeTo(output);
275     }
276
277     private int memoizedSerializedSize = -1;
278
279     public int getSerializedSize() {
280       int size = memoizedSerializedSize;
281       if (size != -1)
282         return size;
283
284       size = 0;
285       {
286         int dataSize = 0;
287         for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
288           dataSize +=
289               com.google.protobuf.CodedOutputStream
290                   .computeBytesSizeNoTag(instanceIdentifierPathArguments_
291                       .getByteString(i));
292         }
293         size += dataSize;
294         size += 1 * getInstanceIdentifierPathArgumentsList().size();
295       }
296       if (((bitField0_ & 0x00000001) == 0x00000001)) {
297         size +=
298             com.google.protobuf.CodedOutputStream.computeMessageSize(2,
299                 normalizedNodeXml_);
300       }
301       size += getUnknownFields().getSerializedSize();
302       memoizedSerializedSize = size;
303       return size;
304     }
305
306     private static final long serialVersionUID = 0L;
307
308     @java.lang.Override
309     protected java.lang.Object writeReplace()
310         throws java.io.ObjectStreamException {
311       return super.writeReplace();
312     }
313
314     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
315         com.google.protobuf.ByteString data)
316         throws com.google.protobuf.InvalidProtocolBufferException {
317       return PARSER.parseFrom(data);
318     }
319
320     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
321         com.google.protobuf.ByteString data,
322         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
323         throws com.google.protobuf.InvalidProtocolBufferException {
324       return PARSER.parseFrom(data, extensionRegistry);
325     }
326
327     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
328         byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
329       return PARSER.parseFrom(data);
330     }
331
332     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
333         byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
334         throws com.google.protobuf.InvalidProtocolBufferException {
335       return PARSER.parseFrom(data, extensionRegistry);
336     }
337
338     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
339         java.io.InputStream input) throws java.io.IOException {
340       return PARSER.parseFrom(input);
341     }
342
343     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
344         java.io.InputStream input,
345         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
346         throws java.io.IOException {
347       return PARSER.parseFrom(input, extensionRegistry);
348     }
349
350     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseDelimitedFrom(
351         java.io.InputStream input) throws java.io.IOException {
352       return PARSER.parseDelimitedFrom(input);
353     }
354
355     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseDelimitedFrom(
356         java.io.InputStream input,
357         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
358         throws java.io.IOException {
359       return PARSER.parseDelimitedFrom(input, extensionRegistry);
360     }
361
362     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
363         com.google.protobuf.CodedInputStream input) throws java.io.IOException {
364       return PARSER.parseFrom(input);
365     }
366
367     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
368         com.google.protobuf.CodedInputStream input,
369         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
370         throws java.io.IOException {
371       return PARSER.parseFrom(input, extensionRegistry);
372     }
373
374     public static Builder newBuilder() {
375       return Builder.create();
376     }
377
378     public Builder newBuilderForType() {
379       return newBuilder();
380     }
381
382     public static Builder newBuilder(
383         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged prototype) {
384       return newBuilder().mergeFrom(prototype);
385     }
386
387     public Builder toBuilder() {
388       return newBuilder(this);
389     }
390
391     @java.lang.Override
392     protected Builder newBuilderForType(
393         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
394       Builder builder = new Builder(parent);
395       return builder;
396     }
397
398     /**
399      * Protobuf type {@code org.opendaylight.controller.mdsal.DataChanged}
400      */
401     public static final class Builder extends
402         com.google.protobuf.GeneratedMessage.Builder<Builder>
403         implements
404         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedOrBuilder {
405       public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
406         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
407       }
408
409       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
410         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable
411             .ensureFieldAccessorsInitialized(
412                 org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.class,
413                 org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.Builder.class);
414       }
415
416       // Construct using
417       // org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.newBuilder()
418       private Builder() {
419         maybeForceBuilderInitialization();
420       }
421
422       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
423         super(parent);
424         maybeForceBuilderInitialization();
425       }
426
427       private void maybeForceBuilderInitialization() {
428         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
429           getNormalizedNodeXmlFieldBuilder();
430         }
431       }
432
433       private static Builder create() {
434         return new Builder();
435       }
436
437       public Builder clear() {
438         super.clear();
439         instanceIdentifierPathArguments_ =
440             com.google.protobuf.LazyStringArrayList.EMPTY;
441         bitField0_ = (bitField0_ & ~0x00000001);
442         if (normalizedNodeXmlBuilder_ == null) {
443           normalizedNodeXml_ =
444               org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
445                   .getDefaultInstance();
446         } else {
447           normalizedNodeXmlBuilder_.clear();
448         }
449         bitField0_ = (bitField0_ & ~0x00000002);
450         return this;
451       }
452
453       public Builder clone() {
454         return create().mergeFrom(buildPartial());
455       }
456
457       public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
458         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
459       }
460
461       public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged getDefaultInstanceForType() {
462         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged
463             .getDefaultInstance();
464       }
465
466       public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged build() {
467         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged result =
468             buildPartial();
469         if (!result.isInitialized()) {
470           throw newUninitializedMessageException(result);
471         }
472         return result;
473       }
474
475       public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged buildPartial() {
476         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged result =
477             new org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged(
478                 this);
479         int from_bitField0_ = bitField0_;
480         int to_bitField0_ = 0;
481         if (((bitField0_ & 0x00000001) == 0x00000001)) {
482           instanceIdentifierPathArguments_ =
483               new com.google.protobuf.UnmodifiableLazyStringList(
484                   instanceIdentifierPathArguments_);
485           bitField0_ = (bitField0_ & ~0x00000001);
486         }
487         result.instanceIdentifierPathArguments_ =
488             instanceIdentifierPathArguments_;
489         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
490           to_bitField0_ |= 0x00000001;
491         }
492         if (normalizedNodeXmlBuilder_ == null) {
493           result.normalizedNodeXml_ = normalizedNodeXml_;
494         } else {
495           result.normalizedNodeXml_ = normalizedNodeXmlBuilder_.build();
496         }
497         result.bitField0_ = to_bitField0_;
498         onBuilt();
499         return result;
500       }
501
502       public Builder mergeFrom(com.google.protobuf.Message other) {
503         if (other instanceof org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged) {
504           return mergeFrom((org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged) other);
505         } else {
506           super.mergeFrom(other);
507           return this;
508         }
509       }
510
511       public Builder mergeFrom(
512           org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged other) {
513         if (other == org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged
514             .getDefaultInstance())
515           return this;
516         if (!other.instanceIdentifierPathArguments_.isEmpty()) {
517           if (instanceIdentifierPathArguments_.isEmpty()) {
518             instanceIdentifierPathArguments_ =
519                 other.instanceIdentifierPathArguments_;
520             bitField0_ = (bitField0_ & ~0x00000001);
521           } else {
522             ensureInstanceIdentifierPathArgumentsIsMutable();
523             instanceIdentifierPathArguments_
524                 .addAll(other.instanceIdentifierPathArguments_);
525           }
526           onChanged();
527         }
528         if (other.hasNormalizedNodeXml()) {
529           mergeNormalizedNodeXml(other.getNormalizedNodeXml());
530         }
531         this.mergeUnknownFields(other.getUnknownFields());
532         return this;
533       }
534
535       public final boolean isInitialized() {
536         if (!hasNormalizedNodeXml()) {
537
538           return false;
539         }
540         if (!getNormalizedNodeXml().isInitialized()) {
541
542           return false;
543         }
544         return true;
545       }
546
547       public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
548           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
549           throws java.io.IOException {
550         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parsedMessage =
551             null;
552         try {
553           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
554         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
555           parsedMessage =
556               (org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged) e
557                   .getUnfinishedMessage();
558           throw e;
559         } finally {
560           if (parsedMessage != null) {
561             mergeFrom(parsedMessage);
562           }
563         }
564         return this;
565       }
566
567       private int bitField0_;
568
569       // repeated string instanceIdentifierPathArguments = 1;
570       private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ =
571           com.google.protobuf.LazyStringArrayList.EMPTY;
572
573       private void ensureInstanceIdentifierPathArgumentsIsMutable() {
574         if (!((bitField0_ & 0x00000001) == 0x00000001)) {
575           instanceIdentifierPathArguments_ =
576               new com.google.protobuf.LazyStringArrayList(
577                   instanceIdentifierPathArguments_);
578           bitField0_ |= 0x00000001;
579         }
580       }
581
582       /**
583        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
584        */
585       public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
586         return java.util.Collections
587             .unmodifiableList(instanceIdentifierPathArguments_);
588       }
589
590       /**
591        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
592        */
593       public int getInstanceIdentifierPathArgumentsCount() {
594         return instanceIdentifierPathArguments_.size();
595       }
596
597       /**
598        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
599        */
600       public java.lang.String getInstanceIdentifierPathArguments(int index) {
601         return instanceIdentifierPathArguments_.get(index);
602       }
603
604       /**
605        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
606        */
607       public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
608           int index) {
609         return instanceIdentifierPathArguments_.getByteString(index);
610       }
611
612       /**
613        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
614        */
615       public Builder setInstanceIdentifierPathArguments(int index,
616           java.lang.String value) {
617         if (value == null) {
618           throw new NullPointerException();
619         }
620         ensureInstanceIdentifierPathArgumentsIsMutable();
621         instanceIdentifierPathArguments_.set(index, value);
622         onChanged();
623         return this;
624       }
625
626       /**
627        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
628        */
629       public Builder addInstanceIdentifierPathArguments(java.lang.String value) {
630         if (value == null) {
631           throw new NullPointerException();
632         }
633         ensureInstanceIdentifierPathArgumentsIsMutable();
634         instanceIdentifierPathArguments_.add(value);
635         onChanged();
636         return this;
637       }
638
639       /**
640        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
641        */
642       public Builder addAllInstanceIdentifierPathArguments(
643           java.lang.Iterable<java.lang.String> values) {
644         ensureInstanceIdentifierPathArgumentsIsMutable();
645         super.addAll(values, instanceIdentifierPathArguments_);
646         onChanged();
647         return this;
648       }
649
650       /**
651        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
652        */
653       public Builder clearInstanceIdentifierPathArguments() {
654         instanceIdentifierPathArguments_ =
655             com.google.protobuf.LazyStringArrayList.EMPTY;
656         bitField0_ = (bitField0_ & ~0x00000001);
657         onChanged();
658         return this;
659       }
660
661       /**
662        * <code>repeated string instanceIdentifierPathArguments = 1;</code>
663        */
664       public Builder addInstanceIdentifierPathArgumentsBytes(
665           com.google.protobuf.ByteString value) {
666         if (value == null) {
667           throw new NullPointerException();
668         }
669         ensureInstanceIdentifierPathArgumentsIsMutable();
670         instanceIdentifierPathArguments_.add(value);
671         onChanged();
672         return this;
673       }
674
675       // required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;
676       private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNodeXml_ =
677           org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
678               .getDefaultInstance();
679       private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeXmlBuilder_;
680
681       /**
682        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
683        */
684       public boolean hasNormalizedNodeXml() {
685         return ((bitField0_ & 0x00000002) == 0x00000002);
686       }
687
688       /**
689        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
690        */
691       public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml() {
692         if (normalizedNodeXmlBuilder_ == null) {
693           return normalizedNodeXml_;
694         } else {
695           return normalizedNodeXmlBuilder_.getMessage();
696         }
697       }
698
699       /**
700        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
701        */
702       public Builder setNormalizedNodeXml(
703           org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
704         if (normalizedNodeXmlBuilder_ == null) {
705           if (value == null) {
706             throw new NullPointerException();
707           }
708           normalizedNodeXml_ = value;
709           onChanged();
710         } else {
711           normalizedNodeXmlBuilder_.setMessage(value);
712         }
713         bitField0_ |= 0x00000002;
714         return this;
715       }
716
717       /**
718        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
719        */
720       public Builder setNormalizedNodeXml(
721           org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
722         if (normalizedNodeXmlBuilder_ == null) {
723           normalizedNodeXml_ = builderForValue.build();
724           onChanged();
725         } else {
726           normalizedNodeXmlBuilder_.setMessage(builderForValue.build());
727         }
728         bitField0_ |= 0x00000002;
729         return this;
730       }
731
732       /**
733        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
734        */
735       public Builder mergeNormalizedNodeXml(
736           org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
737         if (normalizedNodeXmlBuilder_ == null) {
738           if (((bitField0_ & 0x00000002) == 0x00000002)
739               && normalizedNodeXml_ != org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
740                   .getDefaultInstance()) {
741             normalizedNodeXml_ =
742                 org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
743                     .newBuilder(normalizedNodeXml_).mergeFrom(value)
744                     .buildPartial();
745           } else {
746             normalizedNodeXml_ = value;
747           }
748           onChanged();
749         } else {
750           normalizedNodeXmlBuilder_.mergeFrom(value);
751         }
752         bitField0_ |= 0x00000002;
753         return this;
754       }
755
756       /**
757        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
758        */
759       public Builder clearNormalizedNodeXml() {
760         if (normalizedNodeXmlBuilder_ == null) {
761           normalizedNodeXml_ =
762               org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
763                   .getDefaultInstance();
764           onChanged();
765         } else {
766           normalizedNodeXmlBuilder_.clear();
767         }
768         bitField0_ = (bitField0_ & ~0x00000002);
769         return this;
770       }
771
772       /**
773        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
774        */
775       public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeXmlBuilder() {
776         bitField0_ |= 0x00000002;
777         onChanged();
778         return getNormalizedNodeXmlFieldBuilder().getBuilder();
779       }
780
781       /**
782        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
783        */
784       public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder() {
785         if (normalizedNodeXmlBuilder_ != null) {
786           return normalizedNodeXmlBuilder_.getMessageOrBuilder();
787         } else {
788           return normalizedNodeXml_;
789         }
790       }
791
792       /**
793        * <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
794        */
795       private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> getNormalizedNodeXmlFieldBuilder() {
796         if (normalizedNodeXmlBuilder_ == null) {
797           normalizedNodeXmlBuilder_ =
798               new com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
799                   normalizedNodeXml_, getParentForChildren(), isClean());
800           normalizedNodeXml_ = null;
801         }
802         return normalizedNodeXmlBuilder_;
803       }
804
805       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.DataChanged)
806     }
807
808     static {
809       defaultInstance = new DataChanged(true);
810       defaultInstance.initFields();
811     }
812
813     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.DataChanged)
814   }
815
816   public interface DataChangedReplyOrBuilder extends
817       com.google.protobuf.MessageOrBuilder {
818   }
819   /**
820    * Protobuf type {@code org.opendaylight.controller.mdsal.DataChangedReply}
821    */
822   public static final class DataChangedReply extends
823       com.google.protobuf.GeneratedMessage implements DataChangedReplyOrBuilder {
824     // Use DataChangedReply.newBuilder() to construct.
825     private DataChangedReply(
826         com.google.protobuf.GeneratedMessage.Builder<?> builder) {
827       super(builder);
828       this.unknownFields = builder.getUnknownFields();
829     }
830
831     private DataChangedReply(boolean noInit) {
832       this.unknownFields =
833           com.google.protobuf.UnknownFieldSet.getDefaultInstance();
834     }
835
836     private static final DataChangedReply defaultInstance;
837
838     public static DataChangedReply getDefaultInstance() {
839       return defaultInstance;
840     }
841
842     public DataChangedReply getDefaultInstanceForType() {
843       return defaultInstance;
844     }
845
846     private final com.google.protobuf.UnknownFieldSet unknownFields;
847
848     @java.lang.Override
849     public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
850       return this.unknownFields;
851     }
852
853     private DataChangedReply(com.google.protobuf.CodedInputStream input,
854         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
855         throws com.google.protobuf.InvalidProtocolBufferException {
856       initFields();
857       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
858           com.google.protobuf.UnknownFieldSet.newBuilder();
859       try {
860         boolean done = false;
861         while (!done) {
862           int tag = input.readTag();
863           switch (tag) {
864             case 0:
865               done = true;
866               break;
867             default: {
868               if (!parseUnknownField(input, unknownFields, extensionRegistry,
869                   tag)) {
870                 done = true;
871               }
872               break;
873             }
874           }
875         }
876       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
877         throw e.setUnfinishedMessage(this);
878       } catch (java.io.IOException e) {
879         throw new com.google.protobuf.InvalidProtocolBufferException(
880             e.getMessage()).setUnfinishedMessage(this);
881       } finally {
882         this.unknownFields = unknownFields.build();
883         makeExtensionsImmutable();
884       }
885     }
886
887     public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
888       return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
889     }
890
891     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
892       return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable
893           .ensureFieldAccessorsInitialized(
894               org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.class,
895               org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.Builder.class);
896     }
897
898     public static com.google.protobuf.Parser<DataChangedReply> PARSER =
899         new com.google.protobuf.AbstractParser<DataChangedReply>() {
900           public DataChangedReply parsePartialFrom(
901               com.google.protobuf.CodedInputStream input,
902               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
903               throws com.google.protobuf.InvalidProtocolBufferException {
904             return new DataChangedReply(input, extensionRegistry);
905           }
906         };
907
908     @java.lang.Override
909     public com.google.protobuf.Parser<DataChangedReply> getParserForType() {
910       return PARSER;
911     }
912
913     private void initFields() {}
914
915     private byte memoizedIsInitialized = -1;
916
917     public final boolean isInitialized() {
918       byte isInitialized = memoizedIsInitialized;
919       if (isInitialized != -1)
920         return isInitialized == 1;
921
922       memoizedIsInitialized = 1;
923       return true;
924     }
925
926     public void writeTo(com.google.protobuf.CodedOutputStream output)
927         throws java.io.IOException {
928       getSerializedSize();
929       getUnknownFields().writeTo(output);
930     }
931
932     private int memoizedSerializedSize = -1;
933
934     public int getSerializedSize() {
935       int size = memoizedSerializedSize;
936       if (size != -1)
937         return size;
938
939       size = 0;
940       size += getUnknownFields().getSerializedSize();
941       memoizedSerializedSize = size;
942       return size;
943     }
944
945     private static final long serialVersionUID = 0L;
946
947     @java.lang.Override
948     protected java.lang.Object writeReplace()
949         throws java.io.ObjectStreamException {
950       return super.writeReplace();
951     }
952
953     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
954         com.google.protobuf.ByteString data)
955         throws com.google.protobuf.InvalidProtocolBufferException {
956       return PARSER.parseFrom(data);
957     }
958
959     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
960         com.google.protobuf.ByteString data,
961         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
962         throws com.google.protobuf.InvalidProtocolBufferException {
963       return PARSER.parseFrom(data, extensionRegistry);
964     }
965
966     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
967         byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
968       return PARSER.parseFrom(data);
969     }
970
971     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
972         byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
973         throws com.google.protobuf.InvalidProtocolBufferException {
974       return PARSER.parseFrom(data, extensionRegistry);
975     }
976
977     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
978         java.io.InputStream input) throws java.io.IOException {
979       return PARSER.parseFrom(input);
980     }
981
982     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
983         java.io.InputStream input,
984         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
985         throws java.io.IOException {
986       return PARSER.parseFrom(input, extensionRegistry);
987     }
988
989     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseDelimitedFrom(
990         java.io.InputStream input) throws java.io.IOException {
991       return PARSER.parseDelimitedFrom(input);
992     }
993
994     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseDelimitedFrom(
995         java.io.InputStream input,
996         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
997         throws java.io.IOException {
998       return PARSER.parseDelimitedFrom(input, extensionRegistry);
999     }
1000
1001     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
1002         com.google.protobuf.CodedInputStream input) throws java.io.IOException {
1003       return PARSER.parseFrom(input);
1004     }
1005
1006     public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
1007         com.google.protobuf.CodedInputStream input,
1008         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1009         throws java.io.IOException {
1010       return PARSER.parseFrom(input, extensionRegistry);
1011     }
1012
1013     public static Builder newBuilder() {
1014       return Builder.create();
1015     }
1016
1017     public Builder newBuilderForType() {
1018       return newBuilder();
1019     }
1020
1021     public static Builder newBuilder(
1022         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply prototype) {
1023       return newBuilder().mergeFrom(prototype);
1024     }
1025
1026     public Builder toBuilder() {
1027       return newBuilder(this);
1028     }
1029
1030     @java.lang.Override
1031     protected Builder newBuilderForType(
1032         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1033       Builder builder = new Builder(parent);
1034       return builder;
1035     }
1036
1037     /**
1038      * Protobuf type {@code org.opendaylight.controller.mdsal.DataChangedReply}
1039      */
1040     public static final class Builder extends
1041         com.google.protobuf.GeneratedMessage.Builder<Builder>
1042         implements
1043         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReplyOrBuilder {
1044       public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
1045         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
1046       }
1047
1048       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
1049         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable
1050             .ensureFieldAccessorsInitialized(
1051                 org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.class,
1052                 org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.Builder.class);
1053       }
1054
1055       // Construct using
1056       // org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.newBuilder()
1057       private Builder() {
1058         maybeForceBuilderInitialization();
1059       }
1060
1061       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1062         super(parent);
1063         maybeForceBuilderInitialization();
1064       }
1065
1066       private void maybeForceBuilderInitialization() {
1067         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1068         }
1069       }
1070
1071       private static Builder create() {
1072         return new Builder();
1073       }
1074
1075       public Builder clear() {
1076         super.clear();
1077         return this;
1078       }
1079
1080       public Builder clone() {
1081         return create().mergeFrom(buildPartial());
1082       }
1083
1084       public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
1085         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
1086       }
1087
1088       public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply getDefaultInstanceForType() {
1089         return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply
1090             .getDefaultInstance();
1091       }
1092
1093       public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply build() {
1094         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply result =
1095             buildPartial();
1096         if (!result.isInitialized()) {
1097           throw newUninitializedMessageException(result);
1098         }
1099         return result;
1100       }
1101
1102       public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply buildPartial() {
1103         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply result =
1104             new org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply(
1105                 this);
1106         onBuilt();
1107         return result;
1108       }
1109
1110       public Builder mergeFrom(com.google.protobuf.Message other) {
1111         if (other instanceof org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply) {
1112           return mergeFrom((org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply) other);
1113         } else {
1114           super.mergeFrom(other);
1115           return this;
1116         }
1117       }
1118
1119       public Builder mergeFrom(
1120           org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply other) {
1121         if (other == org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply
1122             .getDefaultInstance())
1123           return this;
1124         this.mergeUnknownFields(other.getUnknownFields());
1125         return this;
1126       }
1127
1128       public final boolean isInitialized() {
1129         return true;
1130       }
1131
1132       public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
1133           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1134           throws java.io.IOException {
1135         org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parsedMessage =
1136             null;
1137         try {
1138           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1139         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1140           parsedMessage =
1141               (org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply) e
1142                   .getUnfinishedMessage();
1143           throw e;
1144         } finally {
1145           if (parsedMessage != null) {
1146             mergeFrom(parsedMessage);
1147           }
1148         }
1149         return this;
1150       }
1151
1152       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.DataChangedReply)
1153     }
1154
1155     static {
1156       defaultInstance = new DataChangedReply(true);
1157       defaultInstance.initFields();
1158     }
1159
1160     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.DataChangedReply)
1161   }
1162
1163   private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
1164   private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable;
1165   private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
1166   private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable;
1167
1168   public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
1169     return descriptor;
1170   }
1171
1172   private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
1173   static {
1174     java.lang.String[] descriptorData =
1175         {"\n\030DataChangeListener.proto\022!org.opendayl"
1176             + "ight.controller.mdsal\032\032SimpleNormalizedN"
1177             + "ode.proto\"\207\001\n\013DataChanged\022\'\n\037instanceIde"
1178             + "ntifierPathArguments\030\001 \003(\t\022O\n\021normalized"
1179             + "NodeXml\030\002 \002(\01324.org.opendaylight.control"
1180             + "ler.mdsal.NormalizedNodeXml\"\022\n\020DataChang"
1181             + "edReplyBc\nEorg.opendaylight.controller.c"
1182             + "luster.datastore.datachange.notification"
1183             + "B\032DataChangeListenerMessages"};
1184     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
1185         new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
1186           public com.google.protobuf.ExtensionRegistry assignDescriptors(
1187               com.google.protobuf.Descriptors.FileDescriptor root) {
1188             descriptor = root;
1189             internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor =
1190                 getDescriptor().getMessageTypes().get(0);
1191             internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable =
1192                 new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
1193                     internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor,
1194                     new java.lang.String[] {"InstanceIdentifierPathArguments",
1195                         "NormalizedNodeXml",});
1196             internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor =
1197                 getDescriptor().getMessageTypes().get(1);
1198             internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable =
1199                 new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
1200                     internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor,
1201                     new java.lang.String[] {});
1202             return null;
1203           }
1204         };
1205     com.google.protobuf.Descriptors.FileDescriptor
1206         .internalBuildGeneratedFileFrom(
1207             descriptorData,
1208             new com.google.protobuf.Descriptors.FileDescriptor[]{org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage
1209                 .getDescriptor(),}, assigner);
1210   }
1211
1212   // @@protoc_insertion_point(outer_class_scope)
1213 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.