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 }