opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/protobuff/messages/registration/ListenerRegistrationMessages.java

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: ListenerRegistration.proto
   3
   4 package org.opendaylight.controller.protobuff.messages.registration;
   5
   6 public final class ListenerRegistrationMessages {
   7   private ListenerRegistrationMessages() {}
   8   public static void registerAllExtensions(
   9       com.google.protobuf.ExtensionRegistry registry) {
  10   }
  11   public interface CloseDataChangeListenerRegistrationOrBuilder
  12       extends com.google.protobuf.MessageOrBuilder {
  13   }
  14   /**
  15    * Protobuf type {@code org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistration}
  16    *
  17    * <pre>
  18    ** used when a listener needs to be unregistered
  19    * </pre>
  20    */
  21   public static final class CloseDataChangeListenerRegistration extends
  22       com.google.protobuf.GeneratedMessage
  23       implements CloseDataChangeListenerRegistrationOrBuilder {
  24     // Use CloseDataChangeListenerRegistration.newBuilder() to construct.
  25     private CloseDataChangeListenerRegistration(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
  26       super(builder);
  27       this.unknownFields = builder.getUnknownFields();
  28     }
  29     private CloseDataChangeListenerRegistration(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
  30
  31     private static final CloseDataChangeListenerRegistration defaultInstance;
  32     public static CloseDataChangeListenerRegistration getDefaultInstance() {
  33       return defaultInstance;
  34     }
  35
  36     public CloseDataChangeListenerRegistration getDefaultInstanceForType() {
  37       return defaultInstance;
  38     }
  39
  40     private final com.google.protobuf.UnknownFieldSet unknownFields;
  41     @java.lang.Override
  42     public final com.google.protobuf.UnknownFieldSet
  43         getUnknownFields() {
  44       return this.unknownFields;
  45     }
  46     private CloseDataChangeListenerRegistration(
  47         com.google.protobuf.CodedInputStream input,
  48         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
  49         throws com.google.protobuf.InvalidProtocolBufferException {
  50       initFields();
  51       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
  52           com.google.protobuf.UnknownFieldSet.newBuilder();
  53       try {
  54         boolean done = false;
  55         while (!done) {
  56           int tag = input.readTag();
  57           switch (tag) {
  58             case 0:
  59               done = true;
  60               break;
  61             default: {
  62               if (!parseUnknownField(input, unknownFields,
  63                                      extensionRegistry, tag)) {
  64                 done = true;
  65               }
  66               break;
  67             }
  68           }
  69         }
  70       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
  71         throw e.setUnfinishedMessage(this);
  72       } catch (java.io.IOException e) {
  73         throw new com.google.protobuf.InvalidProtocolBufferException(
  74             e.getMessage()).setUnfinishedMessage(this);
  75       } finally {
  76         this.unknownFields = unknownFields.build();
  77         makeExtensionsImmutable();
  78       }
  79     }
  80     public static final com.google.protobuf.Descriptors.Descriptor
  81         getDescriptor() {
  82       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_descriptor;
  83     }
  84
  85     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
  86         internalGetFieldAccessorTable() {
  87       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_fieldAccessorTable
  88           .ensureFieldAccessorsInitialized(
  89               org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.Builder.class);
  90     }
  91
  92     public static com.google.protobuf.Parser<CloseDataChangeListenerRegistration> PARSER =
  93         new com.google.protobuf.AbstractParser<CloseDataChangeListenerRegistration>() {
  94       public CloseDataChangeListenerRegistration parsePartialFrom(
  95           com.google.protobuf.CodedInputStream input,
  96           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
  97           throws com.google.protobuf.InvalidProtocolBufferException {
  98         return new CloseDataChangeListenerRegistration(input, extensionRegistry);
  99       }
 100     };
 101
 102     @java.lang.Override
 103     public com.google.protobuf.Parser<CloseDataChangeListenerRegistration> getParserForType() {
 104       return PARSER;
 105     }
 106
 107     private void initFields() {
 108     }
 109     private byte memoizedIsInitialized = -1;
 110     public final boolean isInitialized() {
 111       byte isInitialized = memoizedIsInitialized;
 112       if (isInitialized != -1) return isInitialized == 1;
 113
 114       memoizedIsInitialized = 1;
 115       return true;
 116     }
 117
 118     public void writeTo(com.google.protobuf.CodedOutputStream output)
 119                         throws java.io.IOException {
 120       getSerializedSize();
 121       getUnknownFields().writeTo(output);
 122     }
 123
 124     private int memoizedSerializedSize = -1;
 125     public int getSerializedSize() {
 126       int size = memoizedSerializedSize;
 127       if (size != -1) return size;
 128
 129       size = 0;
 130       size += getUnknownFields().getSerializedSize();
 131       memoizedSerializedSize = size;
 132       return size;
 133     }
 134
 135     private static final long serialVersionUID = 0L;
 136     @java.lang.Override
 137     protected java.lang.Object writeReplace()
 138         throws java.io.ObjectStreamException {
 139       return super.writeReplace();
 140     }
 141
 142     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(
 143         com.google.protobuf.ByteString data)
 144         throws com.google.protobuf.InvalidProtocolBufferException {
 145       return PARSER.parseFrom(data);
 146     }
 147     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(
 148         com.google.protobuf.ByteString data,
 149         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 150         throws com.google.protobuf.InvalidProtocolBufferException {
 151       return PARSER.parseFrom(data, extensionRegistry);
 152     }
 153     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(byte[] data)
 154         throws com.google.protobuf.InvalidProtocolBufferException {
 155       return PARSER.parseFrom(data);
 156     }
 157     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(
 158         byte[] data,
 159         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 160         throws com.google.protobuf.InvalidProtocolBufferException {
 161       return PARSER.parseFrom(data, extensionRegistry);
 162     }
 163     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(java.io.InputStream input)
 164         throws java.io.IOException {
 165       return PARSER.parseFrom(input);
 166     }
 167     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(
 168         java.io.InputStream input,
 169         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 170         throws java.io.IOException {
 171       return PARSER.parseFrom(input, extensionRegistry);
 172     }
 173     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseDelimitedFrom(java.io.InputStream input)
 174         throws java.io.IOException {
 175       return PARSER.parseDelimitedFrom(input);
 176     }
 177     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseDelimitedFrom(
 178         java.io.InputStream input,
 179         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 180         throws java.io.IOException {
 181       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 182     }
 183     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(
 184         com.google.protobuf.CodedInputStream input)
 185         throws java.io.IOException {
 186       return PARSER.parseFrom(input);
 187     }
 188     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parseFrom(
 189         com.google.protobuf.CodedInputStream input,
 190         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 191         throws java.io.IOException {
 192       return PARSER.parseFrom(input, extensionRegistry);
 193     }
 194
 195     public static Builder newBuilder() { return Builder.create(); }
 196     public Builder newBuilderForType() { return newBuilder(); }
 197     public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration prototype) {
 198       return newBuilder().mergeFrom(prototype);
 199     }
 200     public Builder toBuilder() { return newBuilder(this); }
 201
 202     @java.lang.Override
 203     protected Builder newBuilderForType(
 204         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 205       Builder builder = new Builder(parent);
 206       return builder;
 207     }
 208     /**
 209      * Protobuf type {@code org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistration}
 210      *
 211      * <pre>
 212      ** used when a listener needs to be unregistered
 213      * </pre>
 214      */
 215     public static final class Builder extends
 216         com.google.protobuf.GeneratedMessage.Builder<Builder>
 217        implements org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationOrBuilder {
 218       public static final com.google.protobuf.Descriptors.Descriptor
 219           getDescriptor() {
 220         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_descriptor;
 221       }
 222
 223       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 224           internalGetFieldAccessorTable() {
 225         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_fieldAccessorTable
 226             .ensureFieldAccessorsInitialized(
 227                 org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.Builder.class);
 228       }
 229
 230       // Construct using org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.newBuilder()
 231       private Builder() {
 232         maybeForceBuilderInitialization();
 233       }
 234
 235       private Builder(
 236           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 237         super(parent);
 238         maybeForceBuilderInitialization();
 239       }
 240       private void maybeForceBuilderInitialization() {
 241         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 242         }
 243       }
 244       private static Builder create() {
 245         return new Builder();
 246       }
 247
 248       public Builder clear() {
 249         super.clear();
 250         return this;
 251       }
 252
 253       public Builder clone() {
 254         return create().mergeFrom(buildPartial());
 255       }
 256
 257       public com.google.protobuf.Descriptors.Descriptor
 258           getDescriptorForType() {
 259         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_descriptor;
 260       }
 261
 262       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration getDefaultInstanceForType() {
 263         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.getDefaultInstance();
 264       }
 265
 266       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration build() {
 267         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration result = buildPartial();
 268         if (!result.isInitialized()) {
 269           throw newUninitializedMessageException(result);
 270         }
 271         return result;
 272       }
 273
 274       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration buildPartial() {
 275         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration result = new org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration(this);
 276         onBuilt();
 277         return result;
 278       }
 279
 280       public Builder mergeFrom(com.google.protobuf.Message other) {
 281         if (other instanceof org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration) {
 282           return mergeFrom((org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration)other);
 283         } else {
 284           super.mergeFrom(other);
 285           return this;
 286         }
 287       }
 288
 289       public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration other) {
 290         if (other == org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration.getDefaultInstance()) return this;
 291         this.mergeUnknownFields(other.getUnknownFields());
 292         return this;
 293       }
 294
 295       public final boolean isInitialized() {
 296         return true;
 297       }
 298
 299       public Builder mergeFrom(
 300           com.google.protobuf.CodedInputStream input,
 301           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 302           throws java.io.IOException {
 303         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration parsedMessage = null;
 304         try {
 305           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 306         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 307           parsedMessage = (org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistration) e.getUnfinishedMessage();
 308           throw e;
 309         } finally {
 310           if (parsedMessage != null) {
 311             mergeFrom(parsedMessage);
 312           }
 313         }
 314         return this;
 315       }
 316
 317       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistration)
 318     }
 319
 320     static {
 321       defaultInstance = new CloseDataChangeListenerRegistration(true);
 322       defaultInstance.initFields();
 323     }
 324
 325     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistration)
 326   }
 327
 328   public interface CloseDataChangeListenerRegistrationReplyOrBuilder
 329       extends com.google.protobuf.MessageOrBuilder {
 330   }
 331   /**
 332    * Protobuf type {@code org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistrationReply}
 333    *
 334    * <pre>
 335    ** reply to the CloseDataChangeListenerRegistration request
 336    * </pre>
 337    */
 338   public static final class CloseDataChangeListenerRegistrationReply extends
 339       com.google.protobuf.GeneratedMessage
 340       implements CloseDataChangeListenerRegistrationReplyOrBuilder {
 341     // Use CloseDataChangeListenerRegistrationReply.newBuilder() to construct.
 342     private CloseDataChangeListenerRegistrationReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 343       super(builder);
 344       this.unknownFields = builder.getUnknownFields();
 345     }
 346     private CloseDataChangeListenerRegistrationReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 347
 348     private static final CloseDataChangeListenerRegistrationReply defaultInstance;
 349     public static CloseDataChangeListenerRegistrationReply getDefaultInstance() {
 350       return defaultInstance;
 351     }
 352
 353     public CloseDataChangeListenerRegistrationReply getDefaultInstanceForType() {
 354       return defaultInstance;
 355     }
 356
 357     private final com.google.protobuf.UnknownFieldSet unknownFields;
 358     @java.lang.Override
 359     public final com.google.protobuf.UnknownFieldSet
 360         getUnknownFields() {
 361       return this.unknownFields;
 362     }
 363     private CloseDataChangeListenerRegistrationReply(
 364         com.google.protobuf.CodedInputStream input,
 365         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 366         throws com.google.protobuf.InvalidProtocolBufferException {
 367       initFields();
 368       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 369           com.google.protobuf.UnknownFieldSet.newBuilder();
 370       try {
 371         boolean done = false;
 372         while (!done) {
 373           int tag = input.readTag();
 374           switch (tag) {
 375             case 0:
 376               done = true;
 377               break;
 378             default: {
 379               if (!parseUnknownField(input, unknownFields,
 380                                      extensionRegistry, tag)) {
 381                 done = true;
 382               }
 383               break;
 384             }
 385           }
 386         }
 387       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 388         throw e.setUnfinishedMessage(this);
 389       } catch (java.io.IOException e) {
 390         throw new com.google.protobuf.InvalidProtocolBufferException(
 391             e.getMessage()).setUnfinishedMessage(this);
 392       } finally {
 393         this.unknownFields = unknownFields.build();
 394         makeExtensionsImmutable();
 395       }
 396     }
 397     public static final com.google.protobuf.Descriptors.Descriptor
 398         getDescriptor() {
 399       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_descriptor;
 400     }
 401
 402     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 403         internalGetFieldAccessorTable() {
 404       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_fieldAccessorTable
 405           .ensureFieldAccessorsInitialized(
 406               org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.Builder.class);
 407     }
 408
 409     public static com.google.protobuf.Parser<CloseDataChangeListenerRegistrationReply> PARSER =
 410         new com.google.protobuf.AbstractParser<CloseDataChangeListenerRegistrationReply>() {
 411       public CloseDataChangeListenerRegistrationReply parsePartialFrom(
 412           com.google.protobuf.CodedInputStream input,
 413           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 414           throws com.google.protobuf.InvalidProtocolBufferException {
 415         return new CloseDataChangeListenerRegistrationReply(input, extensionRegistry);
 416       }
 417     };
 418
 419     @java.lang.Override
 420     public com.google.protobuf.Parser<CloseDataChangeListenerRegistrationReply> getParserForType() {
 421       return PARSER;
 422     }
 423
 424     private void initFields() {
 425     }
 426     private byte memoizedIsInitialized = -1;
 427     public final boolean isInitialized() {
 428       byte isInitialized = memoizedIsInitialized;
 429       if (isInitialized != -1) return isInitialized == 1;
 430
 431       memoizedIsInitialized = 1;
 432       return true;
 433     }
 434
 435     public void writeTo(com.google.protobuf.CodedOutputStream output)
 436                         throws java.io.IOException {
 437       getSerializedSize();
 438       getUnknownFields().writeTo(output);
 439     }
 440
 441     private int memoizedSerializedSize = -1;
 442     public int getSerializedSize() {
 443       int size = memoizedSerializedSize;
 444       if (size != -1) return size;
 445
 446       size = 0;
 447       size += getUnknownFields().getSerializedSize();
 448       memoizedSerializedSize = size;
 449       return size;
 450     }
 451
 452     private static final long serialVersionUID = 0L;
 453     @java.lang.Override
 454     protected java.lang.Object writeReplace()
 455         throws java.io.ObjectStreamException {
 456       return super.writeReplace();
 457     }
 458
 459     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(
 460         com.google.protobuf.ByteString data)
 461         throws com.google.protobuf.InvalidProtocolBufferException {
 462       return PARSER.parseFrom(data);
 463     }
 464     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(
 465         com.google.protobuf.ByteString data,
 466         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 467         throws com.google.protobuf.InvalidProtocolBufferException {
 468       return PARSER.parseFrom(data, extensionRegistry);
 469     }
 470     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(byte[] data)
 471         throws com.google.protobuf.InvalidProtocolBufferException {
 472       return PARSER.parseFrom(data);
 473     }
 474     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(
 475         byte[] data,
 476         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 477         throws com.google.protobuf.InvalidProtocolBufferException {
 478       return PARSER.parseFrom(data, extensionRegistry);
 479     }
 480     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(java.io.InputStream input)
 481         throws java.io.IOException {
 482       return PARSER.parseFrom(input);
 483     }
 484     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(
 485         java.io.InputStream input,
 486         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 487         throws java.io.IOException {
 488       return PARSER.parseFrom(input, extensionRegistry);
 489     }
 490     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseDelimitedFrom(java.io.InputStream input)
 491         throws java.io.IOException {
 492       return PARSER.parseDelimitedFrom(input);
 493     }
 494     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseDelimitedFrom(
 495         java.io.InputStream input,
 496         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 497         throws java.io.IOException {
 498       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 499     }
 500     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(
 501         com.google.protobuf.CodedInputStream input)
 502         throws java.io.IOException {
 503       return PARSER.parseFrom(input);
 504     }
 505     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parseFrom(
 506         com.google.protobuf.CodedInputStream input,
 507         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 508         throws java.io.IOException {
 509       return PARSER.parseFrom(input, extensionRegistry);
 510     }
 511
 512     public static Builder newBuilder() { return Builder.create(); }
 513     public Builder newBuilderForType() { return newBuilder(); }
 514     public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply prototype) {
 515       return newBuilder().mergeFrom(prototype);
 516     }
 517     public Builder toBuilder() { return newBuilder(this); }
 518
 519     @java.lang.Override
 520     protected Builder newBuilderForType(
 521         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 522       Builder builder = new Builder(parent);
 523       return builder;
 524     }
 525     /**
 526      * Protobuf type {@code org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistrationReply}
 527      *
 528      * <pre>
 529      ** reply to the CloseDataChangeListenerRegistration request
 530      * </pre>
 531      */
 532     public static final class Builder extends
 533         com.google.protobuf.GeneratedMessage.Builder<Builder>
 534        implements org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReplyOrBuilder {
 535       public static final com.google.protobuf.Descriptors.Descriptor
 536           getDescriptor() {
 537         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_descriptor;
 538       }
 539
 540       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 541           internalGetFieldAccessorTable() {
 542         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_fieldAccessorTable
 543             .ensureFieldAccessorsInitialized(
 544                 org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.Builder.class);
 545       }
 546
 547       // Construct using org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.newBuilder()
 548       private Builder() {
 549         maybeForceBuilderInitialization();
 550       }
 551
 552       private Builder(
 553           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 554         super(parent);
 555         maybeForceBuilderInitialization();
 556       }
 557       private void maybeForceBuilderInitialization() {
 558         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 559         }
 560       }
 561       private static Builder create() {
 562         return new Builder();
 563       }
 564
 565       public Builder clear() {
 566         super.clear();
 567         return this;
 568       }
 569
 570       public Builder clone() {
 571         return create().mergeFrom(buildPartial());
 572       }
 573
 574       public com.google.protobuf.Descriptors.Descriptor
 575           getDescriptorForType() {
 576         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_descriptor;
 577       }
 578
 579       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply getDefaultInstanceForType() {
 580         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.getDefaultInstance();
 581       }
 582
 583       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply build() {
 584         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply result = buildPartial();
 585         if (!result.isInitialized()) {
 586           throw newUninitializedMessageException(result);
 587         }
 588         return result;
 589       }
 590
 591       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply buildPartial() {
 592         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply result = new org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply(this);
 593         onBuilt();
 594         return result;
 595       }
 596
 597       public Builder mergeFrom(com.google.protobuf.Message other) {
 598         if (other instanceof org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply) {
 599           return mergeFrom((org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply)other);
 600         } else {
 601           super.mergeFrom(other);
 602           return this;
 603         }
 604       }
 605
 606       public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply other) {
 607         if (other == org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.getDefaultInstance()) return this;
 608         this.mergeUnknownFields(other.getUnknownFields());
 609         return this;
 610       }
 611
 612       public final boolean isInitialized() {
 613         return true;
 614       }
 615
 616       public Builder mergeFrom(
 617           com.google.protobuf.CodedInputStream input,
 618           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 619           throws java.io.IOException {
 620         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply parsedMessage = null;
 621         try {
 622           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 623         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 624           parsedMessage = (org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply) e.getUnfinishedMessage();
 625           throw e;
 626         } finally {
 627           if (parsedMessage != null) {
 628             mergeFrom(parsedMessage);
 629           }
 630         }
 631         return this;
 632       }
 633
 634       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistrationReply)
 635     }
 636
 637     static {
 638       defaultInstance = new CloseDataChangeListenerRegistrationReply(true);
 639       defaultInstance.initFields();
 640     }
 641
 642     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseDataChangeListenerRegistrationReply)
 643   }
 644
 645   public interface RegisterChangeListenerOrBuilder
 646       extends com.google.protobuf.MessageOrBuilder {
 647
 648     // required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;
 649     /**
 650      * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
 651      */
 652     boolean hasInstanceIdentifierPath();
 653     /**
 654      * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
 655      */
 656     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierPath();
 657     /**
 658      * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
 659      */
 660     org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierPathOrBuilder();
 661
 662     // required string dataChangeListenerActorPath = 2;
 663     /**
 664      * <code>required string dataChangeListenerActorPath = 2;</code>
 665      */
 666     boolean hasDataChangeListenerActorPath();
 667     /**
 668      * <code>required string dataChangeListenerActorPath = 2;</code>
 669      */
 670     java.lang.String getDataChangeListenerActorPath();
 671     /**
 672      * <code>required string dataChangeListenerActorPath = 2;</code>
 673      */
 674     com.google.protobuf.ByteString
 675         getDataChangeListenerActorPathBytes();
 676
 677     // required int32 dataChangeScope = 3;
 678     /**
 679      * <code>required int32 dataChangeScope = 3;</code>
 680      */
 681     boolean hasDataChangeScope();
 682     /**
 683      * <code>required int32 dataChangeScope = 3;</code>
 684      */
 685     int getDataChangeScope();
 686
 687     // optional bool registerOnAllInstances = 4;
 688     /**
 689      * <code>optional bool registerOnAllInstances = 4;</code>
 690      */
 691     boolean hasRegisterOnAllInstances();
 692     /**
 693      * <code>optional bool registerOnAllInstances = 4;</code>
 694      */
 695     boolean getRegisterOnAllInstances();
 696   }
 697   /**
 698    * Protobuf type {@code org.opendaylight.controller.mdsal.RegisterChangeListener}
 699    */
 700   public static final class RegisterChangeListener extends
 701       com.google.protobuf.GeneratedMessage
 702       implements RegisterChangeListenerOrBuilder {
 703     // Use RegisterChangeListener.newBuilder() to construct.
 704     private RegisterChangeListener(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 705       super(builder);
 706       this.unknownFields = builder.getUnknownFields();
 707     }
 708     private RegisterChangeListener(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 709
 710     private static final RegisterChangeListener defaultInstance;
 711     public static RegisterChangeListener getDefaultInstance() {
 712       return defaultInstance;
 713     }
 714
 715     public RegisterChangeListener getDefaultInstanceForType() {
 716       return defaultInstance;
 717     }
 718
 719     private final com.google.protobuf.UnknownFieldSet unknownFields;
 720     @java.lang.Override
 721     public final com.google.protobuf.UnknownFieldSet
 722         getUnknownFields() {
 723       return this.unknownFields;
 724     }
 725     private RegisterChangeListener(
 726         com.google.protobuf.CodedInputStream input,
 727         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 728         throws com.google.protobuf.InvalidProtocolBufferException {
 729       initFields();
 730       int mutable_bitField0_ = 0;
 731       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 732           com.google.protobuf.UnknownFieldSet.newBuilder();
 733       try {
 734         boolean done = false;
 735         while (!done) {
 736           int tag = input.readTag();
 737           switch (tag) {
 738             case 0:
 739               done = true;
 740               break;
 741             default: {
 742               if (!parseUnknownField(input, unknownFields,
 743                                      extensionRegistry, tag)) {
 744                 done = true;
 745               }
 746               break;
 747             }
 748             case 10: {
 749               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder subBuilder = null;
 750               if (((bitField0_ & 0x00000001) == 0x00000001)) {
 751                 subBuilder = instanceIdentifierPath_.toBuilder();
 752               }
 753               instanceIdentifierPath_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.PARSER, extensionRegistry);
 754               if (subBuilder != null) {
 755                 subBuilder.mergeFrom(instanceIdentifierPath_);
 756                 instanceIdentifierPath_ = subBuilder.buildPartial();
 757               }
 758               bitField0_ |= 0x00000001;
 759               break;
 760             }
 761             case 18: {
 762               bitField0_ |= 0x00000002;
 763               dataChangeListenerActorPath_ = input.readBytes();
 764               break;
 765             }
 766             case 24: {
 767               bitField0_ |= 0x00000004;
 768               dataChangeScope_ = input.readInt32();
 769               break;
 770             }
 771             case 32: {
 772               bitField0_ |= 0x00000008;
 773               registerOnAllInstances_ = input.readBool();
 774               break;
 775             }
 776           }
 777         }
 778       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 779         throw e.setUnfinishedMessage(this);
 780       } catch (java.io.IOException e) {
 781         throw new com.google.protobuf.InvalidProtocolBufferException(
 782             e.getMessage()).setUnfinishedMessage(this);
 783       } finally {
 784         this.unknownFields = unknownFields.build();
 785         makeExtensionsImmutable();
 786       }
 787     }
 788     public static final com.google.protobuf.Descriptors.Descriptor
 789         getDescriptor() {
 790       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_descriptor;
 791     }
 792
 793     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 794         internalGetFieldAccessorTable() {
 795       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_fieldAccessorTable
 796           .ensureFieldAccessorsInitialized(
 797               org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.Builder.class);
 798     }
 799
 800     public static com.google.protobuf.Parser<RegisterChangeListener> PARSER =
 801         new com.google.protobuf.AbstractParser<RegisterChangeListener>() {
 802       public RegisterChangeListener parsePartialFrom(
 803           com.google.protobuf.CodedInputStream input,
 804           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 805           throws com.google.protobuf.InvalidProtocolBufferException {
 806         return new RegisterChangeListener(input, extensionRegistry);
 807       }
 808     };
 809
 810     @java.lang.Override
 811     public com.google.protobuf.Parser<RegisterChangeListener> getParserForType() {
 812       return PARSER;
 813     }
 814
 815     private int bitField0_;
 816     // required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;
 817     public static final int INSTANCEIDENTIFIERPATH_FIELD_NUMBER = 1;
 818     private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier instanceIdentifierPath_;
 819     /**
 820      * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
 821      */
 822     public boolean hasInstanceIdentifierPath() {
 823       return ((bitField0_ & 0x00000001) == 0x00000001);
 824     }
 825     /**
 826      * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
 827      */
 828     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierPath() {
 829       return instanceIdentifierPath_;
 830     }
 831     /**
 832      * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
 833      */
 834     public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierPathOrBuilder() {
 835       return instanceIdentifierPath_;
 836     }
 837
 838     // required string dataChangeListenerActorPath = 2;
 839     public static final int DATACHANGELISTENERACTORPATH_FIELD_NUMBER = 2;
 840     private java.lang.Object dataChangeListenerActorPath_;
 841     /**
 842      * <code>required string dataChangeListenerActorPath = 2;</code>
 843      */
 844     public boolean hasDataChangeListenerActorPath() {
 845       return ((bitField0_ & 0x00000002) == 0x00000002);
 846     }
 847     /**
 848      * <code>required string dataChangeListenerActorPath = 2;</code>
 849      */
 850     public java.lang.String getDataChangeListenerActorPath() {
 851       java.lang.Object ref = dataChangeListenerActorPath_;
 852       if (ref instanceof java.lang.String) {
 853         return (java.lang.String) ref;
 854       } else {
 855         com.google.protobuf.ByteString bs =
 856             (com.google.protobuf.ByteString) ref;
 857         java.lang.String s = bs.toStringUtf8();
 858         if (bs.isValidUtf8()) {
 859           dataChangeListenerActorPath_ = s;
 860         }
 861         return s;
 862       }
 863     }
 864     /**
 865      * <code>required string dataChangeListenerActorPath = 2;</code>
 866      */
 867     public com.google.protobuf.ByteString
 868         getDataChangeListenerActorPathBytes() {
 869       java.lang.Object ref = dataChangeListenerActorPath_;
 870       if (ref instanceof java.lang.String) {
 871         com.google.protobuf.ByteString b =
 872             com.google.protobuf.ByteString.copyFromUtf8(
 873                 (java.lang.String) ref);
 874         dataChangeListenerActorPath_ = b;
 875         return b;
 876       } else {
 877         return (com.google.protobuf.ByteString) ref;
 878       }
 879     }
 880
 881     // required int32 dataChangeScope = 3;
 882     public static final int DATACHANGESCOPE_FIELD_NUMBER = 3;
 883     private int dataChangeScope_;
 884     /**
 885      * <code>required int32 dataChangeScope = 3;</code>
 886      */
 887     public boolean hasDataChangeScope() {
 888       return ((bitField0_ & 0x00000004) == 0x00000004);
 889     }
 890     /**
 891      * <code>required int32 dataChangeScope = 3;</code>
 892      */
 893     public int getDataChangeScope() {
 894       return dataChangeScope_;
 895     }
 896
 897     // optional bool registerOnAllInstances = 4;
 898     public static final int REGISTERONALLINSTANCES_FIELD_NUMBER = 4;
 899     private boolean registerOnAllInstances_;
 900     /**
 901      * <code>optional bool registerOnAllInstances = 4;</code>
 902      */
 903     public boolean hasRegisterOnAllInstances() {
 904       return ((bitField0_ & 0x00000008) == 0x00000008);
 905     }
 906     /**
 907      * <code>optional bool registerOnAllInstances = 4;</code>
 908      */
 909     public boolean getRegisterOnAllInstances() {
 910       return registerOnAllInstances_;
 911     }
 912
 913     private void initFields() {
 914       instanceIdentifierPath_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
 915       dataChangeListenerActorPath_ = "";
 916       dataChangeScope_ = 0;
 917       registerOnAllInstances_ = false;
 918     }
 919     private byte memoizedIsInitialized = -1;
 920     public final boolean isInitialized() {
 921       byte isInitialized = memoizedIsInitialized;
 922       if (isInitialized != -1) return isInitialized == 1;
 923
 924       if (!hasInstanceIdentifierPath()) {
 925         memoizedIsInitialized = 0;
 926         return false;
 927       }
 928       if (!hasDataChangeListenerActorPath()) {
 929         memoizedIsInitialized = 0;
 930         return false;
 931       }
 932       if (!hasDataChangeScope()) {
 933         memoizedIsInitialized = 0;
 934         return false;
 935       }
 936       if (!getInstanceIdentifierPath().isInitialized()) {
 937         memoizedIsInitialized = 0;
 938         return false;
 939       }
 940       memoizedIsInitialized = 1;
 941       return true;
 942     }
 943
 944     public void writeTo(com.google.protobuf.CodedOutputStream output)
 945                         throws java.io.IOException {
 946       getSerializedSize();
 947       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 948         output.writeMessage(1, instanceIdentifierPath_);
 949       }
 950       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 951         output.writeBytes(2, getDataChangeListenerActorPathBytes());
 952       }
 953       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 954         output.writeInt32(3, dataChangeScope_);
 955       }
 956       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 957         output.writeBool(4, registerOnAllInstances_);
 958       }
 959       getUnknownFields().writeTo(output);
 960     }
 961
 962     private int memoizedSerializedSize = -1;
 963     public int getSerializedSize() {
 964       int size = memoizedSerializedSize;
 965       if (size != -1) return size;
 966
 967       size = 0;
 968       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 969         size += com.google.protobuf.CodedOutputStream
 970           .computeMessageSize(1, instanceIdentifierPath_);
 971       }
 972       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 973         size += com.google.protobuf.CodedOutputStream
 974           .computeBytesSize(2, getDataChangeListenerActorPathBytes());
 975       }
 976       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 977         size += com.google.protobuf.CodedOutputStream
 978           .computeInt32Size(3, dataChangeScope_);
 979       }
 980       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 981         size += com.google.protobuf.CodedOutputStream
 982           .computeBoolSize(4, registerOnAllInstances_);
 983       }
 984       size += getUnknownFields().getSerializedSize();
 985       memoizedSerializedSize = size;
 986       return size;
 987     }
 988
 989     private static final long serialVersionUID = 0L;
 990     @java.lang.Override
 991     protected java.lang.Object writeReplace()
 992         throws java.io.ObjectStreamException {
 993       return super.writeReplace();
 994     }
 995
 996     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(
 997         com.google.protobuf.ByteString data)
 998         throws com.google.protobuf.InvalidProtocolBufferException {
 999       return PARSER.parseFrom(data);
1000     }
1001     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(
1002         com.google.protobuf.ByteString data,
1003         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1004         throws com.google.protobuf.InvalidProtocolBufferException {
1005       return PARSER.parseFrom(data, extensionRegistry);
1006     }
1007     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(byte[] data)
1008         throws com.google.protobuf.InvalidProtocolBufferException {
1009       return PARSER.parseFrom(data);
1010     }
1011     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(
1012         byte[] data,
1013         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1014         throws com.google.protobuf.InvalidProtocolBufferException {
1015       return PARSER.parseFrom(data, extensionRegistry);
1016     }
1017     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(java.io.InputStream input)
1018         throws java.io.IOException {
1019       return PARSER.parseFrom(input);
1020     }
1021     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(
1022         java.io.InputStream input,
1023         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1024         throws java.io.IOException {
1025       return PARSER.parseFrom(input, extensionRegistry);
1026     }
1027     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseDelimitedFrom(java.io.InputStream input)
1028         throws java.io.IOException {
1029       return PARSER.parseDelimitedFrom(input);
1030     }
1031     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseDelimitedFrom(
1032         java.io.InputStream input,
1033         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1034         throws java.io.IOException {
1035       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1036     }
1037     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(
1038         com.google.protobuf.CodedInputStream input)
1039         throws java.io.IOException {
1040       return PARSER.parseFrom(input);
1041     }
1042     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parseFrom(
1043         com.google.protobuf.CodedInputStream input,
1044         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1045         throws java.io.IOException {
1046       return PARSER.parseFrom(input, extensionRegistry);
1047     }
1048
1049     public static Builder newBuilder() { return Builder.create(); }
1050     public Builder newBuilderForType() { return newBuilder(); }
1051     public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener prototype) {
1052       return newBuilder().mergeFrom(prototype);
1053     }
1054     public Builder toBuilder() { return newBuilder(this); }
1055
1056     @java.lang.Override
1057     protected Builder newBuilderForType(
1058         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1059       Builder builder = new Builder(parent);
1060       return builder;
1061     }
1062     /**
1063      * Protobuf type {@code org.opendaylight.controller.mdsal.RegisterChangeListener}
1064      */
1065     public static final class Builder extends
1066         com.google.protobuf.GeneratedMessage.Builder<Builder>
1067        implements org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerOrBuilder {
1068       public static final com.google.protobuf.Descriptors.Descriptor
1069           getDescriptor() {
1070         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_descriptor;
1071       }
1072
1073       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1074           internalGetFieldAccessorTable() {
1075         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_fieldAccessorTable
1076             .ensureFieldAccessorsInitialized(
1077                 org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.Builder.class);
1078       }
1079
1080       // Construct using org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.newBuilder()
1081       private Builder() {
1082         maybeForceBuilderInitialization();
1083       }
1084
1085       private Builder(
1086           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1087         super(parent);
1088         maybeForceBuilderInitialization();
1089       }
1090       private void maybeForceBuilderInitialization() {
1091         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1092           getInstanceIdentifierPathFieldBuilder();
1093         }
1094       }
1095       private static Builder create() {
1096         return new Builder();
1097       }
1098
1099       public Builder clear() {
1100         super.clear();
1101         if (instanceIdentifierPathBuilder_ == null) {
1102           instanceIdentifierPath_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
1103         } else {
1104           instanceIdentifierPathBuilder_.clear();
1105         }
1106         bitField0_ = (bitField0_ & ~0x00000001);
1107         dataChangeListenerActorPath_ = "";
1108         bitField0_ = (bitField0_ & ~0x00000002);
1109         dataChangeScope_ = 0;
1110         bitField0_ = (bitField0_ & ~0x00000004);
1111         registerOnAllInstances_ = false;
1112         bitField0_ = (bitField0_ & ~0x00000008);
1113         return this;
1114       }
1115
1116       public Builder clone() {
1117         return create().mergeFrom(buildPartial());
1118       }
1119
1120       public com.google.protobuf.Descriptors.Descriptor
1121           getDescriptorForType() {
1122         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_descriptor;
1123       }
1124
1125       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener getDefaultInstanceForType() {
1126         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.getDefaultInstance();
1127       }
1128
1129       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener build() {
1130         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener result = buildPartial();
1131         if (!result.isInitialized()) {
1132           throw newUninitializedMessageException(result);
1133         }
1134         return result;
1135       }
1136
1137       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener buildPartial() {
1138         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener result = new org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener(this);
1139         int from_bitField0_ = bitField0_;
1140         int to_bitField0_ = 0;
1141         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1142           to_bitField0_ |= 0x00000001;
1143         }
1144         if (instanceIdentifierPathBuilder_ == null) {
1145           result.instanceIdentifierPath_ = instanceIdentifierPath_;
1146         } else {
1147           result.instanceIdentifierPath_ = instanceIdentifierPathBuilder_.build();
1148         }
1149         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1150           to_bitField0_ |= 0x00000002;
1151         }
1152         result.dataChangeListenerActorPath_ = dataChangeListenerActorPath_;
1153         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1154           to_bitField0_ |= 0x00000004;
1155         }
1156         result.dataChangeScope_ = dataChangeScope_;
1157         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
1158           to_bitField0_ |= 0x00000008;
1159         }
1160         result.registerOnAllInstances_ = registerOnAllInstances_;
1161         result.bitField0_ = to_bitField0_;
1162         onBuilt();
1163         return result;
1164       }
1165
1166       public Builder mergeFrom(com.google.protobuf.Message other) {
1167         if (other instanceof org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener) {
1168           return mergeFrom((org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener)other);
1169         } else {
1170           super.mergeFrom(other);
1171           return this;
1172         }
1173       }
1174
1175       public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener other) {
1176         if (other == org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener.getDefaultInstance()) return this;
1177         if (other.hasInstanceIdentifierPath()) {
1178           mergeInstanceIdentifierPath(other.getInstanceIdentifierPath());
1179         }
1180         if (other.hasDataChangeListenerActorPath()) {
1181           bitField0_ |= 0x00000002;
1182           dataChangeListenerActorPath_ = other.dataChangeListenerActorPath_;
1183           onChanged();
1184         }
1185         if (other.hasDataChangeScope()) {
1186           setDataChangeScope(other.getDataChangeScope());
1187         }
1188         if (other.hasRegisterOnAllInstances()) {
1189           setRegisterOnAllInstances(other.getRegisterOnAllInstances());
1190         }
1191         this.mergeUnknownFields(other.getUnknownFields());
1192         return this;
1193       }
1194
1195       public final boolean isInitialized() {
1196         if (!hasInstanceIdentifierPath()) {
1197
1198           return false;
1199         }
1200         if (!hasDataChangeListenerActorPath()) {
1201
1202           return false;
1203         }
1204         if (!hasDataChangeScope()) {
1205
1206           return false;
1207         }
1208         if (!getInstanceIdentifierPath().isInitialized()) {
1209
1210           return false;
1211         }
1212         return true;
1213       }
1214
1215       public Builder mergeFrom(
1216           com.google.protobuf.CodedInputStream input,
1217           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1218           throws java.io.IOException {
1219         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener parsedMessage = null;
1220         try {
1221           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1222         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1223           parsedMessage = (org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListener) e.getUnfinishedMessage();
1224           throw e;
1225         } finally {
1226           if (parsedMessage != null) {
1227             mergeFrom(parsedMessage);
1228           }
1229         }
1230         return this;
1231       }
1232       private int bitField0_;
1233
1234       // required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;
1235       private org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier instanceIdentifierPath_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
1236       private com.google.protobuf.SingleFieldBuilder<
1237           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder> instanceIdentifierPathBuilder_;
1238       /**
1239        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1240        */
1241       public boolean hasInstanceIdentifierPath() {
1242         return ((bitField0_ & 0x00000001) == 0x00000001);
1243       }
1244       /**
1245        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1246        */
1247       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier getInstanceIdentifierPath() {
1248         if (instanceIdentifierPathBuilder_ == null) {
1249           return instanceIdentifierPath_;
1250         } else {
1251           return instanceIdentifierPathBuilder_.getMessage();
1252         }
1253       }
1254       /**
1255        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1256        */
1257       public Builder setInstanceIdentifierPath(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier value) {
1258         if (instanceIdentifierPathBuilder_ == null) {
1259           if (value == null) {
1260             throw new NullPointerException();
1261           }
1262           instanceIdentifierPath_ = value;
1263           onChanged();
1264         } else {
1265           instanceIdentifierPathBuilder_.setMessage(value);
1266         }
1267         bitField0_ |= 0x00000001;
1268         return this;
1269       }
1270       /**
1271        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1272        */
1273       public Builder setInstanceIdentifierPath(
1274           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder builderForValue) {
1275         if (instanceIdentifierPathBuilder_ == null) {
1276           instanceIdentifierPath_ = builderForValue.build();
1277           onChanged();
1278         } else {
1279           instanceIdentifierPathBuilder_.setMessage(builderForValue.build());
1280         }
1281         bitField0_ |= 0x00000001;
1282         return this;
1283       }
1284       /**
1285        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1286        */
1287       public Builder mergeInstanceIdentifierPath(org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier value) {
1288         if (instanceIdentifierPathBuilder_ == null) {
1289           if (((bitField0_ & 0x00000001) == 0x00000001) &&
1290               instanceIdentifierPath_ != org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance()) {
1291             instanceIdentifierPath_ =
1292               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.newBuilder(instanceIdentifierPath_).mergeFrom(value).buildPartial();
1293           } else {
1294             instanceIdentifierPath_ = value;
1295           }
1296           onChanged();
1297         } else {
1298           instanceIdentifierPathBuilder_.mergeFrom(value);
1299         }
1300         bitField0_ |= 0x00000001;
1301         return this;
1302       }
1303       /**
1304        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1305        */
1306       public Builder clearInstanceIdentifierPath() {
1307         if (instanceIdentifierPathBuilder_ == null) {
1308           instanceIdentifierPath_ = org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.getDefaultInstance();
1309           onChanged();
1310         } else {
1311           instanceIdentifierPathBuilder_.clear();
1312         }
1313         bitField0_ = (bitField0_ & ~0x00000001);
1314         return this;
1315       }
1316       /**
1317        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1318        */
1319       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder getInstanceIdentifierPathBuilder() {
1320         bitField0_ |= 0x00000001;
1321         onChanged();
1322         return getInstanceIdentifierPathFieldBuilder().getBuilder();
1323       }
1324       /**
1325        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1326        */
1327       public org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder getInstanceIdentifierPathOrBuilder() {
1328         if (instanceIdentifierPathBuilder_ != null) {
1329           return instanceIdentifierPathBuilder_.getMessageOrBuilder();
1330         } else {
1331           return instanceIdentifierPath_;
1332         }
1333       }
1334       /**
1335        * <code>required .org.opendaylight.controller.mdsal.InstanceIdentifier instanceIdentifierPath = 1;</code>
1336        */
1337       private com.google.protobuf.SingleFieldBuilder<
1338           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>
1339           getInstanceIdentifierPathFieldBuilder() {
1340         if (instanceIdentifierPathBuilder_ == null) {
1341           instanceIdentifierPathBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1342               org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier.Builder, org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifierOrBuilder>(
1343                   instanceIdentifierPath_,
1344                   getParentForChildren(),
1345                   isClean());
1346           instanceIdentifierPath_ = null;
1347         }
1348         return instanceIdentifierPathBuilder_;
1349       }
1350
1351       // required string dataChangeListenerActorPath = 2;
1352       private java.lang.Object dataChangeListenerActorPath_ = "";
1353       /**
1354        * <code>required string dataChangeListenerActorPath = 2;</code>
1355        */
1356       public boolean hasDataChangeListenerActorPath() {
1357         return ((bitField0_ & 0x00000002) == 0x00000002);
1358       }
1359       /**
1360        * <code>required string dataChangeListenerActorPath = 2;</code>
1361        */
1362       public java.lang.String getDataChangeListenerActorPath() {
1363         java.lang.Object ref = dataChangeListenerActorPath_;
1364         if (!(ref instanceof java.lang.String)) {
1365           java.lang.String s = ((com.google.protobuf.ByteString) ref)
1366               .toStringUtf8();
1367           dataChangeListenerActorPath_ = s;
1368           return s;
1369         } else {
1370           return (java.lang.String) ref;
1371         }
1372       }
1373       /**
1374        * <code>required string dataChangeListenerActorPath = 2;</code>
1375        */
1376       public com.google.protobuf.ByteString
1377           getDataChangeListenerActorPathBytes() {
1378         java.lang.Object ref = dataChangeListenerActorPath_;
1379         if (ref instanceof String) {
1380           com.google.protobuf.ByteString b =
1381               com.google.protobuf.ByteString.copyFromUtf8(
1382                   (java.lang.String) ref);
1383           dataChangeListenerActorPath_ = b;
1384           return b;
1385         } else {
1386           return (com.google.protobuf.ByteString) ref;
1387         }
1388       }
1389       /**
1390        * <code>required string dataChangeListenerActorPath = 2;</code>
1391        */
1392       public Builder setDataChangeListenerActorPath(
1393           java.lang.String value) {
1394         if (value == null) {
1395     throw new NullPointerException();
1396   }
1397   bitField0_ |= 0x00000002;
1398         dataChangeListenerActorPath_ = value;
1399         onChanged();
1400         return this;
1401       }
1402       /**
1403        * <code>required string dataChangeListenerActorPath = 2;</code>
1404        */
1405       public Builder clearDataChangeListenerActorPath() {
1406         bitField0_ = (bitField0_ & ~0x00000002);
1407         dataChangeListenerActorPath_ = getDefaultInstance().getDataChangeListenerActorPath();
1408         onChanged();
1409         return this;
1410       }
1411       /**
1412        * <code>required string dataChangeListenerActorPath = 2;</code>
1413        */
1414       public Builder setDataChangeListenerActorPathBytes(
1415           com.google.protobuf.ByteString value) {
1416         if (value == null) {
1417     throw new NullPointerException();
1418   }
1419   bitField0_ |= 0x00000002;
1420         dataChangeListenerActorPath_ = value;
1421         onChanged();
1422         return this;
1423       }
1424
1425       // required int32 dataChangeScope = 3;
1426       private int dataChangeScope_ ;
1427       /**
1428        * <code>required int32 dataChangeScope = 3;</code>
1429        */
1430       public boolean hasDataChangeScope() {
1431         return ((bitField0_ & 0x00000004) == 0x00000004);
1432       }
1433       /**
1434        * <code>required int32 dataChangeScope = 3;</code>
1435        */
1436       public int getDataChangeScope() {
1437         return dataChangeScope_;
1438       }
1439       /**
1440        * <code>required int32 dataChangeScope = 3;</code>
1441        */
1442       public Builder setDataChangeScope(int value) {
1443         bitField0_ |= 0x00000004;
1444         dataChangeScope_ = value;
1445         onChanged();
1446         return this;
1447       }
1448       /**
1449        * <code>required int32 dataChangeScope = 3;</code>
1450        */
1451       public Builder clearDataChangeScope() {
1452         bitField0_ = (bitField0_ & ~0x00000004);
1453         dataChangeScope_ = 0;
1454         onChanged();
1455         return this;
1456       }
1457
1458       // optional bool registerOnAllInstances = 4;
1459       private boolean registerOnAllInstances_ ;
1460       /**
1461        * <code>optional bool registerOnAllInstances = 4;</code>
1462        */
1463       public boolean hasRegisterOnAllInstances() {
1464         return ((bitField0_ & 0x00000008) == 0x00000008);
1465       }
1466       /**
1467        * <code>optional bool registerOnAllInstances = 4;</code>
1468        */
1469       public boolean getRegisterOnAllInstances() {
1470         return registerOnAllInstances_;
1471       }
1472       /**
1473        * <code>optional bool registerOnAllInstances = 4;</code>
1474        */
1475       public Builder setRegisterOnAllInstances(boolean value) {
1476         bitField0_ |= 0x00000008;
1477         registerOnAllInstances_ = value;
1478         onChanged();
1479         return this;
1480       }
1481       /**
1482        * <code>optional bool registerOnAllInstances = 4;</code>
1483        */
1484       public Builder clearRegisterOnAllInstances() {
1485         bitField0_ = (bitField0_ & ~0x00000008);
1486         registerOnAllInstances_ = false;
1487         onChanged();
1488         return this;
1489       }
1490
1491       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.RegisterChangeListener)
1492     }
1493
1494     static {
1495       defaultInstance = new RegisterChangeListener(true);
1496       defaultInstance.initFields();
1497     }
1498
1499     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.RegisterChangeListener)
1500   }
1501
1502   public interface RegisterChangeListenerReplyOrBuilder
1503       extends com.google.protobuf.MessageOrBuilder {
1504
1505     // required string listenerRegistrationPath = 1;
1506     /**
1507      * <code>required string listenerRegistrationPath = 1;</code>
1508      */
1509     boolean hasListenerRegistrationPath();
1510     /**
1511      * <code>required string listenerRegistrationPath = 1;</code>
1512      */
1513     java.lang.String getListenerRegistrationPath();
1514     /**
1515      * <code>required string listenerRegistrationPath = 1;</code>
1516      */
1517     com.google.protobuf.ByteString
1518         getListenerRegistrationPathBytes();
1519   }
1520   /**
1521    * Protobuf type {@code org.opendaylight.controller.mdsal.RegisterChangeListenerReply}
1522    *
1523    * <pre>
1524    **
1525    * This is the reply for the RegisterChangeListener message
1526    * It contains the listenerRegistration actor path
1527    * that can be used to unregister the listener
1528    * </pre>
1529    */
1530   public static final class RegisterChangeListenerReply extends
1531       com.google.protobuf.GeneratedMessage
1532       implements RegisterChangeListenerReplyOrBuilder {
1533     // Use RegisterChangeListenerReply.newBuilder() to construct.
1534     private RegisterChangeListenerReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1535       super(builder);
1536       this.unknownFields = builder.getUnknownFields();
1537     }
1538     private RegisterChangeListenerReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1539
1540     private static final RegisterChangeListenerReply defaultInstance;
1541     public static RegisterChangeListenerReply getDefaultInstance() {
1542       return defaultInstance;
1543     }
1544
1545     public RegisterChangeListenerReply getDefaultInstanceForType() {
1546       return defaultInstance;
1547     }
1548
1549     private final com.google.protobuf.UnknownFieldSet unknownFields;
1550     @java.lang.Override
1551     public final com.google.protobuf.UnknownFieldSet
1552         getUnknownFields() {
1553       return this.unknownFields;
1554     }
1555     private RegisterChangeListenerReply(
1556         com.google.protobuf.CodedInputStream input,
1557         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1558         throws com.google.protobuf.InvalidProtocolBufferException {
1559       initFields();
1560       int mutable_bitField0_ = 0;
1561       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1562           com.google.protobuf.UnknownFieldSet.newBuilder();
1563       try {
1564         boolean done = false;
1565         while (!done) {
1566           int tag = input.readTag();
1567           switch (tag) {
1568             case 0:
1569               done = true;
1570               break;
1571             default: {
1572               if (!parseUnknownField(input, unknownFields,
1573                                      extensionRegistry, tag)) {
1574                 done = true;
1575               }
1576               break;
1577             }
1578             case 10: {
1579               bitField0_ |= 0x00000001;
1580               listenerRegistrationPath_ = input.readBytes();
1581               break;
1582             }
1583           }
1584         }
1585       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1586         throw e.setUnfinishedMessage(this);
1587       } catch (java.io.IOException e) {
1588         throw new com.google.protobuf.InvalidProtocolBufferException(
1589             e.getMessage()).setUnfinishedMessage(this);
1590       } finally {
1591         this.unknownFields = unknownFields.build();
1592         makeExtensionsImmutable();
1593       }
1594     }
1595     public static final com.google.protobuf.Descriptors.Descriptor
1596         getDescriptor() {
1597       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_descriptor;
1598     }
1599
1600     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1601         internalGetFieldAccessorTable() {
1602       return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_fieldAccessorTable
1603           .ensureFieldAccessorsInitialized(
1604               org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.Builder.class);
1605     }
1606
1607     public static com.google.protobuf.Parser<RegisterChangeListenerReply> PARSER =
1608         new com.google.protobuf.AbstractParser<RegisterChangeListenerReply>() {
1609       public RegisterChangeListenerReply parsePartialFrom(
1610           com.google.protobuf.CodedInputStream input,
1611           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1612           throws com.google.protobuf.InvalidProtocolBufferException {
1613         return new RegisterChangeListenerReply(input, extensionRegistry);
1614       }
1615     };
1616
1617     @java.lang.Override
1618     public com.google.protobuf.Parser<RegisterChangeListenerReply> getParserForType() {
1619       return PARSER;
1620     }
1621
1622     private int bitField0_;
1623     // required string listenerRegistrationPath = 1;
1624     public static final int LISTENERREGISTRATIONPATH_FIELD_NUMBER = 1;
1625     private java.lang.Object listenerRegistrationPath_;
1626     /**
1627      * <code>required string listenerRegistrationPath = 1;</code>
1628      */
1629     public boolean hasListenerRegistrationPath() {
1630       return ((bitField0_ & 0x00000001) == 0x00000001);
1631     }
1632     /**
1633      * <code>required string listenerRegistrationPath = 1;</code>
1634      */
1635     public java.lang.String getListenerRegistrationPath() {
1636       java.lang.Object ref = listenerRegistrationPath_;
1637       if (ref instanceof java.lang.String) {
1638         return (java.lang.String) ref;
1639       } else {
1640         com.google.protobuf.ByteString bs =
1641             (com.google.protobuf.ByteString) ref;
1642         java.lang.String s = bs.toStringUtf8();
1643         if (bs.isValidUtf8()) {
1644           listenerRegistrationPath_ = s;
1645         }
1646         return s;
1647       }
1648     }
1649     /**
1650      * <code>required string listenerRegistrationPath = 1;</code>
1651      */
1652     public com.google.protobuf.ByteString
1653         getListenerRegistrationPathBytes() {
1654       java.lang.Object ref = listenerRegistrationPath_;
1655       if (ref instanceof java.lang.String) {
1656         com.google.protobuf.ByteString b =
1657             com.google.protobuf.ByteString.copyFromUtf8(
1658                 (java.lang.String) ref);
1659         listenerRegistrationPath_ = b;
1660         return b;
1661       } else {
1662         return (com.google.protobuf.ByteString) ref;
1663       }
1664     }
1665
1666     private void initFields() {
1667       listenerRegistrationPath_ = "";
1668     }
1669     private byte memoizedIsInitialized = -1;
1670     public final boolean isInitialized() {
1671       byte isInitialized = memoizedIsInitialized;
1672       if (isInitialized != -1) return isInitialized == 1;
1673
1674       if (!hasListenerRegistrationPath()) {
1675         memoizedIsInitialized = 0;
1676         return false;
1677       }
1678       memoizedIsInitialized = 1;
1679       return true;
1680     }
1681
1682     public void writeTo(com.google.protobuf.CodedOutputStream output)
1683                         throws java.io.IOException {
1684       getSerializedSize();
1685       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1686         output.writeBytes(1, getListenerRegistrationPathBytes());
1687       }
1688       getUnknownFields().writeTo(output);
1689     }
1690
1691     private int memoizedSerializedSize = -1;
1692     public int getSerializedSize() {
1693       int size = memoizedSerializedSize;
1694       if (size != -1) return size;
1695
1696       size = 0;
1697       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1698         size += com.google.protobuf.CodedOutputStream
1699           .computeBytesSize(1, getListenerRegistrationPathBytes());
1700       }
1701       size += getUnknownFields().getSerializedSize();
1702       memoizedSerializedSize = size;
1703       return size;
1704     }
1705
1706     private static final long serialVersionUID = 0L;
1707     @java.lang.Override
1708     protected java.lang.Object writeReplace()
1709         throws java.io.ObjectStreamException {
1710       return super.writeReplace();
1711     }
1712
1713     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(
1714         com.google.protobuf.ByteString data)
1715         throws com.google.protobuf.InvalidProtocolBufferException {
1716       return PARSER.parseFrom(data);
1717     }
1718     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(
1719         com.google.protobuf.ByteString data,
1720         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1721         throws com.google.protobuf.InvalidProtocolBufferException {
1722       return PARSER.parseFrom(data, extensionRegistry);
1723     }
1724     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(byte[] data)
1725         throws com.google.protobuf.InvalidProtocolBufferException {
1726       return PARSER.parseFrom(data);
1727     }
1728     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(
1729         byte[] data,
1730         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1731         throws com.google.protobuf.InvalidProtocolBufferException {
1732       return PARSER.parseFrom(data, extensionRegistry);
1733     }
1734     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(java.io.InputStream input)
1735         throws java.io.IOException {
1736       return PARSER.parseFrom(input);
1737     }
1738     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(
1739         java.io.InputStream input,
1740         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1741         throws java.io.IOException {
1742       return PARSER.parseFrom(input, extensionRegistry);
1743     }
1744     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseDelimitedFrom(java.io.InputStream input)
1745         throws java.io.IOException {
1746       return PARSER.parseDelimitedFrom(input);
1747     }
1748     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseDelimitedFrom(
1749         java.io.InputStream input,
1750         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1751         throws java.io.IOException {
1752       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1753     }
1754     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(
1755         com.google.protobuf.CodedInputStream input)
1756         throws java.io.IOException {
1757       return PARSER.parseFrom(input);
1758     }
1759     public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parseFrom(
1760         com.google.protobuf.CodedInputStream input,
1761         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1762         throws java.io.IOException {
1763       return PARSER.parseFrom(input, extensionRegistry);
1764     }
1765
1766     public static Builder newBuilder() { return Builder.create(); }
1767     public Builder newBuilderForType() { return newBuilder(); }
1768     public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply prototype) {
1769       return newBuilder().mergeFrom(prototype);
1770     }
1771     public Builder toBuilder() { return newBuilder(this); }
1772
1773     @java.lang.Override
1774     protected Builder newBuilderForType(
1775         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1776       Builder builder = new Builder(parent);
1777       return builder;
1778     }
1779     /**
1780      * Protobuf type {@code org.opendaylight.controller.mdsal.RegisterChangeListenerReply}
1781      *
1782      * <pre>
1783      **
1784      * This is the reply for the RegisterChangeListener message
1785      * It contains the listenerRegistration actor path
1786      * that can be used to unregister the listener
1787      * </pre>
1788      */
1789     public static final class Builder extends
1790         com.google.protobuf.GeneratedMessage.Builder<Builder>
1791        implements org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReplyOrBuilder {
1792       public static final com.google.protobuf.Descriptors.Descriptor
1793           getDescriptor() {
1794         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_descriptor;
1795       }
1796
1797       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1798           internalGetFieldAccessorTable() {
1799         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_fieldAccessorTable
1800             .ensureFieldAccessorsInitialized(
1801                 org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.Builder.class);
1802       }
1803
1804       // Construct using org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.newBuilder()
1805       private Builder() {
1806         maybeForceBuilderInitialization();
1807       }
1808
1809       private Builder(
1810           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1811         super(parent);
1812         maybeForceBuilderInitialization();
1813       }
1814       private void maybeForceBuilderInitialization() {
1815         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1816         }
1817       }
1818       private static Builder create() {
1819         return new Builder();
1820       }
1821
1822       public Builder clear() {
1823         super.clear();
1824         listenerRegistrationPath_ = "";
1825         bitField0_ = (bitField0_ & ~0x00000001);
1826         return this;
1827       }
1828
1829       public Builder clone() {
1830         return create().mergeFrom(buildPartial());
1831       }
1832
1833       public com.google.protobuf.Descriptors.Descriptor
1834           getDescriptorForType() {
1835         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_descriptor;
1836       }
1837
1838       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply getDefaultInstanceForType() {
1839         return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.getDefaultInstance();
1840       }
1841
1842       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply build() {
1843         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply result = buildPartial();
1844         if (!result.isInitialized()) {
1845           throw newUninitializedMessageException(result);
1846         }
1847         return result;
1848       }
1849
1850       public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply buildPartial() {
1851         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply result = new org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply(this);
1852         int from_bitField0_ = bitField0_;
1853         int to_bitField0_ = 0;
1854         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1855           to_bitField0_ |= 0x00000001;
1856         }
1857         result.listenerRegistrationPath_ = listenerRegistrationPath_;
1858         result.bitField0_ = to_bitField0_;
1859         onBuilt();
1860         return result;
1861       }
1862
1863       public Builder mergeFrom(com.google.protobuf.Message other) {
1864         if (other instanceof org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply) {
1865           return mergeFrom((org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply)other);
1866         } else {
1867           super.mergeFrom(other);
1868           return this;
1869         }
1870       }
1871
1872       public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply other) {
1873         if (other == org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply.getDefaultInstance()) return this;
1874         if (other.hasListenerRegistrationPath()) {
1875           bitField0_ |= 0x00000001;
1876           listenerRegistrationPath_ = other.listenerRegistrationPath_;
1877           onChanged();
1878         }
1879         this.mergeUnknownFields(other.getUnknownFields());
1880         return this;
1881       }
1882
1883       public final boolean isInitialized() {
1884         if (!hasListenerRegistrationPath()) {
1885
1886           return false;
1887         }
1888         return true;
1889       }
1890
1891       public Builder mergeFrom(
1892           com.google.protobuf.CodedInputStream input,
1893           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1894           throws java.io.IOException {
1895         org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply parsedMessage = null;
1896         try {
1897           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1898         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1899           parsedMessage = (org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.RegisterChangeListenerReply) e.getUnfinishedMessage();
1900           throw e;
1901         } finally {
1902           if (parsedMessage != null) {
1903             mergeFrom(parsedMessage);
1904           }
1905         }
1906         return this;
1907       }
1908       private int bitField0_;
1909
1910       // required string listenerRegistrationPath = 1;
1911       private java.lang.Object listenerRegistrationPath_ = "";
1912       /**
1913        * <code>required string listenerRegistrationPath = 1;</code>
1914        */
1915       public boolean hasListenerRegistrationPath() {
1916         return ((bitField0_ & 0x00000001) == 0x00000001);
1917       }
1918       /**
1919        * <code>required string listenerRegistrationPath = 1;</code>
1920        */
1921       public java.lang.String getListenerRegistrationPath() {
1922         java.lang.Object ref = listenerRegistrationPath_;
1923         if (!(ref instanceof java.lang.String)) {
1924           java.lang.String s = ((com.google.protobuf.ByteString) ref)
1925               .toStringUtf8();
1926           listenerRegistrationPath_ = s;
1927           return s;
1928         } else {
1929           return (java.lang.String) ref;
1930         }
1931       }
1932       /**
1933        * <code>required string listenerRegistrationPath = 1;</code>
1934        */
1935       public com.google.protobuf.ByteString
1936           getListenerRegistrationPathBytes() {
1937         java.lang.Object ref = listenerRegistrationPath_;
1938         if (ref instanceof String) {
1939           com.google.protobuf.ByteString b =
1940               com.google.protobuf.ByteString.copyFromUtf8(
1941                   (java.lang.String) ref);
1942           listenerRegistrationPath_ = b;
1943           return b;
1944         } else {
1945           return (com.google.protobuf.ByteString) ref;
1946         }
1947       }
1948       /**
1949        * <code>required string listenerRegistrationPath = 1;</code>
1950        */
1951       public Builder setListenerRegistrationPath(
1952           java.lang.String value) {
1953         if (value == null) {
1954     throw new NullPointerException();
1955   }
1956   bitField0_ |= 0x00000001;
1957         listenerRegistrationPath_ = value;
1958         onChanged();
1959         return this;
1960       }
1961       /**
1962        * <code>required string listenerRegistrationPath = 1;</code>
1963        */
1964       public Builder clearListenerRegistrationPath() {
1965         bitField0_ = (bitField0_ & ~0x00000001);
1966         listenerRegistrationPath_ = getDefaultInstance().getListenerRegistrationPath();
1967         onChanged();
1968         return this;
1969       }
1970       /**
1971        * <code>required string listenerRegistrationPath = 1;</code>
1972        */
1973       public Builder setListenerRegistrationPathBytes(
1974           com.google.protobuf.ByteString value) {
1975         if (value == null) {
1976     throw new NullPointerException();
1977   }
1978   bitField0_ |= 0x00000001;
1979         listenerRegistrationPath_ = value;
1980         onChanged();
1981         return this;
1982       }
1983
1984       // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.RegisterChangeListenerReply)
1985     }
1986
1987     static {
1988       defaultInstance = new RegisterChangeListenerReply(true);
1989       defaultInstance.initFields();
1990     }
1991
1992     // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.RegisterChangeListenerReply)
1993   }
1994
1995   private static com.google.protobuf.Descriptors.Descriptor
1996     internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_descriptor;
1997   private static
1998     com.google.protobuf.GeneratedMessage.FieldAccessorTable
1999       internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_fieldAccessorTable;
2000   private static com.google.protobuf.Descriptors.Descriptor
2001     internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_descriptor;
2002   private static
2003     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2004       internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_fieldAccessorTable;
2005   private static com.google.protobuf.Descriptors.Descriptor
2006     internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_descriptor;
2007   private static
2008     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2009       internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_fieldAccessorTable;
2010   private static com.google.protobuf.Descriptors.Descriptor
2011     internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_descriptor;
2012   private static
2013     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2014       internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_fieldAccessorTable;
2015
2016   public static com.google.protobuf.Descriptors.FileDescriptor
2017       getDescriptor() {
2018     return descriptor;
2019   }
2020   private static com.google.protobuf.Descriptors.FileDescriptor
2021       descriptor;
2022   static {
2023     java.lang.String[] descriptorData = {
2024       "\n\032ListenerRegistration.proto\022!org.openda" +
2025       "ylight.controller.mdsal\032\014Common.proto\"%\n" +
2026       "#CloseDataChangeListenerRegistration\"*\n(" +
2027       "CloseDataChangeListenerRegistrationReply" +
2028       "\"\315\001\n\026RegisterChangeListener\022U\n\026instanceI" +
2029       "dentifierPath\030\001 \002(\01325.org.opendaylight.c" +
2030       "ontroller.mdsal.InstanceIdentifier\022#\n\033da" +
2031       "taChangeListenerActorPath\030\002 \002(\t\022\027\n\017dataC" +
2032       "hangeScope\030\003 \002(\005\022\036\n\026registerOnAllInstanc" +
2033       "es\030\004 \001(\010\"?\n\033RegisterChangeListenerReply\022",
2034       " \n\030listenerRegistrationPath\030\001 \002(\tB[\n;org" +
2035       ".opendaylight.controller.protobuff.messa" +
2036       "ges.registrationB\034ListenerRegistrationMe" +
2037       "ssages"
2038     };
2039     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
2040       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
2041         public com.google.protobuf.ExtensionRegistry assignDescriptors(
2042             com.google.protobuf.Descriptors.FileDescriptor root) {
2043           descriptor = root;
2044           internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_descriptor =
2045             getDescriptor().getMessageTypes().get(0);
2046           internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_fieldAccessorTable = new
2047             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2048               internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistration_descriptor,
2049               new java.lang.String[] { });
2050           internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_descriptor =
2051             getDescriptor().getMessageTypes().get(1);
2052           internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_fieldAccessorTable = new
2053             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2054               internal_static_org_opendaylight_controller_mdsal_CloseDataChangeListenerRegistrationReply_descriptor,
2055               new java.lang.String[] { });
2056           internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_descriptor =
2057             getDescriptor().getMessageTypes().get(2);
2058           internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_fieldAccessorTable = new
2059             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2060               internal_static_org_opendaylight_controller_mdsal_RegisterChangeListener_descriptor,
2061               new java.lang.String[] { "InstanceIdentifierPath", "DataChangeListenerActorPath", "DataChangeScope", "RegisterOnAllInstances", });
2062           internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_descriptor =
2063             getDescriptor().getMessageTypes().get(3);
2064           internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_fieldAccessorTable = new
2065             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2066               internal_static_org_opendaylight_controller_mdsal_RegisterChangeListenerReply_descriptor,
2067               new java.lang.String[] { "ListenerRegistrationPath", });
2068           return null;
2069         }
2070       };
2071     com.google.protobuf.Descriptors.FileDescriptor
2072       .internalBuildGeneratedFileFrom(descriptorData,
2073         new com.google.protobuf.Descriptors.FileDescriptor[] {
2074           org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.getDescriptor(),
2075         }, assigner);
2076   }
2077
2078   // @@protoc_insertion_point(outer_class_scope)
2079 }