gen/java/com/openxc/BinaryMessages.java

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: openxc.proto
   3
   4 package com.openxc;
   5
   6 public final class BinaryMessages {
   7   private BinaryMessages() {}
   8   public static void registerAllExtensions(
   9       com.google.protobuf.ExtensionRegistry registry) {
  10   }
  11   public interface VehicleMessageOrBuilder
  12       extends com.google.protobuf.MessageOrBuilder {
  13
  14     // optional .openxc.VehicleMessage.Type type = 1;
  15     /**
  16      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
  17      */
  18     boolean hasType();
  19     /**
  20      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
  21      */
  22     com.openxc.BinaryMessages.VehicleMessage.Type getType();
  23
  24     // optional .openxc.CanMessage can_message = 2;
  25     /**
  26      * <code>optional .openxc.CanMessage can_message = 2;</code>
  27      */
  28     boolean hasCanMessage();
  29     /**
  30      * <code>optional .openxc.CanMessage can_message = 2;</code>
  31      */
  32     com.openxc.BinaryMessages.CanMessage getCanMessage();
  33     /**
  34      * <code>optional .openxc.CanMessage can_message = 2;</code>
  35      */
  36     com.openxc.BinaryMessages.CanMessageOrBuilder getCanMessageOrBuilder();
  37
  38     // optional .openxc.SimpleMessage simple_message = 3;
  39     /**
  40      * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
  41      */
  42     boolean hasSimpleMessage();
  43     /**
  44      * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
  45      */
  46     com.openxc.BinaryMessages.SimpleMessage getSimpleMessage();
  47     /**
  48      * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
  49      */
  50     com.openxc.BinaryMessages.SimpleMessageOrBuilder getSimpleMessageOrBuilder();
  51
  52     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
  53     /**
  54      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  55      */
  56     boolean hasDiagnosticResponse();
  57     /**
  58      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  59      */
  60     com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse();
  61     /**
  62      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  63      */
  64     com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder();
  65
  66     // optional .openxc.ControlCommand control_command = 5;
  67     /**
  68      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  69      */
  70     boolean hasControlCommand();
  71     /**
  72      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  73      */
  74     com.openxc.BinaryMessages.ControlCommand getControlCommand();
  75     /**
  76      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  77      */
  78     com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder();
  79
  80     // optional .openxc.CommandResponse command_response = 6;
  81     /**
  82      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  83      */
  84     boolean hasCommandResponse();
  85     /**
  86      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  87      */
  88     com.openxc.BinaryMessages.CommandResponse getCommandResponse();
  89     /**
  90      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  91      */
  92     com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder();
  93
  94     // optional uint64 timestamp = 7;
  95     /**
  96      * <code>optional uint64 timestamp = 7;</code>
  97      */
  98     boolean hasTimestamp();
  99     /**
 100      * <code>optional uint64 timestamp = 7;</code>
 101      */
 102     long getTimestamp();
 103   }
 104   /**
 105    * Protobuf type {@code openxc.VehicleMessage}
 106    */
 107   public static final class VehicleMessage extends
 108       com.google.protobuf.GeneratedMessage
 109       implements VehicleMessageOrBuilder {
 110     // Use VehicleMessage.newBuilder() to construct.
 111     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 112       super(builder);
 113       this.unknownFields = builder.getUnknownFields();
 114     }
 115     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 116
 117     private static final VehicleMessage defaultInstance;
 118     public static VehicleMessage getDefaultInstance() {
 119       return defaultInstance;
 120     }
 121
 122     public VehicleMessage getDefaultInstanceForType() {
 123       return defaultInstance;
 124     }
 125
 126     private final com.google.protobuf.UnknownFieldSet unknownFields;
 127     @java.lang.Override
 128     public final com.google.protobuf.UnknownFieldSet
 129         getUnknownFields() {
 130       return this.unknownFields;
 131     }
 132     private VehicleMessage(
 133         com.google.protobuf.CodedInputStream input,
 134         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 135         throws com.google.protobuf.InvalidProtocolBufferException {
 136       initFields();
 137       int mutable_bitField0_ = 0;
 138       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 139           com.google.protobuf.UnknownFieldSet.newBuilder();
 140       try {
 141         boolean done = false;
 142         while (!done) {
 143           int tag = input.readTag();
 144           switch (tag) {
 145             case 0:
 146               done = true;
 147               break;
 148             default: {
 149               if (!parseUnknownField(input, unknownFields,
 150                                      extensionRegistry, tag)) {
 151                 done = true;
 152               }
 153               break;
 154             }
 155             case 8: {
 156               int rawValue = input.readEnum();
 157               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 158               if (value == null) {
 159                 unknownFields.mergeVarintField(1, rawValue);
 160               } else {
 161                 bitField0_ |= 0x00000001;
 162                 type_ = value;
 163               }
 164               break;
 165             }
 166             case 18: {
 167               com.openxc.BinaryMessages.CanMessage.Builder subBuilder = null;
 168               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 169                 subBuilder = canMessage_.toBuilder();
 170               }
 171               canMessage_ = input.readMessage(com.openxc.BinaryMessages.CanMessage.PARSER, extensionRegistry);
 172               if (subBuilder != null) {
 173                 subBuilder.mergeFrom(canMessage_);
 174                 canMessage_ = subBuilder.buildPartial();
 175               }
 176               bitField0_ |= 0x00000002;
 177               break;
 178             }
 179             case 26: {
 180               com.openxc.BinaryMessages.SimpleMessage.Builder subBuilder = null;
 181               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 182                 subBuilder = simpleMessage_.toBuilder();
 183               }
 184               simpleMessage_ = input.readMessage(com.openxc.BinaryMessages.SimpleMessage.PARSER, extensionRegistry);
 185               if (subBuilder != null) {
 186                 subBuilder.mergeFrom(simpleMessage_);
 187                 simpleMessage_ = subBuilder.buildPartial();
 188               }
 189               bitField0_ |= 0x00000004;
 190               break;
 191             }
 192             case 34: {
 193               com.openxc.BinaryMessages.DiagnosticResponse.Builder subBuilder = null;
 194               if (((bitField0_ & 0x00000008) == 0x00000008)) {
 195                 subBuilder = diagnosticResponse_.toBuilder();
 196               }
 197               diagnosticResponse_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticResponse.PARSER, extensionRegistry);
 198               if (subBuilder != null) {
 199                 subBuilder.mergeFrom(diagnosticResponse_);
 200                 diagnosticResponse_ = subBuilder.buildPartial();
 201               }
 202               bitField0_ |= 0x00000008;
 203               break;
 204             }
 205             case 42: {
 206               com.openxc.BinaryMessages.ControlCommand.Builder subBuilder = null;
 207               if (((bitField0_ & 0x00000010) == 0x00000010)) {
 208                 subBuilder = controlCommand_.toBuilder();
 209               }
 210               controlCommand_ = input.readMessage(com.openxc.BinaryMessages.ControlCommand.PARSER, extensionRegistry);
 211               if (subBuilder != null) {
 212                 subBuilder.mergeFrom(controlCommand_);
 213                 controlCommand_ = subBuilder.buildPartial();
 214               }
 215               bitField0_ |= 0x00000010;
 216               break;
 217             }
 218             case 50: {
 219               com.openxc.BinaryMessages.CommandResponse.Builder subBuilder = null;
 220               if (((bitField0_ & 0x00000020) == 0x00000020)) {
 221                 subBuilder = commandResponse_.toBuilder();
 222               }
 223               commandResponse_ = input.readMessage(com.openxc.BinaryMessages.CommandResponse.PARSER, extensionRegistry);
 224               if (subBuilder != null) {
 225                 subBuilder.mergeFrom(commandResponse_);
 226                 commandResponse_ = subBuilder.buildPartial();
 227               }
 228               bitField0_ |= 0x00000020;
 229               break;
 230             }
 231             case 56: {
 232               bitField0_ |= 0x00000040;
 233               timestamp_ = input.readUInt64();
 234               break;
 235             }
 236           }
 237         }
 238       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 239         throw e.setUnfinishedMessage(this);
 240       } catch (java.io.IOException e) {
 241         throw new com.google.protobuf.InvalidProtocolBufferException(
 242             e.getMessage()).setUnfinishedMessage(this);
 243       } finally {
 244         this.unknownFields = unknownFields.build();
 245         makeExtensionsImmutable();
 246       }
 247     }
 248     public static final com.google.protobuf.Descriptors.Descriptor
 249         getDescriptor() {
 250       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 251     }
 252
 253     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 254         internalGetFieldAccessorTable() {
 255       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 256           .ensureFieldAccessorsInitialized(
 257               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 258     }
 259
 260     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 261         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 262       public VehicleMessage parsePartialFrom(
 263           com.google.protobuf.CodedInputStream input,
 264           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 265           throws com.google.protobuf.InvalidProtocolBufferException {
 266         return new VehicleMessage(input, extensionRegistry);
 267       }
 268     };
 269
 270     @java.lang.Override
 271     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 272       return PARSER;
 273     }
 274
 275     /**
 276      * Protobuf enum {@code openxc.VehicleMessage.Type}
 277      */
 278     public enum Type
 279         implements com.google.protobuf.ProtocolMessageEnum {
 280       /**
 281        * <code>CAN = 1;</code>
 282        */
 283       CAN(0, 1),
 284       /**
 285        * <code>SIMPLE = 2;</code>
 286        */
 287       SIMPLE(1, 2),
 288       /**
 289        * <code>DIAGNOSTIC = 3;</code>
 290        */
 291       DIAGNOSTIC(2, 3),
 292       /**
 293        * <code>CONTROL_COMMAND = 4;</code>
 294        */
 295       CONTROL_COMMAND(3, 4),
 296       /**
 297        * <code>COMMAND_RESPONSE = 5;</code>
 298        */
 299       COMMAND_RESPONSE(4, 5),
 300       ;
 301
 302       /**
 303        * <code>CAN = 1;</code>
 304        */
 305       public static final int CAN_VALUE = 1;
 306       /**
 307        * <code>SIMPLE = 2;</code>
 308        */
 309       public static final int SIMPLE_VALUE = 2;
 310       /**
 311        * <code>DIAGNOSTIC = 3;</code>
 312        */
 313       public static final int DIAGNOSTIC_VALUE = 3;
 314       /**
 315        * <code>CONTROL_COMMAND = 4;</code>
 316        */
 317       public static final int CONTROL_COMMAND_VALUE = 4;
 318       /**
 319        * <code>COMMAND_RESPONSE = 5;</code>
 320        */
 321       public static final int COMMAND_RESPONSE_VALUE = 5;
 322
 323
 324       public final int getNumber() { return value; }
 325
 326       public static Type valueOf(int value) {
 327         switch (value) {
 328           case 1: return CAN;
 329           case 2: return SIMPLE;
 330           case 3: return DIAGNOSTIC;
 331           case 4: return CONTROL_COMMAND;
 332           case 5: return COMMAND_RESPONSE;
 333           default: return null;
 334         }
 335       }
 336
 337       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 338           internalGetValueMap() {
 339         return internalValueMap;
 340       }
 341       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 342           internalValueMap =
 343             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 344               public Type findValueByNumber(int number) {
 345                 return Type.valueOf(number);
 346               }
 347             };
 348
 349       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 350           getValueDescriptor() {
 351         return getDescriptor().getValues().get(index);
 352       }
 353       public final com.google.protobuf.Descriptors.EnumDescriptor
 354           getDescriptorForType() {
 355         return getDescriptor();
 356       }
 357       public static final com.google.protobuf.Descriptors.EnumDescriptor
 358           getDescriptor() {
 359         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 360       }
 361
 362       private static final Type[] VALUES = values();
 363
 364       public static Type valueOf(
 365           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 366         if (desc.getType() != getDescriptor()) {
 367           throw new java.lang.IllegalArgumentException(
 368             "EnumValueDescriptor is not for this type.");
 369         }
 370         return VALUES[desc.getIndex()];
 371       }
 372
 373       private final int index;
 374       private final int value;
 375
 376       private Type(int index, int value) {
 377         this.index = index;
 378         this.value = value;
 379       }
 380
 381       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 382     }
 383
 384     private int bitField0_;
 385     // optional .openxc.VehicleMessage.Type type = 1;
 386     public static final int TYPE_FIELD_NUMBER = 1;
 387     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 388     /**
 389      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 390      */
 391     public boolean hasType() {
 392       return ((bitField0_ & 0x00000001) == 0x00000001);
 393     }
 394     /**
 395      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 396      */
 397     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 398       return type_;
 399     }
 400
 401     // optional .openxc.CanMessage can_message = 2;
 402     public static final int CAN_MESSAGE_FIELD_NUMBER = 2;
 403     private com.openxc.BinaryMessages.CanMessage canMessage_;
 404     /**
 405      * <code>optional .openxc.CanMessage can_message = 2;</code>
 406      */
 407     public boolean hasCanMessage() {
 408       return ((bitField0_ & 0x00000002) == 0x00000002);
 409     }
 410     /**
 411      * <code>optional .openxc.CanMessage can_message = 2;</code>
 412      */
 413     public com.openxc.BinaryMessages.CanMessage getCanMessage() {
 414       return canMessage_;
 415     }
 416     /**
 417      * <code>optional .openxc.CanMessage can_message = 2;</code>
 418      */
 419     public com.openxc.BinaryMessages.CanMessageOrBuilder getCanMessageOrBuilder() {
 420       return canMessage_;
 421     }
 422
 423     // optional .openxc.SimpleMessage simple_message = 3;
 424     public static final int SIMPLE_MESSAGE_FIELD_NUMBER = 3;
 425     private com.openxc.BinaryMessages.SimpleMessage simpleMessage_;
 426     /**
 427      * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
 428      */
 429     public boolean hasSimpleMessage() {
 430       return ((bitField0_ & 0x00000004) == 0x00000004);
 431     }
 432     /**
 433      * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
 434      */
 435     public com.openxc.BinaryMessages.SimpleMessage getSimpleMessage() {
 436       return simpleMessage_;
 437     }
 438     /**
 439      * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
 440      */
 441     public com.openxc.BinaryMessages.SimpleMessageOrBuilder getSimpleMessageOrBuilder() {
 442       return simpleMessage_;
 443     }
 444
 445     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
 446     public static final int DIAGNOSTIC_RESPONSE_FIELD_NUMBER = 4;
 447     private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_;
 448     /**
 449      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 450      */
 451     public boolean hasDiagnosticResponse() {
 452       return ((bitField0_ & 0x00000008) == 0x00000008);
 453     }
 454     /**
 455      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 456      */
 457     public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
 458       return diagnosticResponse_;
 459     }
 460     /**
 461      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 462      */
 463     public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
 464       return diagnosticResponse_;
 465     }
 466
 467     // optional .openxc.ControlCommand control_command = 5;
 468     public static final int CONTROL_COMMAND_FIELD_NUMBER = 5;
 469     private com.openxc.BinaryMessages.ControlCommand controlCommand_;
 470     /**
 471      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 472      */
 473     public boolean hasControlCommand() {
 474       return ((bitField0_ & 0x00000010) == 0x00000010);
 475     }
 476     /**
 477      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 478      */
 479     public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
 480       return controlCommand_;
 481     }
 482     /**
 483      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 484      */
 485     public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
 486       return controlCommand_;
 487     }
 488
 489     // optional .openxc.CommandResponse command_response = 6;
 490     public static final int COMMAND_RESPONSE_FIELD_NUMBER = 6;
 491     private com.openxc.BinaryMessages.CommandResponse commandResponse_;
 492     /**
 493      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 494      */
 495     public boolean hasCommandResponse() {
 496       return ((bitField0_ & 0x00000020) == 0x00000020);
 497     }
 498     /**
 499      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 500      */
 501     public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
 502       return commandResponse_;
 503     }
 504     /**
 505      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 506      */
 507     public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
 508       return commandResponse_;
 509     }
 510
 511     // optional uint64 timestamp = 7;
 512     public static final int TIMESTAMP_FIELD_NUMBER = 7;
 513     private long timestamp_;
 514     /**
 515      * <code>optional uint64 timestamp = 7;</code>
 516      */
 517     public boolean hasTimestamp() {
 518       return ((bitField0_ & 0x00000040) == 0x00000040);
 519     }
 520     /**
 521      * <code>optional uint64 timestamp = 7;</code>
 522      */
 523     public long getTimestamp() {
 524       return timestamp_;
 525     }
 526
 527     private void initFields() {
 528       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 529       canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 530       simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
 531       diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 532       controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 533       commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 534       timestamp_ = 0L;
 535     }
 536     private byte memoizedIsInitialized = -1;
 537     public final boolean isInitialized() {
 538       byte isInitialized = memoizedIsInitialized;
 539       if (isInitialized != -1) return isInitialized == 1;
 540
 541       memoizedIsInitialized = 1;
 542       return true;
 543     }
 544
 545     public void writeTo(com.google.protobuf.CodedOutputStream output)
 546                         throws java.io.IOException {
 547       getSerializedSize();
 548       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 549         output.writeEnum(1, type_.getNumber());
 550       }
 551       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 552         output.writeMessage(2, canMessage_);
 553       }
 554       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 555         output.writeMessage(3, simpleMessage_);
 556       }
 557       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 558         output.writeMessage(4, diagnosticResponse_);
 559       }
 560       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 561         output.writeMessage(5, controlCommand_);
 562       }
 563       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 564         output.writeMessage(6, commandResponse_);
 565       }
 566       if (((bitField0_ & 0x00000040) == 0x00000040)) {
 567         output.writeUInt64(7, timestamp_);
 568       }
 569       getUnknownFields().writeTo(output);
 570     }
 571
 572     private int memoizedSerializedSize = -1;
 573     public int getSerializedSize() {
 574       int size = memoizedSerializedSize;
 575       if (size != -1) return size;
 576
 577       size = 0;
 578       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 579         size += com.google.protobuf.CodedOutputStream
 580           .computeEnumSize(1, type_.getNumber());
 581       }
 582       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 583         size += com.google.protobuf.CodedOutputStream
 584           .computeMessageSize(2, canMessage_);
 585       }
 586       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 587         size += com.google.protobuf.CodedOutputStream
 588           .computeMessageSize(3, simpleMessage_);
 589       }
 590       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 591         size += com.google.protobuf.CodedOutputStream
 592           .computeMessageSize(4, diagnosticResponse_);
 593       }
 594       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 595         size += com.google.protobuf.CodedOutputStream
 596           .computeMessageSize(5, controlCommand_);
 597       }
 598       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 599         size += com.google.protobuf.CodedOutputStream
 600           .computeMessageSize(6, commandResponse_);
 601       }
 602       if (((bitField0_ & 0x00000040) == 0x00000040)) {
 603         size += com.google.protobuf.CodedOutputStream
 604           .computeUInt64Size(7, timestamp_);
 605       }
 606       size += getUnknownFields().getSerializedSize();
 607       memoizedSerializedSize = size;
 608       return size;
 609     }
 610
 611     private static final long serialVersionUID = 0L;
 612     @java.lang.Override
 613     protected java.lang.Object writeReplace()
 614         throws java.io.ObjectStreamException {
 615       return super.writeReplace();
 616     }
 617
 618     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 619         com.google.protobuf.ByteString data)
 620         throws com.google.protobuf.InvalidProtocolBufferException {
 621       return PARSER.parseFrom(data);
 622     }
 623     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 624         com.google.protobuf.ByteString data,
 625         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 626         throws com.google.protobuf.InvalidProtocolBufferException {
 627       return PARSER.parseFrom(data, extensionRegistry);
 628     }
 629     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 630         throws com.google.protobuf.InvalidProtocolBufferException {
 631       return PARSER.parseFrom(data);
 632     }
 633     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 634         byte[] data,
 635         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 636         throws com.google.protobuf.InvalidProtocolBufferException {
 637       return PARSER.parseFrom(data, extensionRegistry);
 638     }
 639     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 640         throws java.io.IOException {
 641       return PARSER.parseFrom(input);
 642     }
 643     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 644         java.io.InputStream input,
 645         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 646         throws java.io.IOException {
 647       return PARSER.parseFrom(input, extensionRegistry);
 648     }
 649     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 650         throws java.io.IOException {
 651       return PARSER.parseDelimitedFrom(input);
 652     }
 653     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 654         java.io.InputStream input,
 655         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 656         throws java.io.IOException {
 657       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 658     }
 659     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 660         com.google.protobuf.CodedInputStream input)
 661         throws java.io.IOException {
 662       return PARSER.parseFrom(input);
 663     }
 664     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 665         com.google.protobuf.CodedInputStream input,
 666         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 667         throws java.io.IOException {
 668       return PARSER.parseFrom(input, extensionRegistry);
 669     }
 670
 671     public static Builder newBuilder() { return Builder.create(); }
 672     public Builder newBuilderForType() { return newBuilder(); }
 673     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 674       return newBuilder().mergeFrom(prototype);
 675     }
 676     public Builder toBuilder() { return newBuilder(this); }
 677
 678     @java.lang.Override
 679     protected Builder newBuilderForType(
 680         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 681       Builder builder = new Builder(parent);
 682       return builder;
 683     }
 684     /**
 685      * Protobuf type {@code openxc.VehicleMessage}
 686      */
 687     public static final class Builder extends
 688         com.google.protobuf.GeneratedMessage.Builder<Builder>
 689        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 690       public static final com.google.protobuf.Descriptors.Descriptor
 691           getDescriptor() {
 692         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 693       }
 694
 695       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 696           internalGetFieldAccessorTable() {
 697         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 698             .ensureFieldAccessorsInitialized(
 699                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 700       }
 701
 702       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 703       private Builder() {
 704         maybeForceBuilderInitialization();
 705       }
 706
 707       private Builder(
 708           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 709         super(parent);
 710         maybeForceBuilderInitialization();
 711       }
 712       private void maybeForceBuilderInitialization() {
 713         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 714           getCanMessageFieldBuilder();
 715           getSimpleMessageFieldBuilder();
 716           getDiagnosticResponseFieldBuilder();
 717           getControlCommandFieldBuilder();
 718           getCommandResponseFieldBuilder();
 719         }
 720       }
 721       private static Builder create() {
 722         return new Builder();
 723       }
 724
 725       public Builder clear() {
 726         super.clear();
 727         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 728         bitField0_ = (bitField0_ & ~0x00000001);
 729         if (canMessageBuilder_ == null) {
 730           canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 731         } else {
 732           canMessageBuilder_.clear();
 733         }
 734         bitField0_ = (bitField0_ & ~0x00000002);
 735         if (simpleMessageBuilder_ == null) {
 736           simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
 737         } else {
 738           simpleMessageBuilder_.clear();
 739         }
 740         bitField0_ = (bitField0_ & ~0x00000004);
 741         if (diagnosticResponseBuilder_ == null) {
 742           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 743         } else {
 744           diagnosticResponseBuilder_.clear();
 745         }
 746         bitField0_ = (bitField0_ & ~0x00000008);
 747         if (controlCommandBuilder_ == null) {
 748           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 749         } else {
 750           controlCommandBuilder_.clear();
 751         }
 752         bitField0_ = (bitField0_ & ~0x00000010);
 753         if (commandResponseBuilder_ == null) {
 754           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 755         } else {
 756           commandResponseBuilder_.clear();
 757         }
 758         bitField0_ = (bitField0_ & ~0x00000020);
 759         timestamp_ = 0L;
 760         bitField0_ = (bitField0_ & ~0x00000040);
 761         return this;
 762       }
 763
 764       public Builder clone() {
 765         return create().mergeFrom(buildPartial());
 766       }
 767
 768       public com.google.protobuf.Descriptors.Descriptor
 769           getDescriptorForType() {
 770         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 771       }
 772
 773       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 774         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 775       }
 776
 777       public com.openxc.BinaryMessages.VehicleMessage build() {
 778         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 779         if (!result.isInitialized()) {
 780           throw newUninitializedMessageException(result);
 781         }
 782         return result;
 783       }
 784
 785       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 786         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 787         int from_bitField0_ = bitField0_;
 788         int to_bitField0_ = 0;
 789         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 790           to_bitField0_ |= 0x00000001;
 791         }
 792         result.type_ = type_;
 793         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 794           to_bitField0_ |= 0x00000002;
 795         }
 796         if (canMessageBuilder_ == null) {
 797           result.canMessage_ = canMessage_;
 798         } else {
 799           result.canMessage_ = canMessageBuilder_.build();
 800         }
 801         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 802           to_bitField0_ |= 0x00000004;
 803         }
 804         if (simpleMessageBuilder_ == null) {
 805           result.simpleMessage_ = simpleMessage_;
 806         } else {
 807           result.simpleMessage_ = simpleMessageBuilder_.build();
 808         }
 809         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 810           to_bitField0_ |= 0x00000008;
 811         }
 812         if (diagnosticResponseBuilder_ == null) {
 813           result.diagnosticResponse_ = diagnosticResponse_;
 814         } else {
 815           result.diagnosticResponse_ = diagnosticResponseBuilder_.build();
 816         }
 817         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
 818           to_bitField0_ |= 0x00000010;
 819         }
 820         if (controlCommandBuilder_ == null) {
 821           result.controlCommand_ = controlCommand_;
 822         } else {
 823           result.controlCommand_ = controlCommandBuilder_.build();
 824         }
 825         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
 826           to_bitField0_ |= 0x00000020;
 827         }
 828         if (commandResponseBuilder_ == null) {
 829           result.commandResponse_ = commandResponse_;
 830         } else {
 831           result.commandResponse_ = commandResponseBuilder_.build();
 832         }
 833         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
 834           to_bitField0_ |= 0x00000040;
 835         }
 836         result.timestamp_ = timestamp_;
 837         result.bitField0_ = to_bitField0_;
 838         onBuilt();
 839         return result;
 840       }
 841
 842       public Builder mergeFrom(com.google.protobuf.Message other) {
 843         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 844           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 845         } else {
 846           super.mergeFrom(other);
 847           return this;
 848         }
 849       }
 850
 851       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 852         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 853         if (other.hasType()) {
 854           setType(other.getType());
 855         }
 856         if (other.hasCanMessage()) {
 857           mergeCanMessage(other.getCanMessage());
 858         }
 859         if (other.hasSimpleMessage()) {
 860           mergeSimpleMessage(other.getSimpleMessage());
 861         }
 862         if (other.hasDiagnosticResponse()) {
 863           mergeDiagnosticResponse(other.getDiagnosticResponse());
 864         }
 865         if (other.hasControlCommand()) {
 866           mergeControlCommand(other.getControlCommand());
 867         }
 868         if (other.hasCommandResponse()) {
 869           mergeCommandResponse(other.getCommandResponse());
 870         }
 871         if (other.hasTimestamp()) {
 872           setTimestamp(other.getTimestamp());
 873         }
 874         this.mergeUnknownFields(other.getUnknownFields());
 875         return this;
 876       }
 877
 878       public final boolean isInitialized() {
 879         return true;
 880       }
 881
 882       public Builder mergeFrom(
 883           com.google.protobuf.CodedInputStream input,
 884           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 885           throws java.io.IOException {
 886         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
 887         try {
 888           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 889         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 890           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
 891           throw e;
 892         } finally {
 893           if (parsedMessage != null) {
 894             mergeFrom(parsedMessage);
 895           }
 896         }
 897         return this;
 898       }
 899       private int bitField0_;
 900
 901       // optional .openxc.VehicleMessage.Type type = 1;
 902       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 903       /**
 904        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 905        */
 906       public boolean hasType() {
 907         return ((bitField0_ & 0x00000001) == 0x00000001);
 908       }
 909       /**
 910        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 911        */
 912       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 913         return type_;
 914       }
 915       /**
 916        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 917        */
 918       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 919         if (value == null) {
 920           throw new NullPointerException();
 921         }
 922         bitField0_ |= 0x00000001;
 923         type_ = value;
 924         onChanged();
 925         return this;
 926       }
 927       /**
 928        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 929        */
 930       public Builder clearType() {
 931         bitField0_ = (bitField0_ & ~0x00000001);
 932         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.CAN;
 933         onChanged();
 934         return this;
 935       }
 936
 937       // optional .openxc.CanMessage can_message = 2;
 938       private com.openxc.BinaryMessages.CanMessage canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
 939       private com.google.protobuf.SingleFieldBuilder<
 940           com.openxc.BinaryMessages.CanMessage, com.openxc.BinaryMessages.CanMessage.Builder, com.openxc.BinaryMessages.CanMessageOrBuilder> canMessageBuilder_;
 941       /**
 942        * <code>optional .openxc.CanMessage can_message = 2;</code>
 943        */
 944       public boolean hasCanMessage() {
 945         return ((bitField0_ & 0x00000002) == 0x00000002);
 946       }
 947       /**
 948        * <code>optional .openxc.CanMessage can_message = 2;</code>
 949        */
 950       public com.openxc.BinaryMessages.CanMessage getCanMessage() {
 951         if (canMessageBuilder_ == null) {
 952           return canMessage_;
 953         } else {
 954           return canMessageBuilder_.getMessage();
 955         }
 956       }
 957       /**
 958        * <code>optional .openxc.CanMessage can_message = 2;</code>
 959        */
 960       public Builder setCanMessage(com.openxc.BinaryMessages.CanMessage value) {
 961         if (canMessageBuilder_ == null) {
 962           if (value == null) {
 963             throw new NullPointerException();
 964           }
 965           canMessage_ = value;
 966           onChanged();
 967         } else {
 968           canMessageBuilder_.setMessage(value);
 969         }
 970         bitField0_ |= 0x00000002;
 971         return this;
 972       }
 973       /**
 974        * <code>optional .openxc.CanMessage can_message = 2;</code>
 975        */
 976       public Builder setCanMessage(
 977           com.openxc.BinaryMessages.CanMessage.Builder builderForValue) {
 978         if (canMessageBuilder_ == null) {
 979           canMessage_ = builderForValue.build();
 980           onChanged();
 981         } else {
 982           canMessageBuilder_.setMessage(builderForValue.build());
 983         }
 984         bitField0_ |= 0x00000002;
 985         return this;
 986       }
 987       /**
 988        * <code>optional .openxc.CanMessage can_message = 2;</code>
 989        */
 990       public Builder mergeCanMessage(com.openxc.BinaryMessages.CanMessage value) {
 991         if (canMessageBuilder_ == null) {
 992           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 993               canMessage_ != com.openxc.BinaryMessages.CanMessage.getDefaultInstance()) {
 994             canMessage_ =
 995               com.openxc.BinaryMessages.CanMessage.newBuilder(canMessage_).mergeFrom(value).buildPartial();
 996           } else {
 997             canMessage_ = value;
 998           }
 999           onChanged();
1000         } else {
1001           canMessageBuilder_.mergeFrom(value);
1002         }
1003         bitField0_ |= 0x00000002;
1004         return this;
1005       }
1006       /**
1007        * <code>optional .openxc.CanMessage can_message = 2;</code>
1008        */
1009       public Builder clearCanMessage() {
1010         if (canMessageBuilder_ == null) {
1011           canMessage_ = com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
1012           onChanged();
1013         } else {
1014           canMessageBuilder_.clear();
1015         }
1016         bitField0_ = (bitField0_ & ~0x00000002);
1017         return this;
1018       }
1019       /**
1020        * <code>optional .openxc.CanMessage can_message = 2;</code>
1021        */
1022       public com.openxc.BinaryMessages.CanMessage.Builder getCanMessageBuilder() {
1023         bitField0_ |= 0x00000002;
1024         onChanged();
1025         return getCanMessageFieldBuilder().getBuilder();
1026       }
1027       /**
1028        * <code>optional .openxc.CanMessage can_message = 2;</code>
1029        */
1030       public com.openxc.BinaryMessages.CanMessageOrBuilder getCanMessageOrBuilder() {
1031         if (canMessageBuilder_ != null) {
1032           return canMessageBuilder_.getMessageOrBuilder();
1033         } else {
1034           return canMessage_;
1035         }
1036       }
1037       /**
1038        * <code>optional .openxc.CanMessage can_message = 2;</code>
1039        */
1040       private com.google.protobuf.SingleFieldBuilder<
1041           com.openxc.BinaryMessages.CanMessage, com.openxc.BinaryMessages.CanMessage.Builder, com.openxc.BinaryMessages.CanMessageOrBuilder>
1042           getCanMessageFieldBuilder() {
1043         if (canMessageBuilder_ == null) {
1044           canMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1045               com.openxc.BinaryMessages.CanMessage, com.openxc.BinaryMessages.CanMessage.Builder, com.openxc.BinaryMessages.CanMessageOrBuilder>(
1046                   canMessage_,
1047                   getParentForChildren(),
1048                   isClean());
1049           canMessage_ = null;
1050         }
1051         return canMessageBuilder_;
1052       }
1053
1054       // optional .openxc.SimpleMessage simple_message = 3;
1055       private com.openxc.BinaryMessages.SimpleMessage simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
1056       private com.google.protobuf.SingleFieldBuilder<
1057           com.openxc.BinaryMessages.SimpleMessage, com.openxc.BinaryMessages.SimpleMessage.Builder, com.openxc.BinaryMessages.SimpleMessageOrBuilder> simpleMessageBuilder_;
1058       /**
1059        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1060        */
1061       public boolean hasSimpleMessage() {
1062         return ((bitField0_ & 0x00000004) == 0x00000004);
1063       }
1064       /**
1065        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1066        */
1067       public com.openxc.BinaryMessages.SimpleMessage getSimpleMessage() {
1068         if (simpleMessageBuilder_ == null) {
1069           return simpleMessage_;
1070         } else {
1071           return simpleMessageBuilder_.getMessage();
1072         }
1073       }
1074       /**
1075        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1076        */
1077       public Builder setSimpleMessage(com.openxc.BinaryMessages.SimpleMessage value) {
1078         if (simpleMessageBuilder_ == null) {
1079           if (value == null) {
1080             throw new NullPointerException();
1081           }
1082           simpleMessage_ = value;
1083           onChanged();
1084         } else {
1085           simpleMessageBuilder_.setMessage(value);
1086         }
1087         bitField0_ |= 0x00000004;
1088         return this;
1089       }
1090       /**
1091        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1092        */
1093       public Builder setSimpleMessage(
1094           com.openxc.BinaryMessages.SimpleMessage.Builder builderForValue) {
1095         if (simpleMessageBuilder_ == null) {
1096           simpleMessage_ = builderForValue.build();
1097           onChanged();
1098         } else {
1099           simpleMessageBuilder_.setMessage(builderForValue.build());
1100         }
1101         bitField0_ |= 0x00000004;
1102         return this;
1103       }
1104       /**
1105        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1106        */
1107       public Builder mergeSimpleMessage(com.openxc.BinaryMessages.SimpleMessage value) {
1108         if (simpleMessageBuilder_ == null) {
1109           if (((bitField0_ & 0x00000004) == 0x00000004) &&
1110               simpleMessage_ != com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance()) {
1111             simpleMessage_ =
1112               com.openxc.BinaryMessages.SimpleMessage.newBuilder(simpleMessage_).mergeFrom(value).buildPartial();
1113           } else {
1114             simpleMessage_ = value;
1115           }
1116           onChanged();
1117         } else {
1118           simpleMessageBuilder_.mergeFrom(value);
1119         }
1120         bitField0_ |= 0x00000004;
1121         return this;
1122       }
1123       /**
1124        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1125        */
1126       public Builder clearSimpleMessage() {
1127         if (simpleMessageBuilder_ == null) {
1128           simpleMessage_ = com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
1129           onChanged();
1130         } else {
1131           simpleMessageBuilder_.clear();
1132         }
1133         bitField0_ = (bitField0_ & ~0x00000004);
1134         return this;
1135       }
1136       /**
1137        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1138        */
1139       public com.openxc.BinaryMessages.SimpleMessage.Builder getSimpleMessageBuilder() {
1140         bitField0_ |= 0x00000004;
1141         onChanged();
1142         return getSimpleMessageFieldBuilder().getBuilder();
1143       }
1144       /**
1145        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1146        */
1147       public com.openxc.BinaryMessages.SimpleMessageOrBuilder getSimpleMessageOrBuilder() {
1148         if (simpleMessageBuilder_ != null) {
1149           return simpleMessageBuilder_.getMessageOrBuilder();
1150         } else {
1151           return simpleMessage_;
1152         }
1153       }
1154       /**
1155        * <code>optional .openxc.SimpleMessage simple_message = 3;</code>
1156        */
1157       private com.google.protobuf.SingleFieldBuilder<
1158           com.openxc.BinaryMessages.SimpleMessage, com.openxc.BinaryMessages.SimpleMessage.Builder, com.openxc.BinaryMessages.SimpleMessageOrBuilder>
1159           getSimpleMessageFieldBuilder() {
1160         if (simpleMessageBuilder_ == null) {
1161           simpleMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1162               com.openxc.BinaryMessages.SimpleMessage, com.openxc.BinaryMessages.SimpleMessage.Builder, com.openxc.BinaryMessages.SimpleMessageOrBuilder>(
1163                   simpleMessage_,
1164                   getParentForChildren(),
1165                   isClean());
1166           simpleMessage_ = null;
1167         }
1168         return simpleMessageBuilder_;
1169       }
1170
1171       // optional .openxc.DiagnosticResponse diagnostic_response = 4;
1172       private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1173       private com.google.protobuf.SingleFieldBuilder<
1174           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> diagnosticResponseBuilder_;
1175       /**
1176        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1177        */
1178       public boolean hasDiagnosticResponse() {
1179         return ((bitField0_ & 0x00000008) == 0x00000008);
1180       }
1181       /**
1182        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1183        */
1184       public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
1185         if (diagnosticResponseBuilder_ == null) {
1186           return diagnosticResponse_;
1187         } else {
1188           return diagnosticResponseBuilder_.getMessage();
1189         }
1190       }
1191       /**
1192        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1193        */
1194       public Builder setDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1195         if (diagnosticResponseBuilder_ == null) {
1196           if (value == null) {
1197             throw new NullPointerException();
1198           }
1199           diagnosticResponse_ = value;
1200           onChanged();
1201         } else {
1202           diagnosticResponseBuilder_.setMessage(value);
1203         }
1204         bitField0_ |= 0x00000008;
1205         return this;
1206       }
1207       /**
1208        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1209        */
1210       public Builder setDiagnosticResponse(
1211           com.openxc.BinaryMessages.DiagnosticResponse.Builder builderForValue) {
1212         if (diagnosticResponseBuilder_ == null) {
1213           diagnosticResponse_ = builderForValue.build();
1214           onChanged();
1215         } else {
1216           diagnosticResponseBuilder_.setMessage(builderForValue.build());
1217         }
1218         bitField0_ |= 0x00000008;
1219         return this;
1220       }
1221       /**
1222        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1223        */
1224       public Builder mergeDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1225         if (diagnosticResponseBuilder_ == null) {
1226           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1227               diagnosticResponse_ != com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) {
1228             diagnosticResponse_ =
1229               com.openxc.BinaryMessages.DiagnosticResponse.newBuilder(diagnosticResponse_).mergeFrom(value).buildPartial();
1230           } else {
1231             diagnosticResponse_ = value;
1232           }
1233           onChanged();
1234         } else {
1235           diagnosticResponseBuilder_.mergeFrom(value);
1236         }
1237         bitField0_ |= 0x00000008;
1238         return this;
1239       }
1240       /**
1241        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1242        */
1243       public Builder clearDiagnosticResponse() {
1244         if (diagnosticResponseBuilder_ == null) {
1245           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1246           onChanged();
1247         } else {
1248           diagnosticResponseBuilder_.clear();
1249         }
1250         bitField0_ = (bitField0_ & ~0x00000008);
1251         return this;
1252       }
1253       /**
1254        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1255        */
1256       public com.openxc.BinaryMessages.DiagnosticResponse.Builder getDiagnosticResponseBuilder() {
1257         bitField0_ |= 0x00000008;
1258         onChanged();
1259         return getDiagnosticResponseFieldBuilder().getBuilder();
1260       }
1261       /**
1262        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1263        */
1264       public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
1265         if (diagnosticResponseBuilder_ != null) {
1266           return diagnosticResponseBuilder_.getMessageOrBuilder();
1267         } else {
1268           return diagnosticResponse_;
1269         }
1270       }
1271       /**
1272        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1273        */
1274       private com.google.protobuf.SingleFieldBuilder<
1275           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>
1276           getDiagnosticResponseFieldBuilder() {
1277         if (diagnosticResponseBuilder_ == null) {
1278           diagnosticResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1279               com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>(
1280                   diagnosticResponse_,
1281                   getParentForChildren(),
1282                   isClean());
1283           diagnosticResponse_ = null;
1284         }
1285         return diagnosticResponseBuilder_;
1286       }
1287
1288       // optional .openxc.ControlCommand control_command = 5;
1289       private com.openxc.BinaryMessages.ControlCommand controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1290       private com.google.protobuf.SingleFieldBuilder<
1291           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> controlCommandBuilder_;
1292       /**
1293        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1294        */
1295       public boolean hasControlCommand() {
1296         return ((bitField0_ & 0x00000010) == 0x00000010);
1297       }
1298       /**
1299        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1300        */
1301       public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
1302         if (controlCommandBuilder_ == null) {
1303           return controlCommand_;
1304         } else {
1305           return controlCommandBuilder_.getMessage();
1306         }
1307       }
1308       /**
1309        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1310        */
1311       public Builder setControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1312         if (controlCommandBuilder_ == null) {
1313           if (value == null) {
1314             throw new NullPointerException();
1315           }
1316           controlCommand_ = value;
1317           onChanged();
1318         } else {
1319           controlCommandBuilder_.setMessage(value);
1320         }
1321         bitField0_ |= 0x00000010;
1322         return this;
1323       }
1324       /**
1325        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1326        */
1327       public Builder setControlCommand(
1328           com.openxc.BinaryMessages.ControlCommand.Builder builderForValue) {
1329         if (controlCommandBuilder_ == null) {
1330           controlCommand_ = builderForValue.build();
1331           onChanged();
1332         } else {
1333           controlCommandBuilder_.setMessage(builderForValue.build());
1334         }
1335         bitField0_ |= 0x00000010;
1336         return this;
1337       }
1338       /**
1339        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1340        */
1341       public Builder mergeControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1342         if (controlCommandBuilder_ == null) {
1343           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1344               controlCommand_ != com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) {
1345             controlCommand_ =
1346               com.openxc.BinaryMessages.ControlCommand.newBuilder(controlCommand_).mergeFrom(value).buildPartial();
1347           } else {
1348             controlCommand_ = value;
1349           }
1350           onChanged();
1351         } else {
1352           controlCommandBuilder_.mergeFrom(value);
1353         }
1354         bitField0_ |= 0x00000010;
1355         return this;
1356       }
1357       /**
1358        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1359        */
1360       public Builder clearControlCommand() {
1361         if (controlCommandBuilder_ == null) {
1362           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1363           onChanged();
1364         } else {
1365           controlCommandBuilder_.clear();
1366         }
1367         bitField0_ = (bitField0_ & ~0x00000010);
1368         return this;
1369       }
1370       /**
1371        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1372        */
1373       public com.openxc.BinaryMessages.ControlCommand.Builder getControlCommandBuilder() {
1374         bitField0_ |= 0x00000010;
1375         onChanged();
1376         return getControlCommandFieldBuilder().getBuilder();
1377       }
1378       /**
1379        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1380        */
1381       public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
1382         if (controlCommandBuilder_ != null) {
1383           return controlCommandBuilder_.getMessageOrBuilder();
1384         } else {
1385           return controlCommand_;
1386         }
1387       }
1388       /**
1389        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1390        */
1391       private com.google.protobuf.SingleFieldBuilder<
1392           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>
1393           getControlCommandFieldBuilder() {
1394         if (controlCommandBuilder_ == null) {
1395           controlCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1396               com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>(
1397                   controlCommand_,
1398                   getParentForChildren(),
1399                   isClean());
1400           controlCommand_ = null;
1401         }
1402         return controlCommandBuilder_;
1403       }
1404
1405       // optional .openxc.CommandResponse command_response = 6;
1406       private com.openxc.BinaryMessages.CommandResponse commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1407       private com.google.protobuf.SingleFieldBuilder<
1408           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> commandResponseBuilder_;
1409       /**
1410        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1411        */
1412       public boolean hasCommandResponse() {
1413         return ((bitField0_ & 0x00000020) == 0x00000020);
1414       }
1415       /**
1416        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1417        */
1418       public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
1419         if (commandResponseBuilder_ == null) {
1420           return commandResponse_;
1421         } else {
1422           return commandResponseBuilder_.getMessage();
1423         }
1424       }
1425       /**
1426        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1427        */
1428       public Builder setCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1429         if (commandResponseBuilder_ == null) {
1430           if (value == null) {
1431             throw new NullPointerException();
1432           }
1433           commandResponse_ = value;
1434           onChanged();
1435         } else {
1436           commandResponseBuilder_.setMessage(value);
1437         }
1438         bitField0_ |= 0x00000020;
1439         return this;
1440       }
1441       /**
1442        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1443        */
1444       public Builder setCommandResponse(
1445           com.openxc.BinaryMessages.CommandResponse.Builder builderForValue) {
1446         if (commandResponseBuilder_ == null) {
1447           commandResponse_ = builderForValue.build();
1448           onChanged();
1449         } else {
1450           commandResponseBuilder_.setMessage(builderForValue.build());
1451         }
1452         bitField0_ |= 0x00000020;
1453         return this;
1454       }
1455       /**
1456        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1457        */
1458       public Builder mergeCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1459         if (commandResponseBuilder_ == null) {
1460           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1461               commandResponse_ != com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) {
1462             commandResponse_ =
1463               com.openxc.BinaryMessages.CommandResponse.newBuilder(commandResponse_).mergeFrom(value).buildPartial();
1464           } else {
1465             commandResponse_ = value;
1466           }
1467           onChanged();
1468         } else {
1469           commandResponseBuilder_.mergeFrom(value);
1470         }
1471         bitField0_ |= 0x00000020;
1472         return this;
1473       }
1474       /**
1475        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1476        */
1477       public Builder clearCommandResponse() {
1478         if (commandResponseBuilder_ == null) {
1479           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1480           onChanged();
1481         } else {
1482           commandResponseBuilder_.clear();
1483         }
1484         bitField0_ = (bitField0_ & ~0x00000020);
1485         return this;
1486       }
1487       /**
1488        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1489        */
1490       public com.openxc.BinaryMessages.CommandResponse.Builder getCommandResponseBuilder() {
1491         bitField0_ |= 0x00000020;
1492         onChanged();
1493         return getCommandResponseFieldBuilder().getBuilder();
1494       }
1495       /**
1496        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1497        */
1498       public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
1499         if (commandResponseBuilder_ != null) {
1500           return commandResponseBuilder_.getMessageOrBuilder();
1501         } else {
1502           return commandResponse_;
1503         }
1504       }
1505       /**
1506        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1507        */
1508       private com.google.protobuf.SingleFieldBuilder<
1509           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>
1510           getCommandResponseFieldBuilder() {
1511         if (commandResponseBuilder_ == null) {
1512           commandResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1513               com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>(
1514                   commandResponse_,
1515                   getParentForChildren(),
1516                   isClean());
1517           commandResponse_ = null;
1518         }
1519         return commandResponseBuilder_;
1520       }
1521
1522       // optional uint64 timestamp = 7;
1523       private long timestamp_ ;
1524       /**
1525        * <code>optional uint64 timestamp = 7;</code>
1526        */
1527       public boolean hasTimestamp() {
1528         return ((bitField0_ & 0x00000040) == 0x00000040);
1529       }
1530       /**
1531        * <code>optional uint64 timestamp = 7;</code>
1532        */
1533       public long getTimestamp() {
1534         return timestamp_;
1535       }
1536       /**
1537        * <code>optional uint64 timestamp = 7;</code>
1538        */
1539       public Builder setTimestamp(long value) {
1540         bitField0_ |= 0x00000040;
1541         timestamp_ = value;
1542         onChanged();
1543         return this;
1544       }
1545       /**
1546        * <code>optional uint64 timestamp = 7;</code>
1547        */
1548       public Builder clearTimestamp() {
1549         bitField0_ = (bitField0_ & ~0x00000040);
1550         timestamp_ = 0L;
1551         onChanged();
1552         return this;
1553       }
1554
1555       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1556     }
1557
1558     static {
1559       defaultInstance = new VehicleMessage(true);
1560       defaultInstance.initFields();
1561     }
1562
1563     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1564   }
1565
1566   public interface CanMessageOrBuilder
1567       extends com.google.protobuf.MessageOrBuilder {
1568
1569     // optional int32 bus = 1;
1570     /**
1571      * <code>optional int32 bus = 1;</code>
1572      */
1573     boolean hasBus();
1574     /**
1575      * <code>optional int32 bus = 1;</code>
1576      */
1577     int getBus();
1578
1579     // optional uint32 id = 2;
1580     /**
1581      * <code>optional uint32 id = 2;</code>
1582      */
1583     boolean hasId();
1584     /**
1585      * <code>optional uint32 id = 2;</code>
1586      */
1587     int getId();
1588
1589     // optional bytes data = 3;
1590     /**
1591      * <code>optional bytes data = 3;</code>
1592      */
1593     boolean hasData();
1594     /**
1595      * <code>optional bytes data = 3;</code>
1596      */
1597     com.google.protobuf.ByteString getData();
1598
1599     // optional .openxc.CanMessage.FrameFormat frame_format = 4;
1600     /**
1601      * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
1602      */
1603     boolean hasFrameFormat();
1604     /**
1605      * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
1606      */
1607     com.openxc.BinaryMessages.CanMessage.FrameFormat getFrameFormat();
1608   }
1609   /**
1610    * Protobuf type {@code openxc.CanMessage}
1611    */
1612   public static final class CanMessage extends
1613       com.google.protobuf.GeneratedMessage
1614       implements CanMessageOrBuilder {
1615     // Use CanMessage.newBuilder() to construct.
1616     private CanMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1617       super(builder);
1618       this.unknownFields = builder.getUnknownFields();
1619     }
1620     private CanMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1621
1622     private static final CanMessage defaultInstance;
1623     public static CanMessage getDefaultInstance() {
1624       return defaultInstance;
1625     }
1626
1627     public CanMessage getDefaultInstanceForType() {
1628       return defaultInstance;
1629     }
1630
1631     private final com.google.protobuf.UnknownFieldSet unknownFields;
1632     @java.lang.Override
1633     public final com.google.protobuf.UnknownFieldSet
1634         getUnknownFields() {
1635       return this.unknownFields;
1636     }
1637     private CanMessage(
1638         com.google.protobuf.CodedInputStream input,
1639         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1640         throws com.google.protobuf.InvalidProtocolBufferException {
1641       initFields();
1642       int mutable_bitField0_ = 0;
1643       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1644           com.google.protobuf.UnknownFieldSet.newBuilder();
1645       try {
1646         boolean done = false;
1647         while (!done) {
1648           int tag = input.readTag();
1649           switch (tag) {
1650             case 0:
1651               done = true;
1652               break;
1653             default: {
1654               if (!parseUnknownField(input, unknownFields,
1655                                      extensionRegistry, tag)) {
1656                 done = true;
1657               }
1658               break;
1659             }
1660             case 8: {
1661               bitField0_ |= 0x00000001;
1662               bus_ = input.readInt32();
1663               break;
1664             }
1665             case 16: {
1666               bitField0_ |= 0x00000002;
1667               id_ = input.readUInt32();
1668               break;
1669             }
1670             case 26: {
1671               bitField0_ |= 0x00000004;
1672               data_ = input.readBytes();
1673               break;
1674             }
1675             case 32: {
1676               int rawValue = input.readEnum();
1677               com.openxc.BinaryMessages.CanMessage.FrameFormat value = com.openxc.BinaryMessages.CanMessage.FrameFormat.valueOf(rawValue);
1678               if (value == null) {
1679                 unknownFields.mergeVarintField(4, rawValue);
1680               } else {
1681                 bitField0_ |= 0x00000008;
1682                 frameFormat_ = value;
1683               }
1684               break;
1685             }
1686           }
1687         }
1688       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1689         throw e.setUnfinishedMessage(this);
1690       } catch (java.io.IOException e) {
1691         throw new com.google.protobuf.InvalidProtocolBufferException(
1692             e.getMessage()).setUnfinishedMessage(this);
1693       } finally {
1694         this.unknownFields = unknownFields.build();
1695         makeExtensionsImmutable();
1696       }
1697     }
1698     public static final com.google.protobuf.Descriptors.Descriptor
1699         getDescriptor() {
1700       return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_descriptor;
1701     }
1702
1703     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1704         internalGetFieldAccessorTable() {
1705       return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_fieldAccessorTable
1706           .ensureFieldAccessorsInitialized(
1707               com.openxc.BinaryMessages.CanMessage.class, com.openxc.BinaryMessages.CanMessage.Builder.class);
1708     }
1709
1710     public static com.google.protobuf.Parser<CanMessage> PARSER =
1711         new com.google.protobuf.AbstractParser<CanMessage>() {
1712       public CanMessage parsePartialFrom(
1713           com.google.protobuf.CodedInputStream input,
1714           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1715           throws com.google.protobuf.InvalidProtocolBufferException {
1716         return new CanMessage(input, extensionRegistry);
1717       }
1718     };
1719
1720     @java.lang.Override
1721     public com.google.protobuf.Parser<CanMessage> getParserForType() {
1722       return PARSER;
1723     }
1724
1725     /**
1726      * Protobuf enum {@code openxc.CanMessage.FrameFormat}
1727      */
1728     public enum FrameFormat
1729         implements com.google.protobuf.ProtocolMessageEnum {
1730       /**
1731        * <code>STANDARD = 1;</code>
1732        */
1733       STANDARD(0, 1),
1734       /**
1735        * <code>EXTENDED = 2;</code>
1736        */
1737       EXTENDED(1, 2),
1738       ;
1739
1740       /**
1741        * <code>STANDARD = 1;</code>
1742        */
1743       public static final int STANDARD_VALUE = 1;
1744       /**
1745        * <code>EXTENDED = 2;</code>
1746        */
1747       public static final int EXTENDED_VALUE = 2;
1748
1749
1750       public final int getNumber() { return value; }
1751
1752       public static FrameFormat valueOf(int value) {
1753         switch (value) {
1754           case 1: return STANDARD;
1755           case 2: return EXTENDED;
1756           default: return null;
1757         }
1758       }
1759
1760       public static com.google.protobuf.Internal.EnumLiteMap<FrameFormat>
1761           internalGetValueMap() {
1762         return internalValueMap;
1763       }
1764       private static com.google.protobuf.Internal.EnumLiteMap<FrameFormat>
1765           internalValueMap =
1766             new com.google.protobuf.Internal.EnumLiteMap<FrameFormat>() {
1767               public FrameFormat findValueByNumber(int number) {
1768                 return FrameFormat.valueOf(number);
1769               }
1770             };
1771
1772       public final com.google.protobuf.Descriptors.EnumValueDescriptor
1773           getValueDescriptor() {
1774         return getDescriptor().getValues().get(index);
1775       }
1776       public final com.google.protobuf.Descriptors.EnumDescriptor
1777           getDescriptorForType() {
1778         return getDescriptor();
1779       }
1780       public static final com.google.protobuf.Descriptors.EnumDescriptor
1781           getDescriptor() {
1782         return com.openxc.BinaryMessages.CanMessage.getDescriptor().getEnumTypes().get(0);
1783       }
1784
1785       private static final FrameFormat[] VALUES = values();
1786
1787       public static FrameFormat valueOf(
1788           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1789         if (desc.getType() != getDescriptor()) {
1790           throw new java.lang.IllegalArgumentException(
1791             "EnumValueDescriptor is not for this type.");
1792         }
1793         return VALUES[desc.getIndex()];
1794       }
1795
1796       private final int index;
1797       private final int value;
1798
1799       private FrameFormat(int index, int value) {
1800         this.index = index;
1801         this.value = value;
1802       }
1803
1804       // @@protoc_insertion_point(enum_scope:openxc.CanMessage.FrameFormat)
1805     }
1806
1807     private int bitField0_;
1808     // optional int32 bus = 1;
1809     public static final int BUS_FIELD_NUMBER = 1;
1810     private int bus_;
1811     /**
1812      * <code>optional int32 bus = 1;</code>
1813      */
1814     public boolean hasBus() {
1815       return ((bitField0_ & 0x00000001) == 0x00000001);
1816     }
1817     /**
1818      * <code>optional int32 bus = 1;</code>
1819      */
1820     public int getBus() {
1821       return bus_;
1822     }
1823
1824     // optional uint32 id = 2;
1825     public static final int ID_FIELD_NUMBER = 2;
1826     private int id_;
1827     /**
1828      * <code>optional uint32 id = 2;</code>
1829      */
1830     public boolean hasId() {
1831       return ((bitField0_ & 0x00000002) == 0x00000002);
1832     }
1833     /**
1834      * <code>optional uint32 id = 2;</code>
1835      */
1836     public int getId() {
1837       return id_;
1838     }
1839
1840     // optional bytes data = 3;
1841     public static final int DATA_FIELD_NUMBER = 3;
1842     private com.google.protobuf.ByteString data_;
1843     /**
1844      * <code>optional bytes data = 3;</code>
1845      */
1846     public boolean hasData() {
1847       return ((bitField0_ & 0x00000004) == 0x00000004);
1848     }
1849     /**
1850      * <code>optional bytes data = 3;</code>
1851      */
1852     public com.google.protobuf.ByteString getData() {
1853       return data_;
1854     }
1855
1856     // optional .openxc.CanMessage.FrameFormat frame_format = 4;
1857     public static final int FRAME_FORMAT_FIELD_NUMBER = 4;
1858     private com.openxc.BinaryMessages.CanMessage.FrameFormat frameFormat_;
1859     /**
1860      * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
1861      */
1862     public boolean hasFrameFormat() {
1863       return ((bitField0_ & 0x00000008) == 0x00000008);
1864     }
1865     /**
1866      * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
1867      */
1868     public com.openxc.BinaryMessages.CanMessage.FrameFormat getFrameFormat() {
1869       return frameFormat_;
1870     }
1871
1872     private void initFields() {
1873       bus_ = 0;
1874       id_ = 0;
1875       data_ = com.google.protobuf.ByteString.EMPTY;
1876       frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
1877     }
1878     private byte memoizedIsInitialized = -1;
1879     public final boolean isInitialized() {
1880       byte isInitialized = memoizedIsInitialized;
1881       if (isInitialized != -1) return isInitialized == 1;
1882
1883       memoizedIsInitialized = 1;
1884       return true;
1885     }
1886
1887     public void writeTo(com.google.protobuf.CodedOutputStream output)
1888                         throws java.io.IOException {
1889       getSerializedSize();
1890       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1891         output.writeInt32(1, bus_);
1892       }
1893       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1894         output.writeUInt32(2, id_);
1895       }
1896       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1897         output.writeBytes(3, data_);
1898       }
1899       if (((bitField0_ & 0x00000008) == 0x00000008)) {
1900         output.writeEnum(4, frameFormat_.getNumber());
1901       }
1902       getUnknownFields().writeTo(output);
1903     }
1904
1905     private int memoizedSerializedSize = -1;
1906     public int getSerializedSize() {
1907       int size = memoizedSerializedSize;
1908       if (size != -1) return size;
1909
1910       size = 0;
1911       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1912         size += com.google.protobuf.CodedOutputStream
1913           .computeInt32Size(1, bus_);
1914       }
1915       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1916         size += com.google.protobuf.CodedOutputStream
1917           .computeUInt32Size(2, id_);
1918       }
1919       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1920         size += com.google.protobuf.CodedOutputStream
1921           .computeBytesSize(3, data_);
1922       }
1923       if (((bitField0_ & 0x00000008) == 0x00000008)) {
1924         size += com.google.protobuf.CodedOutputStream
1925           .computeEnumSize(4, frameFormat_.getNumber());
1926       }
1927       size += getUnknownFields().getSerializedSize();
1928       memoizedSerializedSize = size;
1929       return size;
1930     }
1931
1932     private static final long serialVersionUID = 0L;
1933     @java.lang.Override
1934     protected java.lang.Object writeReplace()
1935         throws java.io.ObjectStreamException {
1936       return super.writeReplace();
1937     }
1938
1939     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1940         com.google.protobuf.ByteString data)
1941         throws com.google.protobuf.InvalidProtocolBufferException {
1942       return PARSER.parseFrom(data);
1943     }
1944     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1945         com.google.protobuf.ByteString data,
1946         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1947         throws com.google.protobuf.InvalidProtocolBufferException {
1948       return PARSER.parseFrom(data, extensionRegistry);
1949     }
1950     public static com.openxc.BinaryMessages.CanMessage parseFrom(byte[] data)
1951         throws com.google.protobuf.InvalidProtocolBufferException {
1952       return PARSER.parseFrom(data);
1953     }
1954     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1955         byte[] data,
1956         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1957         throws com.google.protobuf.InvalidProtocolBufferException {
1958       return PARSER.parseFrom(data, extensionRegistry);
1959     }
1960     public static com.openxc.BinaryMessages.CanMessage parseFrom(java.io.InputStream input)
1961         throws java.io.IOException {
1962       return PARSER.parseFrom(input);
1963     }
1964     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1965         java.io.InputStream input,
1966         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1967         throws java.io.IOException {
1968       return PARSER.parseFrom(input, extensionRegistry);
1969     }
1970     public static com.openxc.BinaryMessages.CanMessage parseDelimitedFrom(java.io.InputStream input)
1971         throws java.io.IOException {
1972       return PARSER.parseDelimitedFrom(input);
1973     }
1974     public static com.openxc.BinaryMessages.CanMessage parseDelimitedFrom(
1975         java.io.InputStream input,
1976         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1977         throws java.io.IOException {
1978       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1979     }
1980     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1981         com.google.protobuf.CodedInputStream input)
1982         throws java.io.IOException {
1983       return PARSER.parseFrom(input);
1984     }
1985     public static com.openxc.BinaryMessages.CanMessage parseFrom(
1986         com.google.protobuf.CodedInputStream input,
1987         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1988         throws java.io.IOException {
1989       return PARSER.parseFrom(input, extensionRegistry);
1990     }
1991
1992     public static Builder newBuilder() { return Builder.create(); }
1993     public Builder newBuilderForType() { return newBuilder(); }
1994     public static Builder newBuilder(com.openxc.BinaryMessages.CanMessage prototype) {
1995       return newBuilder().mergeFrom(prototype);
1996     }
1997     public Builder toBuilder() { return newBuilder(this); }
1998
1999     @java.lang.Override
2000     protected Builder newBuilderForType(
2001         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2002       Builder builder = new Builder(parent);
2003       return builder;
2004     }
2005     /**
2006      * Protobuf type {@code openxc.CanMessage}
2007      */
2008     public static final class Builder extends
2009         com.google.protobuf.GeneratedMessage.Builder<Builder>
2010        implements com.openxc.BinaryMessages.CanMessageOrBuilder {
2011       public static final com.google.protobuf.Descriptors.Descriptor
2012           getDescriptor() {
2013         return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_descriptor;
2014       }
2015
2016       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2017           internalGetFieldAccessorTable() {
2018         return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_fieldAccessorTable
2019             .ensureFieldAccessorsInitialized(
2020                 com.openxc.BinaryMessages.CanMessage.class, com.openxc.BinaryMessages.CanMessage.Builder.class);
2021       }
2022
2023       // Construct using com.openxc.BinaryMessages.CanMessage.newBuilder()
2024       private Builder() {
2025         maybeForceBuilderInitialization();
2026       }
2027
2028       private Builder(
2029           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2030         super(parent);
2031         maybeForceBuilderInitialization();
2032       }
2033       private void maybeForceBuilderInitialization() {
2034         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2035         }
2036       }
2037       private static Builder create() {
2038         return new Builder();
2039       }
2040
2041       public Builder clear() {
2042         super.clear();
2043         bus_ = 0;
2044         bitField0_ = (bitField0_ & ~0x00000001);
2045         id_ = 0;
2046         bitField0_ = (bitField0_ & ~0x00000002);
2047         data_ = com.google.protobuf.ByteString.EMPTY;
2048         bitField0_ = (bitField0_ & ~0x00000004);
2049         frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
2050         bitField0_ = (bitField0_ & ~0x00000008);
2051         return this;
2052       }
2053
2054       public Builder clone() {
2055         return create().mergeFrom(buildPartial());
2056       }
2057
2058       public com.google.protobuf.Descriptors.Descriptor
2059           getDescriptorForType() {
2060         return com.openxc.BinaryMessages.internal_static_openxc_CanMessage_descriptor;
2061       }
2062
2063       public com.openxc.BinaryMessages.CanMessage getDefaultInstanceForType() {
2064         return com.openxc.BinaryMessages.CanMessage.getDefaultInstance();
2065       }
2066
2067       public com.openxc.BinaryMessages.CanMessage build() {
2068         com.openxc.BinaryMessages.CanMessage result = buildPartial();
2069         if (!result.isInitialized()) {
2070           throw newUninitializedMessageException(result);
2071         }
2072         return result;
2073       }
2074
2075       public com.openxc.BinaryMessages.CanMessage buildPartial() {
2076         com.openxc.BinaryMessages.CanMessage result = new com.openxc.BinaryMessages.CanMessage(this);
2077         int from_bitField0_ = bitField0_;
2078         int to_bitField0_ = 0;
2079         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2080           to_bitField0_ |= 0x00000001;
2081         }
2082         result.bus_ = bus_;
2083         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2084           to_bitField0_ |= 0x00000002;
2085         }
2086         result.id_ = id_;
2087         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2088           to_bitField0_ |= 0x00000004;
2089         }
2090         result.data_ = data_;
2091         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2092           to_bitField0_ |= 0x00000008;
2093         }
2094         result.frameFormat_ = frameFormat_;
2095         result.bitField0_ = to_bitField0_;
2096         onBuilt();
2097         return result;
2098       }
2099
2100       public Builder mergeFrom(com.google.protobuf.Message other) {
2101         if (other instanceof com.openxc.BinaryMessages.CanMessage) {
2102           return mergeFrom((com.openxc.BinaryMessages.CanMessage)other);
2103         } else {
2104           super.mergeFrom(other);
2105           return this;
2106         }
2107       }
2108
2109       public Builder mergeFrom(com.openxc.BinaryMessages.CanMessage other) {
2110         if (other == com.openxc.BinaryMessages.CanMessage.getDefaultInstance()) return this;
2111         if (other.hasBus()) {
2112           setBus(other.getBus());
2113         }
2114         if (other.hasId()) {
2115           setId(other.getId());
2116         }
2117         if (other.hasData()) {
2118           setData(other.getData());
2119         }
2120         if (other.hasFrameFormat()) {
2121           setFrameFormat(other.getFrameFormat());
2122         }
2123         this.mergeUnknownFields(other.getUnknownFields());
2124         return this;
2125       }
2126
2127       public final boolean isInitialized() {
2128         return true;
2129       }
2130
2131       public Builder mergeFrom(
2132           com.google.protobuf.CodedInputStream input,
2133           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2134           throws java.io.IOException {
2135         com.openxc.BinaryMessages.CanMessage parsedMessage = null;
2136         try {
2137           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2138         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2139           parsedMessage = (com.openxc.BinaryMessages.CanMessage) e.getUnfinishedMessage();
2140           throw e;
2141         } finally {
2142           if (parsedMessage != null) {
2143             mergeFrom(parsedMessage);
2144           }
2145         }
2146         return this;
2147       }
2148       private int bitField0_;
2149
2150       // optional int32 bus = 1;
2151       private int bus_ ;
2152       /**
2153        * <code>optional int32 bus = 1;</code>
2154        */
2155       public boolean hasBus() {
2156         return ((bitField0_ & 0x00000001) == 0x00000001);
2157       }
2158       /**
2159        * <code>optional int32 bus = 1;</code>
2160        */
2161       public int getBus() {
2162         return bus_;
2163       }
2164       /**
2165        * <code>optional int32 bus = 1;</code>
2166        */
2167       public Builder setBus(int value) {
2168         bitField0_ |= 0x00000001;
2169         bus_ = value;
2170         onChanged();
2171         return this;
2172       }
2173       /**
2174        * <code>optional int32 bus = 1;</code>
2175        */
2176       public Builder clearBus() {
2177         bitField0_ = (bitField0_ & ~0x00000001);
2178         bus_ = 0;
2179         onChanged();
2180         return this;
2181       }
2182
2183       // optional uint32 id = 2;
2184       private int id_ ;
2185       /**
2186        * <code>optional uint32 id = 2;</code>
2187        */
2188       public boolean hasId() {
2189         return ((bitField0_ & 0x00000002) == 0x00000002);
2190       }
2191       /**
2192        * <code>optional uint32 id = 2;</code>
2193        */
2194       public int getId() {
2195         return id_;
2196       }
2197       /**
2198        * <code>optional uint32 id = 2;</code>
2199        */
2200       public Builder setId(int value) {
2201         bitField0_ |= 0x00000002;
2202         id_ = value;
2203         onChanged();
2204         return this;
2205       }
2206       /**
2207        * <code>optional uint32 id = 2;</code>
2208        */
2209       public Builder clearId() {
2210         bitField0_ = (bitField0_ & ~0x00000002);
2211         id_ = 0;
2212         onChanged();
2213         return this;
2214       }
2215
2216       // optional bytes data = 3;
2217       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
2218       /**
2219        * <code>optional bytes data = 3;</code>
2220        */
2221       public boolean hasData() {
2222         return ((bitField0_ & 0x00000004) == 0x00000004);
2223       }
2224       /**
2225        * <code>optional bytes data = 3;</code>
2226        */
2227       public com.google.protobuf.ByteString getData() {
2228         return data_;
2229       }
2230       /**
2231        * <code>optional bytes data = 3;</code>
2232        */
2233       public Builder setData(com.google.protobuf.ByteString value) {
2234         if (value == null) {
2235     throw new NullPointerException();
2236   }
2237   bitField0_ |= 0x00000004;
2238         data_ = value;
2239         onChanged();
2240         return this;
2241       }
2242       /**
2243        * <code>optional bytes data = 3;</code>
2244        */
2245       public Builder clearData() {
2246         bitField0_ = (bitField0_ & ~0x00000004);
2247         data_ = getDefaultInstance().getData();
2248         onChanged();
2249         return this;
2250       }
2251
2252       // optional .openxc.CanMessage.FrameFormat frame_format = 4;
2253       private com.openxc.BinaryMessages.CanMessage.FrameFormat frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
2254       /**
2255        * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
2256        */
2257       public boolean hasFrameFormat() {
2258         return ((bitField0_ & 0x00000008) == 0x00000008);
2259       }
2260       /**
2261        * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
2262        */
2263       public com.openxc.BinaryMessages.CanMessage.FrameFormat getFrameFormat() {
2264         return frameFormat_;
2265       }
2266       /**
2267        * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
2268        */
2269       public Builder setFrameFormat(com.openxc.BinaryMessages.CanMessage.FrameFormat value) {
2270         if (value == null) {
2271           throw new NullPointerException();
2272         }
2273         bitField0_ |= 0x00000008;
2274         frameFormat_ = value;
2275         onChanged();
2276         return this;
2277       }
2278       /**
2279        * <code>optional .openxc.CanMessage.FrameFormat frame_format = 4;</code>
2280        */
2281       public Builder clearFrameFormat() {
2282         bitField0_ = (bitField0_ & ~0x00000008);
2283         frameFormat_ = com.openxc.BinaryMessages.CanMessage.FrameFormat.STANDARD;
2284         onChanged();
2285         return this;
2286       }
2287
2288       // @@protoc_insertion_point(builder_scope:openxc.CanMessage)
2289     }
2290
2291     static {
2292       defaultInstance = new CanMessage(true);
2293       defaultInstance.initFields();
2294     }
2295
2296     // @@protoc_insertion_point(class_scope:openxc.CanMessage)
2297   }
2298
2299   public interface ControlCommandOrBuilder
2300       extends com.google.protobuf.MessageOrBuilder {
2301
2302     // optional .openxc.ControlCommand.Type type = 1;
2303     /**
2304      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2305      */
2306     boolean hasType();
2307     /**
2308      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2309      */
2310     com.openxc.BinaryMessages.ControlCommand.Type getType();
2311
2312     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2313     /**
2314      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2315      */
2316     boolean hasDiagnosticRequest();
2317     /**
2318      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2319      */
2320     com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest();
2321     /**
2322      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2323      */
2324     com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder();
2325
2326     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2327     /**
2328      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2329      */
2330     boolean hasPassthroughModeRequest();
2331     /**
2332      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2333      */
2334     com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest();
2335     /**
2336      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2337      */
2338     com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder();
2339
2340     // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
2341     /**
2342      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2343      */
2344     boolean hasAcceptanceFilterBypassCommand();
2345     /**
2346      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2347      */
2348     com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand();
2349     /**
2350      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2351      */
2352     com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder();
2353
2354     // optional .openxc.PayloadFormatCommand payload_format_command = 5;
2355     /**
2356      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2357      */
2358     boolean hasPayloadFormatCommand();
2359     /**
2360      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2361      */
2362     com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand();
2363     /**
2364      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2365      */
2366     com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder();
2367
2368     // optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;
2369     /**
2370      * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
2371      */
2372     boolean hasPredefinedObd2RequestsCommand();
2373     /**
2374      * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
2375      */
2376     com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getPredefinedObd2RequestsCommand();
2377     /**
2378      * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
2379      */
2380     com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder getPredefinedObd2RequestsCommandOrBuilder();
2381
2382     // optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;
2383     /**
2384      * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
2385      */
2386     boolean hasModemConfigurationCommand();
2387     /**
2388      * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
2389      */
2390     com.openxc.BinaryMessages.ModemConfigurationCommand getModemConfigurationCommand();
2391     /**
2392      * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
2393      */
2394     com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder getModemConfigurationCommandOrBuilder();
2395
2396     // optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;
2397     /**
2398      * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
2399      */
2400     boolean hasRtcConfigurationCommand();
2401     /**
2402      * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
2403      */
2404     com.openxc.BinaryMessages.RTCConfigurationCommand getRtcConfigurationCommand();
2405     /**
2406      * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
2407      */
2408     com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder getRtcConfigurationCommandOrBuilder();
2409   }
2410   /**
2411    * Protobuf type {@code openxc.ControlCommand}
2412    */
2413   public static final class ControlCommand extends
2414       com.google.protobuf.GeneratedMessage
2415       implements ControlCommandOrBuilder {
2416     // Use ControlCommand.newBuilder() to construct.
2417     private ControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2418       super(builder);
2419       this.unknownFields = builder.getUnknownFields();
2420     }
2421     private ControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2422
2423     private static final ControlCommand defaultInstance;
2424     public static ControlCommand getDefaultInstance() {
2425       return defaultInstance;
2426     }
2427
2428     public ControlCommand getDefaultInstanceForType() {
2429       return defaultInstance;
2430     }
2431
2432     private final com.google.protobuf.UnknownFieldSet unknownFields;
2433     @java.lang.Override
2434     public final com.google.protobuf.UnknownFieldSet
2435         getUnknownFields() {
2436       return this.unknownFields;
2437     }
2438     private ControlCommand(
2439         com.google.protobuf.CodedInputStream input,
2440         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2441         throws com.google.protobuf.InvalidProtocolBufferException {
2442       initFields();
2443       int mutable_bitField0_ = 0;
2444       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2445           com.google.protobuf.UnknownFieldSet.newBuilder();
2446       try {
2447         boolean done = false;
2448         while (!done) {
2449           int tag = input.readTag();
2450           switch (tag) {
2451             case 0:
2452               done = true;
2453               break;
2454             default: {
2455               if (!parseUnknownField(input, unknownFields,
2456                                      extensionRegistry, tag)) {
2457                 done = true;
2458               }
2459               break;
2460             }
2461             case 8: {
2462               int rawValue = input.readEnum();
2463               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2464               if (value == null) {
2465                 unknownFields.mergeVarintField(1, rawValue);
2466               } else {
2467                 bitField0_ |= 0x00000001;
2468                 type_ = value;
2469               }
2470               break;
2471             }
2472             case 18: {
2473               com.openxc.BinaryMessages.DiagnosticControlCommand.Builder subBuilder = null;
2474               if (((bitField0_ & 0x00000002) == 0x00000002)) {
2475                 subBuilder = diagnosticRequest_.toBuilder();
2476               }
2477               diagnosticRequest_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticControlCommand.PARSER, extensionRegistry);
2478               if (subBuilder != null) {
2479                 subBuilder.mergeFrom(diagnosticRequest_);
2480                 diagnosticRequest_ = subBuilder.buildPartial();
2481               }
2482               bitField0_ |= 0x00000002;
2483               break;
2484             }
2485             case 26: {
2486               com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder subBuilder = null;
2487               if (((bitField0_ & 0x00000004) == 0x00000004)) {
2488                 subBuilder = passthroughModeRequest_.toBuilder();
2489               }
2490               passthroughModeRequest_ = input.readMessage(com.openxc.BinaryMessages.PassthroughModeControlCommand.PARSER, extensionRegistry);
2491               if (subBuilder != null) {
2492                 subBuilder.mergeFrom(passthroughModeRequest_);
2493                 passthroughModeRequest_ = subBuilder.buildPartial();
2494               }
2495               bitField0_ |= 0x00000004;
2496               break;
2497             }
2498             case 34: {
2499               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder subBuilder = null;
2500               if (((bitField0_ & 0x00000008) == 0x00000008)) {
2501                 subBuilder = acceptanceFilterBypassCommand_.toBuilder();
2502               }
2503               acceptanceFilterBypassCommand_ = input.readMessage(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.PARSER, extensionRegistry);
2504               if (subBuilder != null) {
2505                 subBuilder.mergeFrom(acceptanceFilterBypassCommand_);
2506                 acceptanceFilterBypassCommand_ = subBuilder.buildPartial();
2507               }
2508               bitField0_ |= 0x00000008;
2509               break;
2510             }
2511             case 42: {
2512               com.openxc.BinaryMessages.PayloadFormatCommand.Builder subBuilder = null;
2513               if (((bitField0_ & 0x00000010) == 0x00000010)) {
2514                 subBuilder = payloadFormatCommand_.toBuilder();
2515               }
2516               payloadFormatCommand_ = input.readMessage(com.openxc.BinaryMessages.PayloadFormatCommand.PARSER, extensionRegistry);
2517               if (subBuilder != null) {
2518                 subBuilder.mergeFrom(payloadFormatCommand_);
2519                 payloadFormatCommand_ = subBuilder.buildPartial();
2520               }
2521               bitField0_ |= 0x00000010;
2522               break;
2523             }
2524             case 50: {
2525               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder subBuilder = null;
2526               if (((bitField0_ & 0x00000020) == 0x00000020)) {
2527                 subBuilder = predefinedObd2RequestsCommand_.toBuilder();
2528               }
2529               predefinedObd2RequestsCommand_ = input.readMessage(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.PARSER, extensionRegistry);
2530               if (subBuilder != null) {
2531                 subBuilder.mergeFrom(predefinedObd2RequestsCommand_);
2532                 predefinedObd2RequestsCommand_ = subBuilder.buildPartial();
2533               }
2534               bitField0_ |= 0x00000020;
2535               break;
2536             }
2537             case 58: {
2538               com.openxc.BinaryMessages.ModemConfigurationCommand.Builder subBuilder = null;
2539               if (((bitField0_ & 0x00000040) == 0x00000040)) {
2540                 subBuilder = modemConfigurationCommand_.toBuilder();
2541               }
2542               modemConfigurationCommand_ = input.readMessage(com.openxc.BinaryMessages.ModemConfigurationCommand.PARSER, extensionRegistry);
2543               if (subBuilder != null) {
2544                 subBuilder.mergeFrom(modemConfigurationCommand_);
2545                 modemConfigurationCommand_ = subBuilder.buildPartial();
2546               }
2547               bitField0_ |= 0x00000040;
2548               break;
2549             }
2550             case 66: {
2551               com.openxc.BinaryMessages.RTCConfigurationCommand.Builder subBuilder = null;
2552               if (((bitField0_ & 0x00000080) == 0x00000080)) {
2553                 subBuilder = rtcConfigurationCommand_.toBuilder();
2554               }
2555               rtcConfigurationCommand_ = input.readMessage(com.openxc.BinaryMessages.RTCConfigurationCommand.PARSER, extensionRegistry);
2556               if (subBuilder != null) {
2557                 subBuilder.mergeFrom(rtcConfigurationCommand_);
2558                 rtcConfigurationCommand_ = subBuilder.buildPartial();
2559               }
2560               bitField0_ |= 0x00000080;
2561               break;
2562             }
2563           }
2564         }
2565       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2566         throw e.setUnfinishedMessage(this);
2567       } catch (java.io.IOException e) {
2568         throw new com.google.protobuf.InvalidProtocolBufferException(
2569             e.getMessage()).setUnfinishedMessage(this);
2570       } finally {
2571         this.unknownFields = unknownFields.build();
2572         makeExtensionsImmutable();
2573       }
2574     }
2575     public static final com.google.protobuf.Descriptors.Descriptor
2576         getDescriptor() {
2577       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2578     }
2579
2580     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2581         internalGetFieldAccessorTable() {
2582       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2583           .ensureFieldAccessorsInitialized(
2584               com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2585     }
2586
2587     public static com.google.protobuf.Parser<ControlCommand> PARSER =
2588         new com.google.protobuf.AbstractParser<ControlCommand>() {
2589       public ControlCommand parsePartialFrom(
2590           com.google.protobuf.CodedInputStream input,
2591           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2592           throws com.google.protobuf.InvalidProtocolBufferException {
2593         return new ControlCommand(input, extensionRegistry);
2594       }
2595     };
2596
2597     @java.lang.Override
2598     public com.google.protobuf.Parser<ControlCommand> getParserForType() {
2599       return PARSER;
2600     }
2601
2602     /**
2603      * Protobuf enum {@code openxc.ControlCommand.Type}
2604      */
2605     public enum Type
2606         implements com.google.protobuf.ProtocolMessageEnum {
2607       /**
2608        * <code>VERSION = 1;</code>
2609        */
2610       VERSION(0, 1),
2611       /**
2612        * <code>DEVICE_ID = 2;</code>
2613        */
2614       DEVICE_ID(1, 2),
2615       /**
2616        * <code>DIAGNOSTIC = 3;</code>
2617        */
2618       DIAGNOSTIC(2, 3),
2619       /**
2620        * <code>PASSTHROUGH = 4;</code>
2621        */
2622       PASSTHROUGH(3, 4),
2623       /**
2624        * <code>ACCEPTANCE_FILTER_BYPASS = 5;</code>
2625        */
2626       ACCEPTANCE_FILTER_BYPASS(4, 5),
2627       /**
2628        * <code>PAYLOAD_FORMAT = 6;</code>
2629        */
2630       PAYLOAD_FORMAT(5, 6),
2631       /**
2632        * <code>PREDEFINED_OBD2_REQUESTS = 7;</code>
2633        */
2634       PREDEFINED_OBD2_REQUESTS(6, 7),
2635       /**
2636        * <code>MODEM_CONFIGURATION = 8;</code>
2637        */
2638       MODEM_CONFIGURATION(7, 8),
2639       /**
2640        * <code>RTC_CONFIGURATION = 9;</code>
2641        */
2642       RTC_CONFIGURATION(8, 9),
2643       /**
2644        * <code>SD_MOUNT_STATUS = 10;</code>
2645        */
2646       SD_MOUNT_STATUS(9, 10),
2647       ;
2648
2649       /**
2650        * <code>VERSION = 1;</code>
2651        */
2652       public static final int VERSION_VALUE = 1;
2653       /**
2654        * <code>DEVICE_ID = 2;</code>
2655        */
2656       public static final int DEVICE_ID_VALUE = 2;
2657       /**
2658        * <code>DIAGNOSTIC = 3;</code>
2659        */
2660       public static final int DIAGNOSTIC_VALUE = 3;
2661       /**
2662        * <code>PASSTHROUGH = 4;</code>
2663        */
2664       public static final int PASSTHROUGH_VALUE = 4;
2665       /**
2666        * <code>ACCEPTANCE_FILTER_BYPASS = 5;</code>
2667        */
2668       public static final int ACCEPTANCE_FILTER_BYPASS_VALUE = 5;
2669       /**
2670        * <code>PAYLOAD_FORMAT = 6;</code>
2671        */
2672       public static final int PAYLOAD_FORMAT_VALUE = 6;
2673       /**
2674        * <code>PREDEFINED_OBD2_REQUESTS = 7;</code>
2675        */
2676       public static final int PREDEFINED_OBD2_REQUESTS_VALUE = 7;
2677       /**
2678        * <code>MODEM_CONFIGURATION = 8;</code>
2679        */
2680       public static final int MODEM_CONFIGURATION_VALUE = 8;
2681       /**
2682        * <code>RTC_CONFIGURATION = 9;</code>
2683        */
2684       public static final int RTC_CONFIGURATION_VALUE = 9;
2685       /**
2686        * <code>SD_MOUNT_STATUS = 10;</code>
2687        */
2688       public static final int SD_MOUNT_STATUS_VALUE = 10;
2689
2690
2691       public final int getNumber() { return value; }
2692
2693       public static Type valueOf(int value) {
2694         switch (value) {
2695           case 1: return VERSION;
2696           case 2: return DEVICE_ID;
2697           case 3: return DIAGNOSTIC;
2698           case 4: return PASSTHROUGH;
2699           case 5: return ACCEPTANCE_FILTER_BYPASS;
2700           case 6: return PAYLOAD_FORMAT;
2701           case 7: return PREDEFINED_OBD2_REQUESTS;
2702           case 8: return MODEM_CONFIGURATION;
2703           case 9: return RTC_CONFIGURATION;
2704           case 10: return SD_MOUNT_STATUS;
2705           default: return null;
2706         }
2707       }
2708
2709       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2710           internalGetValueMap() {
2711         return internalValueMap;
2712       }
2713       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2714           internalValueMap =
2715             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2716               public Type findValueByNumber(int number) {
2717                 return Type.valueOf(number);
2718               }
2719             };
2720
2721       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2722           getValueDescriptor() {
2723         return getDescriptor().getValues().get(index);
2724       }
2725       public final com.google.protobuf.Descriptors.EnumDescriptor
2726           getDescriptorForType() {
2727         return getDescriptor();
2728       }
2729       public static final com.google.protobuf.Descriptors.EnumDescriptor
2730           getDescriptor() {
2731         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
2732       }
2733
2734       private static final Type[] VALUES = values();
2735
2736       public static Type valueOf(
2737           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2738         if (desc.getType() != getDescriptor()) {
2739           throw new java.lang.IllegalArgumentException(
2740             "EnumValueDescriptor is not for this type.");
2741         }
2742         return VALUES[desc.getIndex()];
2743       }
2744
2745       private final int index;
2746       private final int value;
2747
2748       private Type(int index, int value) {
2749         this.index = index;
2750         this.value = value;
2751       }
2752
2753       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
2754     }
2755
2756     private int bitField0_;
2757     // optional .openxc.ControlCommand.Type type = 1;
2758     public static final int TYPE_FIELD_NUMBER = 1;
2759     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2760     /**
2761      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2762      */
2763     public boolean hasType() {
2764       return ((bitField0_ & 0x00000001) == 0x00000001);
2765     }
2766     /**
2767      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2768      */
2769     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2770       return type_;
2771     }
2772
2773     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2774     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
2775     private com.openxc.BinaryMessages.DiagnosticControlCommand diagnosticRequest_;
2776     /**
2777      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2778      */
2779     public boolean hasDiagnosticRequest() {
2780       return ((bitField0_ & 0x00000002) == 0x00000002);
2781     }
2782     /**
2783      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2784      */
2785     public com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest() {
2786       return diagnosticRequest_;
2787     }
2788     /**
2789      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2790      */
2791     public com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder() {
2792       return diagnosticRequest_;
2793     }
2794
2795     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2796     public static final int PASSTHROUGH_MODE_REQUEST_FIELD_NUMBER = 3;
2797     private com.openxc.BinaryMessages.PassthroughModeControlCommand passthroughModeRequest_;
2798     /**
2799      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2800      */
2801     public boolean hasPassthroughModeRequest() {
2802       return ((bitField0_ & 0x00000004) == 0x00000004);
2803     }
2804     /**
2805      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2806      */
2807     public com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest() {
2808       return passthroughModeRequest_;
2809     }
2810     /**
2811      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2812      */
2813     public com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder() {
2814       return passthroughModeRequest_;
2815     }
2816
2817     // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
2818     public static final int ACCEPTANCE_FILTER_BYPASS_COMMAND_FIELD_NUMBER = 4;
2819     private com.openxc.BinaryMessages.AcceptanceFilterBypassCommand acceptanceFilterBypassCommand_;
2820     /**
2821      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2822      */
2823     public boolean hasAcceptanceFilterBypassCommand() {
2824       return ((bitField0_ & 0x00000008) == 0x00000008);
2825     }
2826     /**
2827      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2828      */
2829     public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand() {
2830       return acceptanceFilterBypassCommand_;
2831     }
2832     /**
2833      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2834      */
2835     public com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder() {
2836       return acceptanceFilterBypassCommand_;
2837     }
2838
2839     // optional .openxc.PayloadFormatCommand payload_format_command = 5;
2840     public static final int PAYLOAD_FORMAT_COMMAND_FIELD_NUMBER = 5;
2841     private com.openxc.BinaryMessages.PayloadFormatCommand payloadFormatCommand_;
2842     /**
2843      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2844      */
2845     public boolean hasPayloadFormatCommand() {
2846       return ((bitField0_ & 0x00000010) == 0x00000010);
2847     }
2848     /**
2849      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2850      */
2851     public com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand() {
2852       return payloadFormatCommand_;
2853     }
2854     /**
2855      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2856      */
2857     public com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder() {
2858       return payloadFormatCommand_;
2859     }
2860
2861     // optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;
2862     public static final int PREDEFINED_OBD2_REQUESTS_COMMAND_FIELD_NUMBER = 6;
2863     private com.openxc.BinaryMessages.PredefinedObd2RequestsCommand predefinedObd2RequestsCommand_;
2864     /**
2865      * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
2866      */
2867     public boolean hasPredefinedObd2RequestsCommand() {
2868       return ((bitField0_ & 0x00000020) == 0x00000020);
2869     }
2870     /**
2871      * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
2872      */
2873     public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getPredefinedObd2RequestsCommand() {
2874       return predefinedObd2RequestsCommand_;
2875     }
2876     /**
2877      * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
2878      */
2879     public com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder getPredefinedObd2RequestsCommandOrBuilder() {
2880       return predefinedObd2RequestsCommand_;
2881     }
2882
2883     // optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;
2884     public static final int MODEM_CONFIGURATION_COMMAND_FIELD_NUMBER = 7;
2885     private com.openxc.BinaryMessages.ModemConfigurationCommand modemConfigurationCommand_;
2886     /**
2887      * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
2888      */
2889     public boolean hasModemConfigurationCommand() {
2890       return ((bitField0_ & 0x00000040) == 0x00000040);
2891     }
2892     /**
2893      * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
2894      */
2895     public com.openxc.BinaryMessages.ModemConfigurationCommand getModemConfigurationCommand() {
2896       return modemConfigurationCommand_;
2897     }
2898     /**
2899      * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
2900      */
2901     public com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder getModemConfigurationCommandOrBuilder() {
2902       return modemConfigurationCommand_;
2903     }
2904
2905     // optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;
2906     public static final int RTC_CONFIGURATION_COMMAND_FIELD_NUMBER = 8;
2907     private com.openxc.BinaryMessages.RTCConfigurationCommand rtcConfigurationCommand_;
2908     /**
2909      * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
2910      */
2911     public boolean hasRtcConfigurationCommand() {
2912       return ((bitField0_ & 0x00000080) == 0x00000080);
2913     }
2914     /**
2915      * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
2916      */
2917     public com.openxc.BinaryMessages.RTCConfigurationCommand getRtcConfigurationCommand() {
2918       return rtcConfigurationCommand_;
2919     }
2920     /**
2921      * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
2922      */
2923     public com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder getRtcConfigurationCommandOrBuilder() {
2924       return rtcConfigurationCommand_;
2925     }
2926
2927     private void initFields() {
2928       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2929       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2930       passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2931       acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
2932       payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
2933       predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
2934       modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
2935       rtcConfigurationCommand_ = com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance();
2936     }
2937     private byte memoizedIsInitialized = -1;
2938     public final boolean isInitialized() {
2939       byte isInitialized = memoizedIsInitialized;
2940       if (isInitialized != -1) return isInitialized == 1;
2941
2942       memoizedIsInitialized = 1;
2943       return true;
2944     }
2945
2946     public void writeTo(com.google.protobuf.CodedOutputStream output)
2947                         throws java.io.IOException {
2948       getSerializedSize();
2949       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2950         output.writeEnum(1, type_.getNumber());
2951       }
2952       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2953         output.writeMessage(2, diagnosticRequest_);
2954       }
2955       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2956         output.writeMessage(3, passthroughModeRequest_);
2957       }
2958       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2959         output.writeMessage(4, acceptanceFilterBypassCommand_);
2960       }
2961       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2962         output.writeMessage(5, payloadFormatCommand_);
2963       }
2964       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2965         output.writeMessage(6, predefinedObd2RequestsCommand_);
2966       }
2967       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2968         output.writeMessage(7, modemConfigurationCommand_);
2969       }
2970       if (((bitField0_ & 0x00000080) == 0x00000080)) {
2971         output.writeMessage(8, rtcConfigurationCommand_);
2972       }
2973       getUnknownFields().writeTo(output);
2974     }
2975
2976     private int memoizedSerializedSize = -1;
2977     public int getSerializedSize() {
2978       int size = memoizedSerializedSize;
2979       if (size != -1) return size;
2980
2981       size = 0;
2982       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2983         size += com.google.protobuf.CodedOutputStream
2984           .computeEnumSize(1, type_.getNumber());
2985       }
2986       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2987         size += com.google.protobuf.CodedOutputStream
2988           .computeMessageSize(2, diagnosticRequest_);
2989       }
2990       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2991         size += com.google.protobuf.CodedOutputStream
2992           .computeMessageSize(3, passthroughModeRequest_);
2993       }
2994       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2995         size += com.google.protobuf.CodedOutputStream
2996           .computeMessageSize(4, acceptanceFilterBypassCommand_);
2997       }
2998       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2999         size += com.google.protobuf.CodedOutputStream
3000           .computeMessageSize(5, payloadFormatCommand_);
3001       }
3002       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3003         size += com.google.protobuf.CodedOutputStream
3004           .computeMessageSize(6, predefinedObd2RequestsCommand_);
3005       }
3006       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3007         size += com.google.protobuf.CodedOutputStream
3008           .computeMessageSize(7, modemConfigurationCommand_);
3009       }
3010       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3011         size += com.google.protobuf.CodedOutputStream
3012           .computeMessageSize(8, rtcConfigurationCommand_);
3013       }
3014       size += getUnknownFields().getSerializedSize();
3015       memoizedSerializedSize = size;
3016       return size;
3017     }
3018
3019     private static final long serialVersionUID = 0L;
3020     @java.lang.Override
3021     protected java.lang.Object writeReplace()
3022         throws java.io.ObjectStreamException {
3023       return super.writeReplace();
3024     }
3025
3026     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
3027         com.google.protobuf.ByteString data)
3028         throws com.google.protobuf.InvalidProtocolBufferException {
3029       return PARSER.parseFrom(data);
3030     }
3031     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
3032         com.google.protobuf.ByteString data,
3033         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3034         throws com.google.protobuf.InvalidProtocolBufferException {
3035       return PARSER.parseFrom(data, extensionRegistry);
3036     }
3037     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
3038         throws com.google.protobuf.InvalidProtocolBufferException {
3039       return PARSER.parseFrom(data);
3040     }
3041     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
3042         byte[] data,
3043         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3044         throws com.google.protobuf.InvalidProtocolBufferException {
3045       return PARSER.parseFrom(data, extensionRegistry);
3046     }
3047     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
3048         throws java.io.IOException {
3049       return PARSER.parseFrom(input);
3050     }
3051     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
3052         java.io.InputStream input,
3053         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3054         throws java.io.IOException {
3055       return PARSER.parseFrom(input, extensionRegistry);
3056     }
3057     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
3058         throws java.io.IOException {
3059       return PARSER.parseDelimitedFrom(input);
3060     }
3061     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
3062         java.io.InputStream input,
3063         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3064         throws java.io.IOException {
3065       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3066     }
3067     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
3068         com.google.protobuf.CodedInputStream input)
3069         throws java.io.IOException {
3070       return PARSER.parseFrom(input);
3071     }
3072     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
3073         com.google.protobuf.CodedInputStream input,
3074         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3075         throws java.io.IOException {
3076       return PARSER.parseFrom(input, extensionRegistry);
3077     }
3078
3079     public static Builder newBuilder() { return Builder.create(); }
3080     public Builder newBuilderForType() { return newBuilder(); }
3081     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
3082       return newBuilder().mergeFrom(prototype);
3083     }
3084     public Builder toBuilder() { return newBuilder(this); }
3085
3086     @java.lang.Override
3087     protected Builder newBuilderForType(
3088         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3089       Builder builder = new Builder(parent);
3090       return builder;
3091     }
3092     /**
3093      * Protobuf type {@code openxc.ControlCommand}
3094      */
3095     public static final class Builder extends
3096         com.google.protobuf.GeneratedMessage.Builder<Builder>
3097        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
3098       public static final com.google.protobuf.Descriptors.Descriptor
3099           getDescriptor() {
3100         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
3101       }
3102
3103       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3104           internalGetFieldAccessorTable() {
3105         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
3106             .ensureFieldAccessorsInitialized(
3107                 com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
3108       }
3109
3110       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
3111       private Builder() {
3112         maybeForceBuilderInitialization();
3113       }
3114
3115       private Builder(
3116           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3117         super(parent);
3118         maybeForceBuilderInitialization();
3119       }
3120       private void maybeForceBuilderInitialization() {
3121         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3122           getDiagnosticRequestFieldBuilder();
3123           getPassthroughModeRequestFieldBuilder();
3124           getAcceptanceFilterBypassCommandFieldBuilder();
3125           getPayloadFormatCommandFieldBuilder();
3126           getPredefinedObd2RequestsCommandFieldBuilder();
3127           getModemConfigurationCommandFieldBuilder();
3128           getRtcConfigurationCommandFieldBuilder();
3129         }
3130       }
3131       private static Builder create() {
3132         return new Builder();
3133       }
3134
3135       public Builder clear() {
3136         super.clear();
3137         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3138         bitField0_ = (bitField0_ & ~0x00000001);
3139         if (diagnosticRequestBuilder_ == null) {
3140           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
3141         } else {
3142           diagnosticRequestBuilder_.clear();
3143         }
3144         bitField0_ = (bitField0_ & ~0x00000002);
3145         if (passthroughModeRequestBuilder_ == null) {
3146           passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
3147         } else {
3148           passthroughModeRequestBuilder_.clear();
3149         }
3150         bitField0_ = (bitField0_ & ~0x00000004);
3151         if (acceptanceFilterBypassCommandBuilder_ == null) {
3152           acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
3153         } else {
3154           acceptanceFilterBypassCommandBuilder_.clear();
3155         }
3156         bitField0_ = (bitField0_ & ~0x00000008);
3157         if (payloadFormatCommandBuilder_ == null) {
3158           payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
3159         } else {
3160           payloadFormatCommandBuilder_.clear();
3161         }
3162         bitField0_ = (bitField0_ & ~0x00000010);
3163         if (predefinedObd2RequestsCommandBuilder_ == null) {
3164           predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
3165         } else {
3166           predefinedObd2RequestsCommandBuilder_.clear();
3167         }
3168         bitField0_ = (bitField0_ & ~0x00000020);
3169         if (modemConfigurationCommandBuilder_ == null) {
3170           modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
3171         } else {
3172           modemConfigurationCommandBuilder_.clear();
3173         }
3174         bitField0_ = (bitField0_ & ~0x00000040);
3175         if (rtcConfigurationCommandBuilder_ == null) {
3176           rtcConfigurationCommand_ = com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance();
3177         } else {
3178           rtcConfigurationCommandBuilder_.clear();
3179         }
3180         bitField0_ = (bitField0_ & ~0x00000080);
3181         return this;
3182       }
3183
3184       public Builder clone() {
3185         return create().mergeFrom(buildPartial());
3186       }
3187
3188       public com.google.protobuf.Descriptors.Descriptor
3189           getDescriptorForType() {
3190         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
3191       }
3192
3193       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
3194         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
3195       }
3196
3197       public com.openxc.BinaryMessages.ControlCommand build() {
3198         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
3199         if (!result.isInitialized()) {
3200           throw newUninitializedMessageException(result);
3201         }
3202         return result;
3203       }
3204
3205       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
3206         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
3207         int from_bitField0_ = bitField0_;
3208         int to_bitField0_ = 0;
3209         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3210           to_bitField0_ |= 0x00000001;
3211         }
3212         result.type_ = type_;
3213         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3214           to_bitField0_ |= 0x00000002;
3215         }
3216         if (diagnosticRequestBuilder_ == null) {
3217           result.diagnosticRequest_ = diagnosticRequest_;
3218         } else {
3219           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
3220         }
3221         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
3222           to_bitField0_ |= 0x00000004;
3223         }
3224         if (passthroughModeRequestBuilder_ == null) {
3225           result.passthroughModeRequest_ = passthroughModeRequest_;
3226         } else {
3227           result.passthroughModeRequest_ = passthroughModeRequestBuilder_.build();
3228         }
3229         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
3230           to_bitField0_ |= 0x00000008;
3231         }
3232         if (acceptanceFilterBypassCommandBuilder_ == null) {
3233           result.acceptanceFilterBypassCommand_ = acceptanceFilterBypassCommand_;
3234         } else {
3235           result.acceptanceFilterBypassCommand_ = acceptanceFilterBypassCommandBuilder_.build();
3236         }
3237         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
3238           to_bitField0_ |= 0x00000010;
3239         }
3240         if (payloadFormatCommandBuilder_ == null) {
3241           result.payloadFormatCommand_ = payloadFormatCommand_;
3242         } else {
3243           result.payloadFormatCommand_ = payloadFormatCommandBuilder_.build();
3244         }
3245         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
3246           to_bitField0_ |= 0x00000020;
3247         }
3248         if (predefinedObd2RequestsCommandBuilder_ == null) {
3249           result.predefinedObd2RequestsCommand_ = predefinedObd2RequestsCommand_;
3250         } else {
3251           result.predefinedObd2RequestsCommand_ = predefinedObd2RequestsCommandBuilder_.build();
3252         }
3253         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
3254           to_bitField0_ |= 0x00000040;
3255         }
3256         if (modemConfigurationCommandBuilder_ == null) {
3257           result.modemConfigurationCommand_ = modemConfigurationCommand_;
3258         } else {
3259           result.modemConfigurationCommand_ = modemConfigurationCommandBuilder_.build();
3260         }
3261         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
3262           to_bitField0_ |= 0x00000080;
3263         }
3264         if (rtcConfigurationCommandBuilder_ == null) {
3265           result.rtcConfigurationCommand_ = rtcConfigurationCommand_;
3266         } else {
3267           result.rtcConfigurationCommand_ = rtcConfigurationCommandBuilder_.build();
3268         }
3269         result.bitField0_ = to_bitField0_;
3270         onBuilt();
3271         return result;
3272       }
3273
3274       public Builder mergeFrom(com.google.protobuf.Message other) {
3275         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
3276           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
3277         } else {
3278           super.mergeFrom(other);
3279           return this;
3280         }
3281       }
3282
3283       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
3284         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
3285         if (other.hasType()) {
3286           setType(other.getType());
3287         }
3288         if (other.hasDiagnosticRequest()) {
3289           mergeDiagnosticRequest(other.getDiagnosticRequest());
3290         }
3291         if (other.hasPassthroughModeRequest()) {
3292           mergePassthroughModeRequest(other.getPassthroughModeRequest());
3293         }
3294         if (other.hasAcceptanceFilterBypassCommand()) {
3295           mergeAcceptanceFilterBypassCommand(other.getAcceptanceFilterBypassCommand());
3296         }
3297         if (other.hasPayloadFormatCommand()) {
3298           mergePayloadFormatCommand(other.getPayloadFormatCommand());
3299         }
3300         if (other.hasPredefinedObd2RequestsCommand()) {
3301           mergePredefinedObd2RequestsCommand(other.getPredefinedObd2RequestsCommand());
3302         }
3303         if (other.hasModemConfigurationCommand()) {
3304           mergeModemConfigurationCommand(other.getModemConfigurationCommand());
3305         }
3306         if (other.hasRtcConfigurationCommand()) {
3307           mergeRtcConfigurationCommand(other.getRtcConfigurationCommand());
3308         }
3309         this.mergeUnknownFields(other.getUnknownFields());
3310         return this;
3311       }
3312
3313       public final boolean isInitialized() {
3314         return true;
3315       }
3316
3317       public Builder mergeFrom(
3318           com.google.protobuf.CodedInputStream input,
3319           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3320           throws java.io.IOException {
3321         com.openxc.BinaryMessages.ControlCommand parsedMessage = null;
3322         try {
3323           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3324         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3325           parsedMessage = (com.openxc.BinaryMessages.ControlCommand) e.getUnfinishedMessage();
3326           throw e;
3327         } finally {
3328           if (parsedMessage != null) {
3329             mergeFrom(parsedMessage);
3330           }
3331         }
3332         return this;
3333       }
3334       private int bitField0_;
3335
3336       // optional .openxc.ControlCommand.Type type = 1;
3337       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3338       /**
3339        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3340        */
3341       public boolean hasType() {
3342         return ((bitField0_ & 0x00000001) == 0x00000001);
3343       }
3344       /**
3345        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3346        */
3347       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
3348         return type_;
3349       }
3350       /**
3351        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3352        */
3353       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
3354         if (value == null) {
3355           throw new NullPointerException();
3356         }
3357         bitField0_ |= 0x00000001;
3358         type_ = value;
3359         onChanged();
3360         return this;
3361       }
3362       /**
3363        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3364        */
3365       public Builder clearType() {
3366         bitField0_ = (bitField0_ & ~0x00000001);
3367         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3368         onChanged();
3369         return this;
3370       }
3371
3372       // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
3373       private com.openxc.BinaryMessages.DiagnosticControlCommand diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
3374       private com.google.protobuf.SingleFieldBuilder<
3375           com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder> diagnosticRequestBuilder_;
3376       /**
3377        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3378        */
3379       public boolean hasDiagnosticRequest() {
3380         return ((bitField0_ & 0x00000002) == 0x00000002);
3381       }
3382       /**
3383        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3384        */
3385       public com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest() {
3386         if (diagnosticRequestBuilder_ == null) {
3387           return diagnosticRequest_;
3388         } else {
3389           return diagnosticRequestBuilder_.getMessage();
3390         }
3391       }
3392       /**
3393        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3394        */
3395       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticControlCommand value) {
3396         if (diagnosticRequestBuilder_ == null) {
3397           if (value == null) {
3398             throw new NullPointerException();
3399           }
3400           diagnosticRequest_ = value;
3401           onChanged();
3402         } else {
3403           diagnosticRequestBuilder_.setMessage(value);
3404         }
3405         bitField0_ |= 0x00000002;
3406         return this;
3407       }
3408       /**
3409        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3410        */
3411       public Builder setDiagnosticRequest(
3412           com.openxc.BinaryMessages.DiagnosticControlCommand.Builder builderForValue) {
3413         if (diagnosticRequestBuilder_ == null) {
3414           diagnosticRequest_ = builderForValue.build();
3415           onChanged();
3416         } else {
3417           diagnosticRequestBuilder_.setMessage(builderForValue.build());
3418         }
3419         bitField0_ |= 0x00000002;
3420         return this;
3421       }
3422       /**
3423        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3424        */
3425       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticControlCommand value) {
3426         if (diagnosticRequestBuilder_ == null) {
3427           if (((bitField0_ & 0x00000002) == 0x00000002) &&
3428               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance()) {
3429             diagnosticRequest_ =
3430               com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
3431           } else {
3432             diagnosticRequest_ = value;
3433           }
3434           onChanged();
3435         } else {
3436           diagnosticRequestBuilder_.mergeFrom(value);
3437         }
3438         bitField0_ |= 0x00000002;
3439         return this;
3440       }
3441       /**
3442        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3443        */
3444       public Builder clearDiagnosticRequest() {
3445         if (diagnosticRequestBuilder_ == null) {
3446           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
3447           onChanged();
3448         } else {
3449           diagnosticRequestBuilder_.clear();
3450         }
3451         bitField0_ = (bitField0_ & ~0x00000002);
3452         return this;
3453       }
3454       /**
3455        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3456        */
3457       public com.openxc.BinaryMessages.DiagnosticControlCommand.Builder getDiagnosticRequestBuilder() {
3458         bitField0_ |= 0x00000002;
3459         onChanged();
3460         return getDiagnosticRequestFieldBuilder().getBuilder();
3461       }
3462       /**
3463        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3464        */
3465       public com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder() {
3466         if (diagnosticRequestBuilder_ != null) {
3467           return diagnosticRequestBuilder_.getMessageOrBuilder();
3468         } else {
3469           return diagnosticRequest_;
3470         }
3471       }
3472       /**
3473        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
3474        */
3475       private com.google.protobuf.SingleFieldBuilder<
3476           com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder>
3477           getDiagnosticRequestFieldBuilder() {
3478         if (diagnosticRequestBuilder_ == null) {
3479           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3480               com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder>(
3481                   diagnosticRequest_,
3482                   getParentForChildren(),
3483                   isClean());
3484           diagnosticRequest_ = null;
3485         }
3486         return diagnosticRequestBuilder_;
3487       }
3488
3489       // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
3490       private com.openxc.BinaryMessages.PassthroughModeControlCommand passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
3491       private com.google.protobuf.SingleFieldBuilder<
3492           com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder> passthroughModeRequestBuilder_;
3493       /**
3494        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3495        */
3496       public boolean hasPassthroughModeRequest() {
3497         return ((bitField0_ & 0x00000004) == 0x00000004);
3498       }
3499       /**
3500        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3501        */
3502       public com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest() {
3503         if (passthroughModeRequestBuilder_ == null) {
3504           return passthroughModeRequest_;
3505         } else {
3506           return passthroughModeRequestBuilder_.getMessage();
3507         }
3508       }
3509       /**
3510        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3511        */
3512       public Builder setPassthroughModeRequest(com.openxc.BinaryMessages.PassthroughModeControlCommand value) {
3513         if (passthroughModeRequestBuilder_ == null) {
3514           if (value == null) {
3515             throw new NullPointerException();
3516           }
3517           passthroughModeRequest_ = value;
3518           onChanged();
3519         } else {
3520           passthroughModeRequestBuilder_.setMessage(value);
3521         }
3522         bitField0_ |= 0x00000004;
3523         return this;
3524       }
3525       /**
3526        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3527        */
3528       public Builder setPassthroughModeRequest(
3529           com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder builderForValue) {
3530         if (passthroughModeRequestBuilder_ == null) {
3531           passthroughModeRequest_ = builderForValue.build();
3532           onChanged();
3533         } else {
3534           passthroughModeRequestBuilder_.setMessage(builderForValue.build());
3535         }
3536         bitField0_ |= 0x00000004;
3537         return this;
3538       }
3539       /**
3540        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3541        */
3542       public Builder mergePassthroughModeRequest(com.openxc.BinaryMessages.PassthroughModeControlCommand value) {
3543         if (passthroughModeRequestBuilder_ == null) {
3544           if (((bitField0_ & 0x00000004) == 0x00000004) &&
3545               passthroughModeRequest_ != com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance()) {
3546             passthroughModeRequest_ =
3547               com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder(passthroughModeRequest_).mergeFrom(value).buildPartial();
3548           } else {
3549             passthroughModeRequest_ = value;
3550           }
3551           onChanged();
3552         } else {
3553           passthroughModeRequestBuilder_.mergeFrom(value);
3554         }
3555         bitField0_ |= 0x00000004;
3556         return this;
3557       }
3558       /**
3559        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3560        */
3561       public Builder clearPassthroughModeRequest() {
3562         if (passthroughModeRequestBuilder_ == null) {
3563           passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
3564           onChanged();
3565         } else {
3566           passthroughModeRequestBuilder_.clear();
3567         }
3568         bitField0_ = (bitField0_ & ~0x00000004);
3569         return this;
3570       }
3571       /**
3572        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3573        */
3574       public com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder getPassthroughModeRequestBuilder() {
3575         bitField0_ |= 0x00000004;
3576         onChanged();
3577         return getPassthroughModeRequestFieldBuilder().getBuilder();
3578       }
3579       /**
3580        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3581        */
3582       public com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder() {
3583         if (passthroughModeRequestBuilder_ != null) {
3584           return passthroughModeRequestBuilder_.getMessageOrBuilder();
3585         } else {
3586           return passthroughModeRequest_;
3587         }
3588       }
3589       /**
3590        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
3591        */
3592       private com.google.protobuf.SingleFieldBuilder<
3593           com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder>
3594           getPassthroughModeRequestFieldBuilder() {
3595         if (passthroughModeRequestBuilder_ == null) {
3596           passthroughModeRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3597               com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder>(
3598                   passthroughModeRequest_,
3599                   getParentForChildren(),
3600                   isClean());
3601           passthroughModeRequest_ = null;
3602         }
3603         return passthroughModeRequestBuilder_;
3604       }
3605
3606       // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
3607       private com.openxc.BinaryMessages.AcceptanceFilterBypassCommand acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
3608       private com.google.protobuf.SingleFieldBuilder<
3609           com.openxc.BinaryMessages.AcceptanceFilterBypassCommand, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder, com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder> acceptanceFilterBypassCommandBuilder_;
3610       /**
3611        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3612        */
3613       public boolean hasAcceptanceFilterBypassCommand() {
3614         return ((bitField0_ & 0x00000008) == 0x00000008);
3615       }
3616       /**
3617        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3618        */
3619       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand() {
3620         if (acceptanceFilterBypassCommandBuilder_ == null) {
3621           return acceptanceFilterBypassCommand_;
3622         } else {
3623           return acceptanceFilterBypassCommandBuilder_.getMessage();
3624         }
3625       }
3626       /**
3627        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3628        */
3629       public Builder setAcceptanceFilterBypassCommand(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand value) {
3630         if (acceptanceFilterBypassCommandBuilder_ == null) {
3631           if (value == null) {
3632             throw new NullPointerException();
3633           }
3634           acceptanceFilterBypassCommand_ = value;
3635           onChanged();
3636         } else {
3637           acceptanceFilterBypassCommandBuilder_.setMessage(value);
3638         }
3639         bitField0_ |= 0x00000008;
3640         return this;
3641       }
3642       /**
3643        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3644        */
3645       public Builder setAcceptanceFilterBypassCommand(
3646           com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder builderForValue) {
3647         if (acceptanceFilterBypassCommandBuilder_ == null) {
3648           acceptanceFilterBypassCommand_ = builderForValue.build();
3649           onChanged();
3650         } else {
3651           acceptanceFilterBypassCommandBuilder_.setMessage(builderForValue.build());
3652         }
3653         bitField0_ |= 0x00000008;
3654         return this;
3655       }
3656       /**
3657        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3658        */
3659       public Builder mergeAcceptanceFilterBypassCommand(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand value) {
3660         if (acceptanceFilterBypassCommandBuilder_ == null) {
3661           if (((bitField0_ & 0x00000008) == 0x00000008) &&
3662               acceptanceFilterBypassCommand_ != com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance()) {
3663             acceptanceFilterBypassCommand_ =
3664               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.newBuilder(acceptanceFilterBypassCommand_).mergeFrom(value).buildPartial();
3665           } else {
3666             acceptanceFilterBypassCommand_ = value;
3667           }
3668           onChanged();
3669         } else {
3670           acceptanceFilterBypassCommandBuilder_.mergeFrom(value);
3671         }
3672         bitField0_ |= 0x00000008;
3673         return this;
3674       }
3675       /**
3676        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3677        */
3678       public Builder clearAcceptanceFilterBypassCommand() {
3679         if (acceptanceFilterBypassCommandBuilder_ == null) {
3680           acceptanceFilterBypassCommand_ = com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
3681           onChanged();
3682         } else {
3683           acceptanceFilterBypassCommandBuilder_.clear();
3684         }
3685         bitField0_ = (bitField0_ & ~0x00000008);
3686         return this;
3687       }
3688       /**
3689        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3690        */
3691       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder getAcceptanceFilterBypassCommandBuilder() {
3692         bitField0_ |= 0x00000008;
3693         onChanged();
3694         return getAcceptanceFilterBypassCommandFieldBuilder().getBuilder();
3695       }
3696       /**
3697        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3698        */
3699       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder() {
3700         if (acceptanceFilterBypassCommandBuilder_ != null) {
3701           return acceptanceFilterBypassCommandBuilder_.getMessageOrBuilder();
3702         } else {
3703           return acceptanceFilterBypassCommand_;
3704         }
3705       }
3706       /**
3707        * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
3708        */
3709       private com.google.protobuf.SingleFieldBuilder<
3710           com.openxc.BinaryMessages.AcceptanceFilterBypassCommand, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder, com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder>
3711           getAcceptanceFilterBypassCommandFieldBuilder() {
3712         if (acceptanceFilterBypassCommandBuilder_ == null) {
3713           acceptanceFilterBypassCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3714               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder, com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder>(
3715                   acceptanceFilterBypassCommand_,
3716                   getParentForChildren(),
3717                   isClean());
3718           acceptanceFilterBypassCommand_ = null;
3719         }
3720         return acceptanceFilterBypassCommandBuilder_;
3721       }
3722
3723       // optional .openxc.PayloadFormatCommand payload_format_command = 5;
3724       private com.openxc.BinaryMessages.PayloadFormatCommand payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
3725       private com.google.protobuf.SingleFieldBuilder<
3726           com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder> payloadFormatCommandBuilder_;
3727       /**
3728        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3729        */
3730       public boolean hasPayloadFormatCommand() {
3731         return ((bitField0_ & 0x00000010) == 0x00000010);
3732       }
3733       /**
3734        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3735        */
3736       public com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand() {
3737         if (payloadFormatCommandBuilder_ == null) {
3738           return payloadFormatCommand_;
3739         } else {
3740           return payloadFormatCommandBuilder_.getMessage();
3741         }
3742       }
3743       /**
3744        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3745        */
3746       public Builder setPayloadFormatCommand(com.openxc.BinaryMessages.PayloadFormatCommand value) {
3747         if (payloadFormatCommandBuilder_ == null) {
3748           if (value == null) {
3749             throw new NullPointerException();
3750           }
3751           payloadFormatCommand_ = value;
3752           onChanged();
3753         } else {
3754           payloadFormatCommandBuilder_.setMessage(value);
3755         }
3756         bitField0_ |= 0x00000010;
3757         return this;
3758       }
3759       /**
3760        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3761        */
3762       public Builder setPayloadFormatCommand(
3763           com.openxc.BinaryMessages.PayloadFormatCommand.Builder builderForValue) {
3764         if (payloadFormatCommandBuilder_ == null) {
3765           payloadFormatCommand_ = builderForValue.build();
3766           onChanged();
3767         } else {
3768           payloadFormatCommandBuilder_.setMessage(builderForValue.build());
3769         }
3770         bitField0_ |= 0x00000010;
3771         return this;
3772       }
3773       /**
3774        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3775        */
3776       public Builder mergePayloadFormatCommand(com.openxc.BinaryMessages.PayloadFormatCommand value) {
3777         if (payloadFormatCommandBuilder_ == null) {
3778           if (((bitField0_ & 0x00000010) == 0x00000010) &&
3779               payloadFormatCommand_ != com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance()) {
3780             payloadFormatCommand_ =
3781               com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder(payloadFormatCommand_).mergeFrom(value).buildPartial();
3782           } else {
3783             payloadFormatCommand_ = value;
3784           }
3785           onChanged();
3786         } else {
3787           payloadFormatCommandBuilder_.mergeFrom(value);
3788         }
3789         bitField0_ |= 0x00000010;
3790         return this;
3791       }
3792       /**
3793        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3794        */
3795       public Builder clearPayloadFormatCommand() {
3796         if (payloadFormatCommandBuilder_ == null) {
3797           payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
3798           onChanged();
3799         } else {
3800           payloadFormatCommandBuilder_.clear();
3801         }
3802         bitField0_ = (bitField0_ & ~0x00000010);
3803         return this;
3804       }
3805       /**
3806        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3807        */
3808       public com.openxc.BinaryMessages.PayloadFormatCommand.Builder getPayloadFormatCommandBuilder() {
3809         bitField0_ |= 0x00000010;
3810         onChanged();
3811         return getPayloadFormatCommandFieldBuilder().getBuilder();
3812       }
3813       /**
3814        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3815        */
3816       public com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder() {
3817         if (payloadFormatCommandBuilder_ != null) {
3818           return payloadFormatCommandBuilder_.getMessageOrBuilder();
3819         } else {
3820           return payloadFormatCommand_;
3821         }
3822       }
3823       /**
3824        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3825        */
3826       private com.google.protobuf.SingleFieldBuilder<
3827           com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder>
3828           getPayloadFormatCommandFieldBuilder() {
3829         if (payloadFormatCommandBuilder_ == null) {
3830           payloadFormatCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3831               com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder>(
3832                   payloadFormatCommand_,
3833                   getParentForChildren(),
3834                   isClean());
3835           payloadFormatCommand_ = null;
3836         }
3837         return payloadFormatCommandBuilder_;
3838       }
3839
3840       // optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;
3841       private com.openxc.BinaryMessages.PredefinedObd2RequestsCommand predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
3842       private com.google.protobuf.SingleFieldBuilder<
3843           com.openxc.BinaryMessages.PredefinedObd2RequestsCommand, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder, com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder> predefinedObd2RequestsCommandBuilder_;
3844       /**
3845        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3846        */
3847       public boolean hasPredefinedObd2RequestsCommand() {
3848         return ((bitField0_ & 0x00000020) == 0x00000020);
3849       }
3850       /**
3851        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3852        */
3853       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getPredefinedObd2RequestsCommand() {
3854         if (predefinedObd2RequestsCommandBuilder_ == null) {
3855           return predefinedObd2RequestsCommand_;
3856         } else {
3857           return predefinedObd2RequestsCommandBuilder_.getMessage();
3858         }
3859       }
3860       /**
3861        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3862        */
3863       public Builder setPredefinedObd2RequestsCommand(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand value) {
3864         if (predefinedObd2RequestsCommandBuilder_ == null) {
3865           if (value == null) {
3866             throw new NullPointerException();
3867           }
3868           predefinedObd2RequestsCommand_ = value;
3869           onChanged();
3870         } else {
3871           predefinedObd2RequestsCommandBuilder_.setMessage(value);
3872         }
3873         bitField0_ |= 0x00000020;
3874         return this;
3875       }
3876       /**
3877        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3878        */
3879       public Builder setPredefinedObd2RequestsCommand(
3880           com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder builderForValue) {
3881         if (predefinedObd2RequestsCommandBuilder_ == null) {
3882           predefinedObd2RequestsCommand_ = builderForValue.build();
3883           onChanged();
3884         } else {
3885           predefinedObd2RequestsCommandBuilder_.setMessage(builderForValue.build());
3886         }
3887         bitField0_ |= 0x00000020;
3888         return this;
3889       }
3890       /**
3891        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3892        */
3893       public Builder mergePredefinedObd2RequestsCommand(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand value) {
3894         if (predefinedObd2RequestsCommandBuilder_ == null) {
3895           if (((bitField0_ & 0x00000020) == 0x00000020) &&
3896               predefinedObd2RequestsCommand_ != com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance()) {
3897             predefinedObd2RequestsCommand_ =
3898               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.newBuilder(predefinedObd2RequestsCommand_).mergeFrom(value).buildPartial();
3899           } else {
3900             predefinedObd2RequestsCommand_ = value;
3901           }
3902           onChanged();
3903         } else {
3904           predefinedObd2RequestsCommandBuilder_.mergeFrom(value);
3905         }
3906         bitField0_ |= 0x00000020;
3907         return this;
3908       }
3909       /**
3910        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3911        */
3912       public Builder clearPredefinedObd2RequestsCommand() {
3913         if (predefinedObd2RequestsCommandBuilder_ == null) {
3914           predefinedObd2RequestsCommand_ = com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
3915           onChanged();
3916         } else {
3917           predefinedObd2RequestsCommandBuilder_.clear();
3918         }
3919         bitField0_ = (bitField0_ & ~0x00000020);
3920         return this;
3921       }
3922       /**
3923        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3924        */
3925       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder getPredefinedObd2RequestsCommandBuilder() {
3926         bitField0_ |= 0x00000020;
3927         onChanged();
3928         return getPredefinedObd2RequestsCommandFieldBuilder().getBuilder();
3929       }
3930       /**
3931        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3932        */
3933       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder getPredefinedObd2RequestsCommandOrBuilder() {
3934         if (predefinedObd2RequestsCommandBuilder_ != null) {
3935           return predefinedObd2RequestsCommandBuilder_.getMessageOrBuilder();
3936         } else {
3937           return predefinedObd2RequestsCommand_;
3938         }
3939       }
3940       /**
3941        * <code>optional .openxc.PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6;</code>
3942        */
3943       private com.google.protobuf.SingleFieldBuilder<
3944           com.openxc.BinaryMessages.PredefinedObd2RequestsCommand, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder, com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder>
3945           getPredefinedObd2RequestsCommandFieldBuilder() {
3946         if (predefinedObd2RequestsCommandBuilder_ == null) {
3947           predefinedObd2RequestsCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3948               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder, com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder>(
3949                   predefinedObd2RequestsCommand_,
3950                   getParentForChildren(),
3951                   isClean());
3952           predefinedObd2RequestsCommand_ = null;
3953         }
3954         return predefinedObd2RequestsCommandBuilder_;
3955       }
3956
3957       // optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;
3958       private com.openxc.BinaryMessages.ModemConfigurationCommand modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
3959       private com.google.protobuf.SingleFieldBuilder<
3960           com.openxc.BinaryMessages.ModemConfigurationCommand, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder, com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder> modemConfigurationCommandBuilder_;
3961       /**
3962        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
3963        */
3964       public boolean hasModemConfigurationCommand() {
3965         return ((bitField0_ & 0x00000040) == 0x00000040);
3966       }
3967       /**
3968        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
3969        */
3970       public com.openxc.BinaryMessages.ModemConfigurationCommand getModemConfigurationCommand() {
3971         if (modemConfigurationCommandBuilder_ == null) {
3972           return modemConfigurationCommand_;
3973         } else {
3974           return modemConfigurationCommandBuilder_.getMessage();
3975         }
3976       }
3977       /**
3978        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
3979        */
3980       public Builder setModemConfigurationCommand(com.openxc.BinaryMessages.ModemConfigurationCommand value) {
3981         if (modemConfigurationCommandBuilder_ == null) {
3982           if (value == null) {
3983             throw new NullPointerException();
3984           }
3985           modemConfigurationCommand_ = value;
3986           onChanged();
3987         } else {
3988           modemConfigurationCommandBuilder_.setMessage(value);
3989         }
3990         bitField0_ |= 0x00000040;
3991         return this;
3992       }
3993       /**
3994        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
3995        */
3996       public Builder setModemConfigurationCommand(
3997           com.openxc.BinaryMessages.ModemConfigurationCommand.Builder builderForValue) {
3998         if (modemConfigurationCommandBuilder_ == null) {
3999           modemConfigurationCommand_ = builderForValue.build();
4000           onChanged();
4001         } else {
4002           modemConfigurationCommandBuilder_.setMessage(builderForValue.build());
4003         }
4004         bitField0_ |= 0x00000040;
4005         return this;
4006       }
4007       /**
4008        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
4009        */
4010       public Builder mergeModemConfigurationCommand(com.openxc.BinaryMessages.ModemConfigurationCommand value) {
4011         if (modemConfigurationCommandBuilder_ == null) {
4012           if (((bitField0_ & 0x00000040) == 0x00000040) &&
4013               modemConfigurationCommand_ != com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance()) {
4014             modemConfigurationCommand_ =
4015               com.openxc.BinaryMessages.ModemConfigurationCommand.newBuilder(modemConfigurationCommand_).mergeFrom(value).buildPartial();
4016           } else {
4017             modemConfigurationCommand_ = value;
4018           }
4019           onChanged();
4020         } else {
4021           modemConfigurationCommandBuilder_.mergeFrom(value);
4022         }
4023         bitField0_ |= 0x00000040;
4024         return this;
4025       }
4026       /**
4027        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
4028        */
4029       public Builder clearModemConfigurationCommand() {
4030         if (modemConfigurationCommandBuilder_ == null) {
4031           modemConfigurationCommand_ = com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
4032           onChanged();
4033         } else {
4034           modemConfigurationCommandBuilder_.clear();
4035         }
4036         bitField0_ = (bitField0_ & ~0x00000040);
4037         return this;
4038       }
4039       /**
4040        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
4041        */
4042       public com.openxc.BinaryMessages.ModemConfigurationCommand.Builder getModemConfigurationCommandBuilder() {
4043         bitField0_ |= 0x00000040;
4044         onChanged();
4045         return getModemConfigurationCommandFieldBuilder().getBuilder();
4046       }
4047       /**
4048        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
4049        */
4050       public com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder getModemConfigurationCommandOrBuilder() {
4051         if (modemConfigurationCommandBuilder_ != null) {
4052           return modemConfigurationCommandBuilder_.getMessageOrBuilder();
4053         } else {
4054           return modemConfigurationCommand_;
4055         }
4056       }
4057       /**
4058        * <code>optional .openxc.ModemConfigurationCommand modem_configuration_command = 7;</code>
4059        */
4060       private com.google.protobuf.SingleFieldBuilder<
4061           com.openxc.BinaryMessages.ModemConfigurationCommand, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder, com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder>
4062           getModemConfigurationCommandFieldBuilder() {
4063         if (modemConfigurationCommandBuilder_ == null) {
4064           modemConfigurationCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
4065               com.openxc.BinaryMessages.ModemConfigurationCommand, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder, com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder>(
4066                   modemConfigurationCommand_,
4067                   getParentForChildren(),
4068                   isClean());
4069           modemConfigurationCommand_ = null;
4070         }
4071         return modemConfigurationCommandBuilder_;
4072       }
4073
4074       // optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;
4075       private com.openxc.BinaryMessages.RTCConfigurationCommand rtcConfigurationCommand_ = com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance();
4076       private com.google.protobuf.SingleFieldBuilder<
4077           com.openxc.BinaryMessages.RTCConfigurationCommand, com.openxc.BinaryMessages.RTCConfigurationCommand.Builder, com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder> rtcConfigurationCommandBuilder_;
4078       /**
4079        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4080        */
4081       public boolean hasRtcConfigurationCommand() {
4082         return ((bitField0_ & 0x00000080) == 0x00000080);
4083       }
4084       /**
4085        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4086        */
4087       public com.openxc.BinaryMessages.RTCConfigurationCommand getRtcConfigurationCommand() {
4088         if (rtcConfigurationCommandBuilder_ == null) {
4089           return rtcConfigurationCommand_;
4090         } else {
4091           return rtcConfigurationCommandBuilder_.getMessage();
4092         }
4093       }
4094       /**
4095        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4096        */
4097       public Builder setRtcConfigurationCommand(com.openxc.BinaryMessages.RTCConfigurationCommand value) {
4098         if (rtcConfigurationCommandBuilder_ == null) {
4099           if (value == null) {
4100             throw new NullPointerException();
4101           }
4102           rtcConfigurationCommand_ = value;
4103           onChanged();
4104         } else {
4105           rtcConfigurationCommandBuilder_.setMessage(value);
4106         }
4107         bitField0_ |= 0x00000080;
4108         return this;
4109       }
4110       /**
4111        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4112        */
4113       public Builder setRtcConfigurationCommand(
4114           com.openxc.BinaryMessages.RTCConfigurationCommand.Builder builderForValue) {
4115         if (rtcConfigurationCommandBuilder_ == null) {
4116           rtcConfigurationCommand_ = builderForValue.build();
4117           onChanged();
4118         } else {
4119           rtcConfigurationCommandBuilder_.setMessage(builderForValue.build());
4120         }
4121         bitField0_ |= 0x00000080;
4122         return this;
4123       }
4124       /**
4125        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4126        */
4127       public Builder mergeRtcConfigurationCommand(com.openxc.BinaryMessages.RTCConfigurationCommand value) {
4128         if (rtcConfigurationCommandBuilder_ == null) {
4129           if (((bitField0_ & 0x00000080) == 0x00000080) &&
4130               rtcConfigurationCommand_ != com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance()) {
4131             rtcConfigurationCommand_ =
4132               com.openxc.BinaryMessages.RTCConfigurationCommand.newBuilder(rtcConfigurationCommand_).mergeFrom(value).buildPartial();
4133           } else {
4134             rtcConfigurationCommand_ = value;
4135           }
4136           onChanged();
4137         } else {
4138           rtcConfigurationCommandBuilder_.mergeFrom(value);
4139         }
4140         bitField0_ |= 0x00000080;
4141         return this;
4142       }
4143       /**
4144        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4145        */
4146       public Builder clearRtcConfigurationCommand() {
4147         if (rtcConfigurationCommandBuilder_ == null) {
4148           rtcConfigurationCommand_ = com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance();
4149           onChanged();
4150         } else {
4151           rtcConfigurationCommandBuilder_.clear();
4152         }
4153         bitField0_ = (bitField0_ & ~0x00000080);
4154         return this;
4155       }
4156       /**
4157        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4158        */
4159       public com.openxc.BinaryMessages.RTCConfigurationCommand.Builder getRtcConfigurationCommandBuilder() {
4160         bitField0_ |= 0x00000080;
4161         onChanged();
4162         return getRtcConfigurationCommandFieldBuilder().getBuilder();
4163       }
4164       /**
4165        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4166        */
4167       public com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder getRtcConfigurationCommandOrBuilder() {
4168         if (rtcConfigurationCommandBuilder_ != null) {
4169           return rtcConfigurationCommandBuilder_.getMessageOrBuilder();
4170         } else {
4171           return rtcConfigurationCommand_;
4172         }
4173       }
4174       /**
4175        * <code>optional .openxc.RTCConfigurationCommand rtc_configuration_command = 8;</code>
4176        */
4177       private com.google.protobuf.SingleFieldBuilder<
4178           com.openxc.BinaryMessages.RTCConfigurationCommand, com.openxc.BinaryMessages.RTCConfigurationCommand.Builder, com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder>
4179           getRtcConfigurationCommandFieldBuilder() {
4180         if (rtcConfigurationCommandBuilder_ == null) {
4181           rtcConfigurationCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
4182               com.openxc.BinaryMessages.RTCConfigurationCommand, com.openxc.BinaryMessages.RTCConfigurationCommand.Builder, com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder>(
4183                   rtcConfigurationCommand_,
4184                   getParentForChildren(),
4185                   isClean());
4186           rtcConfigurationCommand_ = null;
4187         }
4188         return rtcConfigurationCommandBuilder_;
4189       }
4190
4191       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
4192     }
4193
4194     static {
4195       defaultInstance = new ControlCommand(true);
4196       defaultInstance.initFields();
4197     }
4198
4199     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
4200   }
4201
4202   public interface DiagnosticControlCommandOrBuilder
4203       extends com.google.protobuf.MessageOrBuilder {
4204
4205     // optional .openxc.DiagnosticRequest request = 1;
4206     /**
4207      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4208      */
4209     boolean hasRequest();
4210     /**
4211      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4212      */
4213     com.openxc.BinaryMessages.DiagnosticRequest getRequest();
4214     /**
4215      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4216      */
4217     com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder();
4218
4219     // optional .openxc.DiagnosticControlCommand.Action action = 2;
4220     /**
4221      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4222      */
4223     boolean hasAction();
4224     /**
4225      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4226      */
4227     com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction();
4228   }
4229   /**
4230    * Protobuf type {@code openxc.DiagnosticControlCommand}
4231    */
4232   public static final class DiagnosticControlCommand extends
4233       com.google.protobuf.GeneratedMessage
4234       implements DiagnosticControlCommandOrBuilder {
4235     // Use DiagnosticControlCommand.newBuilder() to construct.
4236     private DiagnosticControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4237       super(builder);
4238       this.unknownFields = builder.getUnknownFields();
4239     }
4240     private DiagnosticControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4241
4242     private static final DiagnosticControlCommand defaultInstance;
4243     public static DiagnosticControlCommand getDefaultInstance() {
4244       return defaultInstance;
4245     }
4246
4247     public DiagnosticControlCommand getDefaultInstanceForType() {
4248       return defaultInstance;
4249     }
4250
4251     private final com.google.protobuf.UnknownFieldSet unknownFields;
4252     @java.lang.Override
4253     public final com.google.protobuf.UnknownFieldSet
4254         getUnknownFields() {
4255       return this.unknownFields;
4256     }
4257     private DiagnosticControlCommand(
4258         com.google.protobuf.CodedInputStream input,
4259         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4260         throws com.google.protobuf.InvalidProtocolBufferException {
4261       initFields();
4262       int mutable_bitField0_ = 0;
4263       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4264           com.google.protobuf.UnknownFieldSet.newBuilder();
4265       try {
4266         boolean done = false;
4267         while (!done) {
4268           int tag = input.readTag();
4269           switch (tag) {
4270             case 0:
4271               done = true;
4272               break;
4273             default: {
4274               if (!parseUnknownField(input, unknownFields,
4275                                      extensionRegistry, tag)) {
4276                 done = true;
4277               }
4278               break;
4279             }
4280             case 10: {
4281               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = null;
4282               if (((bitField0_ & 0x00000001) == 0x00000001)) {
4283                 subBuilder = request_.toBuilder();
4284               }
4285               request_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticRequest.PARSER, extensionRegistry);
4286               if (subBuilder != null) {
4287                 subBuilder.mergeFrom(request_);
4288                 request_ = subBuilder.buildPartial();
4289               }
4290               bitField0_ |= 0x00000001;
4291               break;
4292             }
4293             case 16: {
4294               int rawValue = input.readEnum();
4295               com.openxc.BinaryMessages.DiagnosticControlCommand.Action value = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.valueOf(rawValue);
4296               if (value == null) {
4297                 unknownFields.mergeVarintField(2, rawValue);
4298               } else {
4299                 bitField0_ |= 0x00000002;
4300                 action_ = value;
4301               }
4302               break;
4303             }
4304           }
4305         }
4306       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4307         throw e.setUnfinishedMessage(this);
4308       } catch (java.io.IOException e) {
4309         throw new com.google.protobuf.InvalidProtocolBufferException(
4310             e.getMessage()).setUnfinishedMessage(this);
4311       } finally {
4312         this.unknownFields = unknownFields.build();
4313         makeExtensionsImmutable();
4314       }
4315     }
4316     public static final com.google.protobuf.Descriptors.Descriptor
4317         getDescriptor() {
4318       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
4319     }
4320
4321     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4322         internalGetFieldAccessorTable() {
4323       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable
4324           .ensureFieldAccessorsInitialized(
4325               com.openxc.BinaryMessages.DiagnosticControlCommand.class, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder.class);
4326     }
4327
4328     public static com.google.protobuf.Parser<DiagnosticControlCommand> PARSER =
4329         new com.google.protobuf.AbstractParser<DiagnosticControlCommand>() {
4330       public DiagnosticControlCommand parsePartialFrom(
4331           com.google.protobuf.CodedInputStream input,
4332           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4333           throws com.google.protobuf.InvalidProtocolBufferException {
4334         return new DiagnosticControlCommand(input, extensionRegistry);
4335       }
4336     };
4337
4338     @java.lang.Override
4339     public com.google.protobuf.Parser<DiagnosticControlCommand> getParserForType() {
4340       return PARSER;
4341     }
4342
4343     /**
4344      * Protobuf enum {@code openxc.DiagnosticControlCommand.Action}
4345      */
4346     public enum Action
4347         implements com.google.protobuf.ProtocolMessageEnum {
4348       /**
4349        * <code>ADD = 1;</code>
4350        */
4351       ADD(0, 1),
4352       /**
4353        * <code>CANCEL = 2;</code>
4354        */
4355       CANCEL(1, 2),
4356       ;
4357
4358       /**
4359        * <code>ADD = 1;</code>
4360        */
4361       public static final int ADD_VALUE = 1;
4362       /**
4363        * <code>CANCEL = 2;</code>
4364        */
4365       public static final int CANCEL_VALUE = 2;
4366
4367
4368       public final int getNumber() { return value; }
4369
4370       public static Action valueOf(int value) {
4371         switch (value) {
4372           case 1: return ADD;
4373           case 2: return CANCEL;
4374           default: return null;
4375         }
4376       }
4377
4378       public static com.google.protobuf.Internal.EnumLiteMap<Action>
4379           internalGetValueMap() {
4380         return internalValueMap;
4381       }
4382       private static com.google.protobuf.Internal.EnumLiteMap<Action>
4383           internalValueMap =
4384             new com.google.protobuf.Internal.EnumLiteMap<Action>() {
4385               public Action findValueByNumber(int number) {
4386                 return Action.valueOf(number);
4387               }
4388             };
4389
4390       public final com.google.protobuf.Descriptors.EnumValueDescriptor
4391           getValueDescriptor() {
4392         return getDescriptor().getValues().get(index);
4393       }
4394       public final com.google.protobuf.Descriptors.EnumDescriptor
4395           getDescriptorForType() {
4396         return getDescriptor();
4397       }
4398       public static final com.google.protobuf.Descriptors.EnumDescriptor
4399           getDescriptor() {
4400         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDescriptor().getEnumTypes().get(0);
4401       }
4402
4403       private static final Action[] VALUES = values();
4404
4405       public static Action valueOf(
4406           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
4407         if (desc.getType() != getDescriptor()) {
4408           throw new java.lang.IllegalArgumentException(
4409             "EnumValueDescriptor is not for this type.");
4410         }
4411         return VALUES[desc.getIndex()];
4412       }
4413
4414       private final int index;
4415       private final int value;
4416
4417       private Action(int index, int value) {
4418         this.index = index;
4419         this.value = value;
4420       }
4421
4422       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticControlCommand.Action)
4423     }
4424
4425     private int bitField0_;
4426     // optional .openxc.DiagnosticRequest request = 1;
4427     public static final int REQUEST_FIELD_NUMBER = 1;
4428     private com.openxc.BinaryMessages.DiagnosticRequest request_;
4429     /**
4430      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4431      */
4432     public boolean hasRequest() {
4433       return ((bitField0_ & 0x00000001) == 0x00000001);
4434     }
4435     /**
4436      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4437      */
4438     public com.openxc.BinaryMessages.DiagnosticRequest getRequest() {
4439       return request_;
4440     }
4441     /**
4442      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4443      */
4444     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder() {
4445       return request_;
4446     }
4447
4448     // optional .openxc.DiagnosticControlCommand.Action action = 2;
4449     public static final int ACTION_FIELD_NUMBER = 2;
4450     private com.openxc.BinaryMessages.DiagnosticControlCommand.Action action_;
4451     /**
4452      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4453      */
4454     public boolean hasAction() {
4455       return ((bitField0_ & 0x00000002) == 0x00000002);
4456     }
4457     /**
4458      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4459      */
4460     public com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction() {
4461       return action_;
4462     }
4463
4464     private void initFields() {
4465       request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4466       action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
4467     }
4468     private byte memoizedIsInitialized = -1;
4469     public final boolean isInitialized() {
4470       byte isInitialized = memoizedIsInitialized;
4471       if (isInitialized != -1) return isInitialized == 1;
4472
4473       memoizedIsInitialized = 1;
4474       return true;
4475     }
4476
4477     public void writeTo(com.google.protobuf.CodedOutputStream output)
4478                         throws java.io.IOException {
4479       getSerializedSize();
4480       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4481         output.writeMessage(1, request_);
4482       }
4483       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4484         output.writeEnum(2, action_.getNumber());
4485       }
4486       getUnknownFields().writeTo(output);
4487     }
4488
4489     private int memoizedSerializedSize = -1;
4490     public int getSerializedSize() {
4491       int size = memoizedSerializedSize;
4492       if (size != -1) return size;
4493
4494       size = 0;
4495       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4496         size += com.google.protobuf.CodedOutputStream
4497           .computeMessageSize(1, request_);
4498       }
4499       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4500         size += com.google.protobuf.CodedOutputStream
4501           .computeEnumSize(2, action_.getNumber());
4502       }
4503       size += getUnknownFields().getSerializedSize();
4504       memoizedSerializedSize = size;
4505       return size;
4506     }
4507
4508     private static final long serialVersionUID = 0L;
4509     @java.lang.Override
4510     protected java.lang.Object writeReplace()
4511         throws java.io.ObjectStreamException {
4512       return super.writeReplace();
4513     }
4514
4515     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
4516         com.google.protobuf.ByteString data)
4517         throws com.google.protobuf.InvalidProtocolBufferException {
4518       return PARSER.parseFrom(data);
4519     }
4520     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
4521         com.google.protobuf.ByteString data,
4522         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4523         throws com.google.protobuf.InvalidProtocolBufferException {
4524       return PARSER.parseFrom(data, extensionRegistry);
4525     }
4526     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(byte[] data)
4527         throws com.google.protobuf.InvalidProtocolBufferException {
4528       return PARSER.parseFrom(data);
4529     }
4530     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
4531         byte[] data,
4532         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4533         throws com.google.protobuf.InvalidProtocolBufferException {
4534       return PARSER.parseFrom(data, extensionRegistry);
4535     }
4536     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(java.io.InputStream input)
4537         throws java.io.IOException {
4538       return PARSER.parseFrom(input);
4539     }
4540     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
4541         java.io.InputStream input,
4542         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4543         throws java.io.IOException {
4544       return PARSER.parseFrom(input, extensionRegistry);
4545     }
4546     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseDelimitedFrom(java.io.InputStream input)
4547         throws java.io.IOException {
4548       return PARSER.parseDelimitedFrom(input);
4549     }
4550     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseDelimitedFrom(
4551         java.io.InputStream input,
4552         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4553         throws java.io.IOException {
4554       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4555     }
4556     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
4557         com.google.protobuf.CodedInputStream input)
4558         throws java.io.IOException {
4559       return PARSER.parseFrom(input);
4560     }
4561     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
4562         com.google.protobuf.CodedInputStream input,
4563         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4564         throws java.io.IOException {
4565       return PARSER.parseFrom(input, extensionRegistry);
4566     }
4567
4568     public static Builder newBuilder() { return Builder.create(); }
4569     public Builder newBuilderForType() { return newBuilder(); }
4570     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticControlCommand prototype) {
4571       return newBuilder().mergeFrom(prototype);
4572     }
4573     public Builder toBuilder() { return newBuilder(this); }
4574
4575     @java.lang.Override
4576     protected Builder newBuilderForType(
4577         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4578       Builder builder = new Builder(parent);
4579       return builder;
4580     }
4581     /**
4582      * Protobuf type {@code openxc.DiagnosticControlCommand}
4583      */
4584     public static final class Builder extends
4585         com.google.protobuf.GeneratedMessage.Builder<Builder>
4586        implements com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder {
4587       public static final com.google.protobuf.Descriptors.Descriptor
4588           getDescriptor() {
4589         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
4590       }
4591
4592       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4593           internalGetFieldAccessorTable() {
4594         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable
4595             .ensureFieldAccessorsInitialized(
4596                 com.openxc.BinaryMessages.DiagnosticControlCommand.class, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder.class);
4597       }
4598
4599       // Construct using com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder()
4600       private Builder() {
4601         maybeForceBuilderInitialization();
4602       }
4603
4604       private Builder(
4605           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4606         super(parent);
4607         maybeForceBuilderInitialization();
4608       }
4609       private void maybeForceBuilderInitialization() {
4610         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4611           getRequestFieldBuilder();
4612         }
4613       }
4614       private static Builder create() {
4615         return new Builder();
4616       }
4617
4618       public Builder clear() {
4619         super.clear();
4620         if (requestBuilder_ == null) {
4621           request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4622         } else {
4623           requestBuilder_.clear();
4624         }
4625         bitField0_ = (bitField0_ & ~0x00000001);
4626         action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
4627         bitField0_ = (bitField0_ & ~0x00000002);
4628         return this;
4629       }
4630
4631       public Builder clone() {
4632         return create().mergeFrom(buildPartial());
4633       }
4634
4635       public com.google.protobuf.Descriptors.Descriptor
4636           getDescriptorForType() {
4637         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
4638       }
4639
4640       public com.openxc.BinaryMessages.DiagnosticControlCommand getDefaultInstanceForType() {
4641         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
4642       }
4643
4644       public com.openxc.BinaryMessages.DiagnosticControlCommand build() {
4645         com.openxc.BinaryMessages.DiagnosticControlCommand result = buildPartial();
4646         if (!result.isInitialized()) {
4647           throw newUninitializedMessageException(result);
4648         }
4649         return result;
4650       }
4651
4652       public com.openxc.BinaryMessages.DiagnosticControlCommand buildPartial() {
4653         com.openxc.BinaryMessages.DiagnosticControlCommand result = new com.openxc.BinaryMessages.DiagnosticControlCommand(this);
4654         int from_bitField0_ = bitField0_;
4655         int to_bitField0_ = 0;
4656         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4657           to_bitField0_ |= 0x00000001;
4658         }
4659         if (requestBuilder_ == null) {
4660           result.request_ = request_;
4661         } else {
4662           result.request_ = requestBuilder_.build();
4663         }
4664         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4665           to_bitField0_ |= 0x00000002;
4666         }
4667         result.action_ = action_;
4668         result.bitField0_ = to_bitField0_;
4669         onBuilt();
4670         return result;
4671       }
4672
4673       public Builder mergeFrom(com.google.protobuf.Message other) {
4674         if (other instanceof com.openxc.BinaryMessages.DiagnosticControlCommand) {
4675           return mergeFrom((com.openxc.BinaryMessages.DiagnosticControlCommand)other);
4676         } else {
4677           super.mergeFrom(other);
4678           return this;
4679         }
4680       }
4681
4682       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticControlCommand other) {
4683         if (other == com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance()) return this;
4684         if (other.hasRequest()) {
4685           mergeRequest(other.getRequest());
4686         }
4687         if (other.hasAction()) {
4688           setAction(other.getAction());
4689         }
4690         this.mergeUnknownFields(other.getUnknownFields());
4691         return this;
4692       }
4693
4694       public final boolean isInitialized() {
4695         return true;
4696       }
4697
4698       public Builder mergeFrom(
4699           com.google.protobuf.CodedInputStream input,
4700           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4701           throws java.io.IOException {
4702         com.openxc.BinaryMessages.DiagnosticControlCommand parsedMessage = null;
4703         try {
4704           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4705         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4706           parsedMessage = (com.openxc.BinaryMessages.DiagnosticControlCommand) e.getUnfinishedMessage();
4707           throw e;
4708         } finally {
4709           if (parsedMessage != null) {
4710             mergeFrom(parsedMessage);
4711           }
4712         }
4713         return this;
4714       }
4715       private int bitField0_;
4716
4717       // optional .openxc.DiagnosticRequest request = 1;
4718       private com.openxc.BinaryMessages.DiagnosticRequest request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4719       private com.google.protobuf.SingleFieldBuilder<
4720           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> requestBuilder_;
4721       /**
4722        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4723        */
4724       public boolean hasRequest() {
4725         return ((bitField0_ & 0x00000001) == 0x00000001);
4726       }
4727       /**
4728        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4729        */
4730       public com.openxc.BinaryMessages.DiagnosticRequest getRequest() {
4731         if (requestBuilder_ == null) {
4732           return request_;
4733         } else {
4734           return requestBuilder_.getMessage();
4735         }
4736       }
4737       /**
4738        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4739        */
4740       public Builder setRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
4741         if (requestBuilder_ == null) {
4742           if (value == null) {
4743             throw new NullPointerException();
4744           }
4745           request_ = value;
4746           onChanged();
4747         } else {
4748           requestBuilder_.setMessage(value);
4749         }
4750         bitField0_ |= 0x00000001;
4751         return this;
4752       }
4753       /**
4754        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4755        */
4756       public Builder setRequest(
4757           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
4758         if (requestBuilder_ == null) {
4759           request_ = builderForValue.build();
4760           onChanged();
4761         } else {
4762           requestBuilder_.setMessage(builderForValue.build());
4763         }
4764         bitField0_ |= 0x00000001;
4765         return this;
4766       }
4767       /**
4768        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4769        */
4770       public Builder mergeRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
4771         if (requestBuilder_ == null) {
4772           if (((bitField0_ & 0x00000001) == 0x00000001) &&
4773               request_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
4774             request_ =
4775               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(request_).mergeFrom(value).buildPartial();
4776           } else {
4777             request_ = value;
4778           }
4779           onChanged();
4780         } else {
4781           requestBuilder_.mergeFrom(value);
4782         }
4783         bitField0_ |= 0x00000001;
4784         return this;
4785       }
4786       /**
4787        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4788        */
4789       public Builder clearRequest() {
4790         if (requestBuilder_ == null) {
4791           request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4792           onChanged();
4793         } else {
4794           requestBuilder_.clear();
4795         }
4796         bitField0_ = (bitField0_ & ~0x00000001);
4797         return this;
4798       }
4799       /**
4800        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4801        */
4802       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getRequestBuilder() {
4803         bitField0_ |= 0x00000001;
4804         onChanged();
4805         return getRequestFieldBuilder().getBuilder();
4806       }
4807       /**
4808        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4809        */
4810       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder() {
4811         if (requestBuilder_ != null) {
4812           return requestBuilder_.getMessageOrBuilder();
4813         } else {
4814           return request_;
4815         }
4816       }
4817       /**
4818        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
4819        */
4820       private com.google.protobuf.SingleFieldBuilder<
4821           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>
4822           getRequestFieldBuilder() {
4823         if (requestBuilder_ == null) {
4824           requestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
4825               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
4826                   request_,
4827                   getParentForChildren(),
4828                   isClean());
4829           request_ = null;
4830         }
4831         return requestBuilder_;
4832       }
4833
4834       // optional .openxc.DiagnosticControlCommand.Action action = 2;
4835       private com.openxc.BinaryMessages.DiagnosticControlCommand.Action action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
4836       /**
4837        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4838        */
4839       public boolean hasAction() {
4840         return ((bitField0_ & 0x00000002) == 0x00000002);
4841       }
4842       /**
4843        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4844        */
4845       public com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction() {
4846         return action_;
4847       }
4848       /**
4849        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4850        */
4851       public Builder setAction(com.openxc.BinaryMessages.DiagnosticControlCommand.Action value) {
4852         if (value == null) {
4853           throw new NullPointerException();
4854         }
4855         bitField0_ |= 0x00000002;
4856         action_ = value;
4857         onChanged();
4858         return this;
4859       }
4860       /**
4861        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
4862        */
4863       public Builder clearAction() {
4864         bitField0_ = (bitField0_ & ~0x00000002);
4865         action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
4866         onChanged();
4867         return this;
4868       }
4869
4870       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticControlCommand)
4871     }
4872
4873     static {
4874       defaultInstance = new DiagnosticControlCommand(true);
4875       defaultInstance.initFields();
4876     }
4877
4878     // @@protoc_insertion_point(class_scope:openxc.DiagnosticControlCommand)
4879   }
4880
4881   public interface PassthroughModeControlCommandOrBuilder
4882       extends com.google.protobuf.MessageOrBuilder {
4883
4884     // optional int32 bus = 1;
4885     /**
4886      * <code>optional int32 bus = 1;</code>
4887      */
4888     boolean hasBus();
4889     /**
4890      * <code>optional int32 bus = 1;</code>
4891      */
4892     int getBus();
4893
4894     // optional bool enabled = 2;
4895     /**
4896      * <code>optional bool enabled = 2;</code>
4897      */
4898     boolean hasEnabled();
4899     /**
4900      * <code>optional bool enabled = 2;</code>
4901      */
4902     boolean getEnabled();
4903   }
4904   /**
4905    * Protobuf type {@code openxc.PassthroughModeControlCommand}
4906    */
4907   public static final class PassthroughModeControlCommand extends
4908       com.google.protobuf.GeneratedMessage
4909       implements PassthroughModeControlCommandOrBuilder {
4910     // Use PassthroughModeControlCommand.newBuilder() to construct.
4911     private PassthroughModeControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4912       super(builder);
4913       this.unknownFields = builder.getUnknownFields();
4914     }
4915     private PassthroughModeControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4916
4917     private static final PassthroughModeControlCommand defaultInstance;
4918     public static PassthroughModeControlCommand getDefaultInstance() {
4919       return defaultInstance;
4920     }
4921
4922     public PassthroughModeControlCommand getDefaultInstanceForType() {
4923       return defaultInstance;
4924     }
4925
4926     private final com.google.protobuf.UnknownFieldSet unknownFields;
4927     @java.lang.Override
4928     public final com.google.protobuf.UnknownFieldSet
4929         getUnknownFields() {
4930       return this.unknownFields;
4931     }
4932     private PassthroughModeControlCommand(
4933         com.google.protobuf.CodedInputStream input,
4934         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4935         throws com.google.protobuf.InvalidProtocolBufferException {
4936       initFields();
4937       int mutable_bitField0_ = 0;
4938       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4939           com.google.protobuf.UnknownFieldSet.newBuilder();
4940       try {
4941         boolean done = false;
4942         while (!done) {
4943           int tag = input.readTag();
4944           switch (tag) {
4945             case 0:
4946               done = true;
4947               break;
4948             default: {
4949               if (!parseUnknownField(input, unknownFields,
4950                                      extensionRegistry, tag)) {
4951                 done = true;
4952               }
4953               break;
4954             }
4955             case 8: {
4956               bitField0_ |= 0x00000001;
4957               bus_ = input.readInt32();
4958               break;
4959             }
4960             case 16: {
4961               bitField0_ |= 0x00000002;
4962               enabled_ = input.readBool();
4963               break;
4964             }
4965           }
4966         }
4967       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4968         throw e.setUnfinishedMessage(this);
4969       } catch (java.io.IOException e) {
4970         throw new com.google.protobuf.InvalidProtocolBufferException(
4971             e.getMessage()).setUnfinishedMessage(this);
4972       } finally {
4973         this.unknownFields = unknownFields.build();
4974         makeExtensionsImmutable();
4975       }
4976     }
4977     public static final com.google.protobuf.Descriptors.Descriptor
4978         getDescriptor() {
4979       return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
4980     }
4981
4982     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4983         internalGetFieldAccessorTable() {
4984       return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable
4985           .ensureFieldAccessorsInitialized(
4986               com.openxc.BinaryMessages.PassthroughModeControlCommand.class, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder.class);
4987     }
4988
4989     public static com.google.protobuf.Parser<PassthroughModeControlCommand> PARSER =
4990         new com.google.protobuf.AbstractParser<PassthroughModeControlCommand>() {
4991       public PassthroughModeControlCommand parsePartialFrom(
4992           com.google.protobuf.CodedInputStream input,
4993           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4994           throws com.google.protobuf.InvalidProtocolBufferException {
4995         return new PassthroughModeControlCommand(input, extensionRegistry);
4996       }
4997     };
4998
4999     @java.lang.Override
5000     public com.google.protobuf.Parser<PassthroughModeControlCommand> getParserForType() {
5001       return PARSER;
5002     }
5003
5004     private int bitField0_;
5005     // optional int32 bus = 1;
5006     public static final int BUS_FIELD_NUMBER = 1;
5007     private int bus_;
5008     /**
5009      * <code>optional int32 bus = 1;</code>
5010      */
5011     public boolean hasBus() {
5012       return ((bitField0_ & 0x00000001) == 0x00000001);
5013     }
5014     /**
5015      * <code>optional int32 bus = 1;</code>
5016      */
5017     public int getBus() {
5018       return bus_;
5019     }
5020
5021     // optional bool enabled = 2;
5022     public static final int ENABLED_FIELD_NUMBER = 2;
5023     private boolean enabled_;
5024     /**
5025      * <code>optional bool enabled = 2;</code>
5026      */
5027     public boolean hasEnabled() {
5028       return ((bitField0_ & 0x00000002) == 0x00000002);
5029     }
5030     /**
5031      * <code>optional bool enabled = 2;</code>
5032      */
5033     public boolean getEnabled() {
5034       return enabled_;
5035     }
5036
5037     private void initFields() {
5038       bus_ = 0;
5039       enabled_ = false;
5040     }
5041     private byte memoizedIsInitialized = -1;
5042     public final boolean isInitialized() {
5043       byte isInitialized = memoizedIsInitialized;
5044       if (isInitialized != -1) return isInitialized == 1;
5045
5046       memoizedIsInitialized = 1;
5047       return true;
5048     }
5049
5050     public void writeTo(com.google.protobuf.CodedOutputStream output)
5051                         throws java.io.IOException {
5052       getSerializedSize();
5053       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5054         output.writeInt32(1, bus_);
5055       }
5056       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5057         output.writeBool(2, enabled_);
5058       }
5059       getUnknownFields().writeTo(output);
5060     }
5061
5062     private int memoizedSerializedSize = -1;
5063     public int getSerializedSize() {
5064       int size = memoizedSerializedSize;
5065       if (size != -1) return size;
5066
5067       size = 0;
5068       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5069         size += com.google.protobuf.CodedOutputStream
5070           .computeInt32Size(1, bus_);
5071       }
5072       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5073         size += com.google.protobuf.CodedOutputStream
5074           .computeBoolSize(2, enabled_);
5075       }
5076       size += getUnknownFields().getSerializedSize();
5077       memoizedSerializedSize = size;
5078       return size;
5079     }
5080
5081     private static final long serialVersionUID = 0L;
5082     @java.lang.Override
5083     protected java.lang.Object writeReplace()
5084         throws java.io.ObjectStreamException {
5085       return super.writeReplace();
5086     }
5087
5088     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
5089         com.google.protobuf.ByteString data)
5090         throws com.google.protobuf.InvalidProtocolBufferException {
5091       return PARSER.parseFrom(data);
5092     }
5093     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
5094         com.google.protobuf.ByteString data,
5095         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5096         throws com.google.protobuf.InvalidProtocolBufferException {
5097       return PARSER.parseFrom(data, extensionRegistry);
5098     }
5099     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(byte[] data)
5100         throws com.google.protobuf.InvalidProtocolBufferException {
5101       return PARSER.parseFrom(data);
5102     }
5103     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
5104         byte[] data,
5105         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5106         throws com.google.protobuf.InvalidProtocolBufferException {
5107       return PARSER.parseFrom(data, extensionRegistry);
5108     }
5109     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(java.io.InputStream input)
5110         throws java.io.IOException {
5111       return PARSER.parseFrom(input);
5112     }
5113     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
5114         java.io.InputStream input,
5115         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5116         throws java.io.IOException {
5117       return PARSER.parseFrom(input, extensionRegistry);
5118     }
5119     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseDelimitedFrom(java.io.InputStream input)
5120         throws java.io.IOException {
5121       return PARSER.parseDelimitedFrom(input);
5122     }
5123     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseDelimitedFrom(
5124         java.io.InputStream input,
5125         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5126         throws java.io.IOException {
5127       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5128     }
5129     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
5130         com.google.protobuf.CodedInputStream input)
5131         throws java.io.IOException {
5132       return PARSER.parseFrom(input);
5133     }
5134     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
5135         com.google.protobuf.CodedInputStream input,
5136         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5137         throws java.io.IOException {
5138       return PARSER.parseFrom(input, extensionRegistry);
5139     }
5140
5141     public static Builder newBuilder() { return Builder.create(); }
5142     public Builder newBuilderForType() { return newBuilder(); }
5143     public static Builder newBuilder(com.openxc.BinaryMessages.PassthroughModeControlCommand prototype) {
5144       return newBuilder().mergeFrom(prototype);
5145     }
5146     public Builder toBuilder() { return newBuilder(this); }
5147
5148     @java.lang.Override
5149     protected Builder newBuilderForType(
5150         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5151       Builder builder = new Builder(parent);
5152       return builder;
5153     }
5154     /**
5155      * Protobuf type {@code openxc.PassthroughModeControlCommand}
5156      */
5157     public static final class Builder extends
5158         com.google.protobuf.GeneratedMessage.Builder<Builder>
5159        implements com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder {
5160       public static final com.google.protobuf.Descriptors.Descriptor
5161           getDescriptor() {
5162         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
5163       }
5164
5165       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5166           internalGetFieldAccessorTable() {
5167         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable
5168             .ensureFieldAccessorsInitialized(
5169                 com.openxc.BinaryMessages.PassthroughModeControlCommand.class, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder.class);
5170       }
5171
5172       // Construct using com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder()
5173       private Builder() {
5174         maybeForceBuilderInitialization();
5175       }
5176
5177       private Builder(
5178           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5179         super(parent);
5180         maybeForceBuilderInitialization();
5181       }
5182       private void maybeForceBuilderInitialization() {
5183         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5184         }
5185       }
5186       private static Builder create() {
5187         return new Builder();
5188       }
5189
5190       public Builder clear() {
5191         super.clear();
5192         bus_ = 0;
5193         bitField0_ = (bitField0_ & ~0x00000001);
5194         enabled_ = false;
5195         bitField0_ = (bitField0_ & ~0x00000002);
5196         return this;
5197       }
5198
5199       public Builder clone() {
5200         return create().mergeFrom(buildPartial());
5201       }
5202
5203       public com.google.protobuf.Descriptors.Descriptor
5204           getDescriptorForType() {
5205         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
5206       }
5207
5208       public com.openxc.BinaryMessages.PassthroughModeControlCommand getDefaultInstanceForType() {
5209         return com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
5210       }
5211
5212       public com.openxc.BinaryMessages.PassthroughModeControlCommand build() {
5213         com.openxc.BinaryMessages.PassthroughModeControlCommand result = buildPartial();
5214         if (!result.isInitialized()) {
5215           throw newUninitializedMessageException(result);
5216         }
5217         return result;
5218       }
5219
5220       public com.openxc.BinaryMessages.PassthroughModeControlCommand buildPartial() {
5221         com.openxc.BinaryMessages.PassthroughModeControlCommand result = new com.openxc.BinaryMessages.PassthroughModeControlCommand(this);
5222         int from_bitField0_ = bitField0_;
5223         int to_bitField0_ = 0;
5224         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5225           to_bitField0_ |= 0x00000001;
5226         }
5227         result.bus_ = bus_;
5228         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5229           to_bitField0_ |= 0x00000002;
5230         }
5231         result.enabled_ = enabled_;
5232         result.bitField0_ = to_bitField0_;
5233         onBuilt();
5234         return result;
5235       }
5236
5237       public Builder mergeFrom(com.google.protobuf.Message other) {
5238         if (other instanceof com.openxc.BinaryMessages.PassthroughModeControlCommand) {
5239           return mergeFrom((com.openxc.BinaryMessages.PassthroughModeControlCommand)other);
5240         } else {
5241           super.mergeFrom(other);
5242           return this;
5243         }
5244       }
5245
5246       public Builder mergeFrom(com.openxc.BinaryMessages.PassthroughModeControlCommand other) {
5247         if (other == com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance()) return this;
5248         if (other.hasBus()) {
5249           setBus(other.getBus());
5250         }
5251         if (other.hasEnabled()) {
5252           setEnabled(other.getEnabled());
5253         }
5254         this.mergeUnknownFields(other.getUnknownFields());
5255         return this;
5256       }
5257
5258       public final boolean isInitialized() {
5259         return true;
5260       }
5261
5262       public Builder mergeFrom(
5263           com.google.protobuf.CodedInputStream input,
5264           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5265           throws java.io.IOException {
5266         com.openxc.BinaryMessages.PassthroughModeControlCommand parsedMessage = null;
5267         try {
5268           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5269         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5270           parsedMessage = (com.openxc.BinaryMessages.PassthroughModeControlCommand) e.getUnfinishedMessage();
5271           throw e;
5272         } finally {
5273           if (parsedMessage != null) {
5274             mergeFrom(parsedMessage);
5275           }
5276         }
5277         return this;
5278       }
5279       private int bitField0_;
5280
5281       // optional int32 bus = 1;
5282       private int bus_ ;
5283       /**
5284        * <code>optional int32 bus = 1;</code>
5285        */
5286       public boolean hasBus() {
5287         return ((bitField0_ & 0x00000001) == 0x00000001);
5288       }
5289       /**
5290        * <code>optional int32 bus = 1;</code>
5291        */
5292       public int getBus() {
5293         return bus_;
5294       }
5295       /**
5296        * <code>optional int32 bus = 1;</code>
5297        */
5298       public Builder setBus(int value) {
5299         bitField0_ |= 0x00000001;
5300         bus_ = value;
5301         onChanged();
5302         return this;
5303       }
5304       /**
5305        * <code>optional int32 bus = 1;</code>
5306        */
5307       public Builder clearBus() {
5308         bitField0_ = (bitField0_ & ~0x00000001);
5309         bus_ = 0;
5310         onChanged();
5311         return this;
5312       }
5313
5314       // optional bool enabled = 2;
5315       private boolean enabled_ ;
5316       /**
5317        * <code>optional bool enabled = 2;</code>
5318        */
5319       public boolean hasEnabled() {
5320         return ((bitField0_ & 0x00000002) == 0x00000002);
5321       }
5322       /**
5323        * <code>optional bool enabled = 2;</code>
5324        */
5325       public boolean getEnabled() {
5326         return enabled_;
5327       }
5328       /**
5329        * <code>optional bool enabled = 2;</code>
5330        */
5331       public Builder setEnabled(boolean value) {
5332         bitField0_ |= 0x00000002;
5333         enabled_ = value;
5334         onChanged();
5335         return this;
5336       }
5337       /**
5338        * <code>optional bool enabled = 2;</code>
5339        */
5340       public Builder clearEnabled() {
5341         bitField0_ = (bitField0_ & ~0x00000002);
5342         enabled_ = false;
5343         onChanged();
5344         return this;
5345       }
5346
5347       // @@protoc_insertion_point(builder_scope:openxc.PassthroughModeControlCommand)
5348     }
5349
5350     static {
5351       defaultInstance = new PassthroughModeControlCommand(true);
5352       defaultInstance.initFields();
5353     }
5354
5355     // @@protoc_insertion_point(class_scope:openxc.PassthroughModeControlCommand)
5356   }
5357
5358   public interface AcceptanceFilterBypassCommandOrBuilder
5359       extends com.google.protobuf.MessageOrBuilder {
5360
5361     // optional int32 bus = 1;
5362     /**
5363      * <code>optional int32 bus = 1;</code>
5364      */
5365     boolean hasBus();
5366     /**
5367      * <code>optional int32 bus = 1;</code>
5368      */
5369     int getBus();
5370
5371     // optional bool bypass = 2;
5372     /**
5373      * <code>optional bool bypass = 2;</code>
5374      */
5375     boolean hasBypass();
5376     /**
5377      * <code>optional bool bypass = 2;</code>
5378      */
5379     boolean getBypass();
5380   }
5381   /**
5382    * Protobuf type {@code openxc.AcceptanceFilterBypassCommand}
5383    */
5384   public static final class AcceptanceFilterBypassCommand extends
5385       com.google.protobuf.GeneratedMessage
5386       implements AcceptanceFilterBypassCommandOrBuilder {
5387     // Use AcceptanceFilterBypassCommand.newBuilder() to construct.
5388     private AcceptanceFilterBypassCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5389       super(builder);
5390       this.unknownFields = builder.getUnknownFields();
5391     }
5392     private AcceptanceFilterBypassCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5393
5394     private static final AcceptanceFilterBypassCommand defaultInstance;
5395     public static AcceptanceFilterBypassCommand getDefaultInstance() {
5396       return defaultInstance;
5397     }
5398
5399     public AcceptanceFilterBypassCommand getDefaultInstanceForType() {
5400       return defaultInstance;
5401     }
5402
5403     private final com.google.protobuf.UnknownFieldSet unknownFields;
5404     @java.lang.Override
5405     public final com.google.protobuf.UnknownFieldSet
5406         getUnknownFields() {
5407       return this.unknownFields;
5408     }
5409     private AcceptanceFilterBypassCommand(
5410         com.google.protobuf.CodedInputStream input,
5411         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5412         throws com.google.protobuf.InvalidProtocolBufferException {
5413       initFields();
5414       int mutable_bitField0_ = 0;
5415       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5416           com.google.protobuf.UnknownFieldSet.newBuilder();
5417       try {
5418         boolean done = false;
5419         while (!done) {
5420           int tag = input.readTag();
5421           switch (tag) {
5422             case 0:
5423               done = true;
5424               break;
5425             default: {
5426               if (!parseUnknownField(input, unknownFields,
5427                                      extensionRegistry, tag)) {
5428                 done = true;
5429               }
5430               break;
5431             }
5432             case 8: {
5433               bitField0_ |= 0x00000001;
5434               bus_ = input.readInt32();
5435               break;
5436             }
5437             case 16: {
5438               bitField0_ |= 0x00000002;
5439               bypass_ = input.readBool();
5440               break;
5441             }
5442           }
5443         }
5444       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5445         throw e.setUnfinishedMessage(this);
5446       } catch (java.io.IOException e) {
5447         throw new com.google.protobuf.InvalidProtocolBufferException(
5448             e.getMessage()).setUnfinishedMessage(this);
5449       } finally {
5450         this.unknownFields = unknownFields.build();
5451         makeExtensionsImmutable();
5452       }
5453     }
5454     public static final com.google.protobuf.Descriptors.Descriptor
5455         getDescriptor() {
5456       return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
5457     }
5458
5459     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5460         internalGetFieldAccessorTable() {
5461       return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable
5462           .ensureFieldAccessorsInitialized(
5463               com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.class, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder.class);
5464     }
5465
5466     public static com.google.protobuf.Parser<AcceptanceFilterBypassCommand> PARSER =
5467         new com.google.protobuf.AbstractParser<AcceptanceFilterBypassCommand>() {
5468       public AcceptanceFilterBypassCommand parsePartialFrom(
5469           com.google.protobuf.CodedInputStream input,
5470           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5471           throws com.google.protobuf.InvalidProtocolBufferException {
5472         return new AcceptanceFilterBypassCommand(input, extensionRegistry);
5473       }
5474     };
5475
5476     @java.lang.Override
5477     public com.google.protobuf.Parser<AcceptanceFilterBypassCommand> getParserForType() {
5478       return PARSER;
5479     }
5480
5481     private int bitField0_;
5482     // optional int32 bus = 1;
5483     public static final int BUS_FIELD_NUMBER = 1;
5484     private int bus_;
5485     /**
5486      * <code>optional int32 bus = 1;</code>
5487      */
5488     public boolean hasBus() {
5489       return ((bitField0_ & 0x00000001) == 0x00000001);
5490     }
5491     /**
5492      * <code>optional int32 bus = 1;</code>
5493      */
5494     public int getBus() {
5495       return bus_;
5496     }
5497
5498     // optional bool bypass = 2;
5499     public static final int BYPASS_FIELD_NUMBER = 2;
5500     private boolean bypass_;
5501     /**
5502      * <code>optional bool bypass = 2;</code>
5503      */
5504     public boolean hasBypass() {
5505       return ((bitField0_ & 0x00000002) == 0x00000002);
5506     }
5507     /**
5508      * <code>optional bool bypass = 2;</code>
5509      */
5510     public boolean getBypass() {
5511       return bypass_;
5512     }
5513
5514     private void initFields() {
5515       bus_ = 0;
5516       bypass_ = false;
5517     }
5518     private byte memoizedIsInitialized = -1;
5519     public final boolean isInitialized() {
5520       byte isInitialized = memoizedIsInitialized;
5521       if (isInitialized != -1) return isInitialized == 1;
5522
5523       memoizedIsInitialized = 1;
5524       return true;
5525     }
5526
5527     public void writeTo(com.google.protobuf.CodedOutputStream output)
5528                         throws java.io.IOException {
5529       getSerializedSize();
5530       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5531         output.writeInt32(1, bus_);
5532       }
5533       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5534         output.writeBool(2, bypass_);
5535       }
5536       getUnknownFields().writeTo(output);
5537     }
5538
5539     private int memoizedSerializedSize = -1;
5540     public int getSerializedSize() {
5541       int size = memoizedSerializedSize;
5542       if (size != -1) return size;
5543
5544       size = 0;
5545       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5546         size += com.google.protobuf.CodedOutputStream
5547           .computeInt32Size(1, bus_);
5548       }
5549       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5550         size += com.google.protobuf.CodedOutputStream
5551           .computeBoolSize(2, bypass_);
5552       }
5553       size += getUnknownFields().getSerializedSize();
5554       memoizedSerializedSize = size;
5555       return size;
5556     }
5557
5558     private static final long serialVersionUID = 0L;
5559     @java.lang.Override
5560     protected java.lang.Object writeReplace()
5561         throws java.io.ObjectStreamException {
5562       return super.writeReplace();
5563     }
5564
5565     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
5566         com.google.protobuf.ByteString data)
5567         throws com.google.protobuf.InvalidProtocolBufferException {
5568       return PARSER.parseFrom(data);
5569     }
5570     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
5571         com.google.protobuf.ByteString data,
5572         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5573         throws com.google.protobuf.InvalidProtocolBufferException {
5574       return PARSER.parseFrom(data, extensionRegistry);
5575     }
5576     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(byte[] data)
5577         throws com.google.protobuf.InvalidProtocolBufferException {
5578       return PARSER.parseFrom(data);
5579     }
5580     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
5581         byte[] data,
5582         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5583         throws com.google.protobuf.InvalidProtocolBufferException {
5584       return PARSER.parseFrom(data, extensionRegistry);
5585     }
5586     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(java.io.InputStream input)
5587         throws java.io.IOException {
5588       return PARSER.parseFrom(input);
5589     }
5590     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
5591         java.io.InputStream input,
5592         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5593         throws java.io.IOException {
5594       return PARSER.parseFrom(input, extensionRegistry);
5595     }
5596     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseDelimitedFrom(java.io.InputStream input)
5597         throws java.io.IOException {
5598       return PARSER.parseDelimitedFrom(input);
5599     }
5600     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseDelimitedFrom(
5601         java.io.InputStream input,
5602         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5603         throws java.io.IOException {
5604       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5605     }
5606     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
5607         com.google.protobuf.CodedInputStream input)
5608         throws java.io.IOException {
5609       return PARSER.parseFrom(input);
5610     }
5611     public static com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parseFrom(
5612         com.google.protobuf.CodedInputStream input,
5613         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5614         throws java.io.IOException {
5615       return PARSER.parseFrom(input, extensionRegistry);
5616     }
5617
5618     public static Builder newBuilder() { return Builder.create(); }
5619     public Builder newBuilderForType() { return newBuilder(); }
5620     public static Builder newBuilder(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand prototype) {
5621       return newBuilder().mergeFrom(prototype);
5622     }
5623     public Builder toBuilder() { return newBuilder(this); }
5624
5625     @java.lang.Override
5626     protected Builder newBuilderForType(
5627         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5628       Builder builder = new Builder(parent);
5629       return builder;
5630     }
5631     /**
5632      * Protobuf type {@code openxc.AcceptanceFilterBypassCommand}
5633      */
5634     public static final class Builder extends
5635         com.google.protobuf.GeneratedMessage.Builder<Builder>
5636        implements com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder {
5637       public static final com.google.protobuf.Descriptors.Descriptor
5638           getDescriptor() {
5639         return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
5640       }
5641
5642       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5643           internalGetFieldAccessorTable() {
5644         return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable
5645             .ensureFieldAccessorsInitialized(
5646                 com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.class, com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.Builder.class);
5647       }
5648
5649       // Construct using com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.newBuilder()
5650       private Builder() {
5651         maybeForceBuilderInitialization();
5652       }
5653
5654       private Builder(
5655           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5656         super(parent);
5657         maybeForceBuilderInitialization();
5658       }
5659       private void maybeForceBuilderInitialization() {
5660         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5661         }
5662       }
5663       private static Builder create() {
5664         return new Builder();
5665       }
5666
5667       public Builder clear() {
5668         super.clear();
5669         bus_ = 0;
5670         bitField0_ = (bitField0_ & ~0x00000001);
5671         bypass_ = false;
5672         bitField0_ = (bitField0_ & ~0x00000002);
5673         return this;
5674       }
5675
5676       public Builder clone() {
5677         return create().mergeFrom(buildPartial());
5678       }
5679
5680       public com.google.protobuf.Descriptors.Descriptor
5681           getDescriptorForType() {
5682         return com.openxc.BinaryMessages.internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
5683       }
5684
5685       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getDefaultInstanceForType() {
5686         return com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance();
5687       }
5688
5689       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand build() {
5690         com.openxc.BinaryMessages.AcceptanceFilterBypassCommand result = buildPartial();
5691         if (!result.isInitialized()) {
5692           throw newUninitializedMessageException(result);
5693         }
5694         return result;
5695       }
5696
5697       public com.openxc.BinaryMessages.AcceptanceFilterBypassCommand buildPartial() {
5698         com.openxc.BinaryMessages.AcceptanceFilterBypassCommand result = new com.openxc.BinaryMessages.AcceptanceFilterBypassCommand(this);
5699         int from_bitField0_ = bitField0_;
5700         int to_bitField0_ = 0;
5701         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5702           to_bitField0_ |= 0x00000001;
5703         }
5704         result.bus_ = bus_;
5705         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5706           to_bitField0_ |= 0x00000002;
5707         }
5708         result.bypass_ = bypass_;
5709         result.bitField0_ = to_bitField0_;
5710         onBuilt();
5711         return result;
5712       }
5713
5714       public Builder mergeFrom(com.google.protobuf.Message other) {
5715         if (other instanceof com.openxc.BinaryMessages.AcceptanceFilterBypassCommand) {
5716           return mergeFrom((com.openxc.BinaryMessages.AcceptanceFilterBypassCommand)other);
5717         } else {
5718           super.mergeFrom(other);
5719           return this;
5720         }
5721       }
5722
5723       public Builder mergeFrom(com.openxc.BinaryMessages.AcceptanceFilterBypassCommand other) {
5724         if (other == com.openxc.BinaryMessages.AcceptanceFilterBypassCommand.getDefaultInstance()) return this;
5725         if (other.hasBus()) {
5726           setBus(other.getBus());
5727         }
5728         if (other.hasBypass()) {
5729           setBypass(other.getBypass());
5730         }
5731         this.mergeUnknownFields(other.getUnknownFields());
5732         return this;
5733       }
5734
5735       public final boolean isInitialized() {
5736         return true;
5737       }
5738
5739       public Builder mergeFrom(
5740           com.google.protobuf.CodedInputStream input,
5741           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5742           throws java.io.IOException {
5743         com.openxc.BinaryMessages.AcceptanceFilterBypassCommand parsedMessage = null;
5744         try {
5745           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5746         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5747           parsedMessage = (com.openxc.BinaryMessages.AcceptanceFilterBypassCommand) e.getUnfinishedMessage();
5748           throw e;
5749         } finally {
5750           if (parsedMessage != null) {
5751             mergeFrom(parsedMessage);
5752           }
5753         }
5754         return this;
5755       }
5756       private int bitField0_;
5757
5758       // optional int32 bus = 1;
5759       private int bus_ ;
5760       /**
5761        * <code>optional int32 bus = 1;</code>
5762        */
5763       public boolean hasBus() {
5764         return ((bitField0_ & 0x00000001) == 0x00000001);
5765       }
5766       /**
5767        * <code>optional int32 bus = 1;</code>
5768        */
5769       public int getBus() {
5770         return bus_;
5771       }
5772       /**
5773        * <code>optional int32 bus = 1;</code>
5774        */
5775       public Builder setBus(int value) {
5776         bitField0_ |= 0x00000001;
5777         bus_ = value;
5778         onChanged();
5779         return this;
5780       }
5781       /**
5782        * <code>optional int32 bus = 1;</code>
5783        */
5784       public Builder clearBus() {
5785         bitField0_ = (bitField0_ & ~0x00000001);
5786         bus_ = 0;
5787         onChanged();
5788         return this;
5789       }
5790
5791       // optional bool bypass = 2;
5792       private boolean bypass_ ;
5793       /**
5794        * <code>optional bool bypass = 2;</code>
5795        */
5796       public boolean hasBypass() {
5797         return ((bitField0_ & 0x00000002) == 0x00000002);
5798       }
5799       /**
5800        * <code>optional bool bypass = 2;</code>
5801        */
5802       public boolean getBypass() {
5803         return bypass_;
5804       }
5805       /**
5806        * <code>optional bool bypass = 2;</code>
5807        */
5808       public Builder setBypass(boolean value) {
5809         bitField0_ |= 0x00000002;
5810         bypass_ = value;
5811         onChanged();
5812         return this;
5813       }
5814       /**
5815        * <code>optional bool bypass = 2;</code>
5816        */
5817       public Builder clearBypass() {
5818         bitField0_ = (bitField0_ & ~0x00000002);
5819         bypass_ = false;
5820         onChanged();
5821         return this;
5822       }
5823
5824       // @@protoc_insertion_point(builder_scope:openxc.AcceptanceFilterBypassCommand)
5825     }
5826
5827     static {
5828       defaultInstance = new AcceptanceFilterBypassCommand(true);
5829       defaultInstance.initFields();
5830     }
5831
5832     // @@protoc_insertion_point(class_scope:openxc.AcceptanceFilterBypassCommand)
5833   }
5834
5835   public interface PayloadFormatCommandOrBuilder
5836       extends com.google.protobuf.MessageOrBuilder {
5837
5838     // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
5839     /**
5840      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5841      */
5842     boolean hasFormat();
5843     /**
5844      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5845      */
5846     com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat();
5847   }
5848   /**
5849    * Protobuf type {@code openxc.PayloadFormatCommand}
5850    */
5851   public static final class PayloadFormatCommand extends
5852       com.google.protobuf.GeneratedMessage
5853       implements PayloadFormatCommandOrBuilder {
5854     // Use PayloadFormatCommand.newBuilder() to construct.
5855     private PayloadFormatCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5856       super(builder);
5857       this.unknownFields = builder.getUnknownFields();
5858     }
5859     private PayloadFormatCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5860
5861     private static final PayloadFormatCommand defaultInstance;
5862     public static PayloadFormatCommand getDefaultInstance() {
5863       return defaultInstance;
5864     }
5865
5866     public PayloadFormatCommand getDefaultInstanceForType() {
5867       return defaultInstance;
5868     }
5869
5870     private final com.google.protobuf.UnknownFieldSet unknownFields;
5871     @java.lang.Override
5872     public final com.google.protobuf.UnknownFieldSet
5873         getUnknownFields() {
5874       return this.unknownFields;
5875     }
5876     private PayloadFormatCommand(
5877         com.google.protobuf.CodedInputStream input,
5878         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5879         throws com.google.protobuf.InvalidProtocolBufferException {
5880       initFields();
5881       int mutable_bitField0_ = 0;
5882       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5883           com.google.protobuf.UnknownFieldSet.newBuilder();
5884       try {
5885         boolean done = false;
5886         while (!done) {
5887           int tag = input.readTag();
5888           switch (tag) {
5889             case 0:
5890               done = true;
5891               break;
5892             default: {
5893               if (!parseUnknownField(input, unknownFields,
5894                                      extensionRegistry, tag)) {
5895                 done = true;
5896               }
5897               break;
5898             }
5899             case 8: {
5900               int rawValue = input.readEnum();
5901               com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat value = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.valueOf(rawValue);
5902               if (value == null) {
5903                 unknownFields.mergeVarintField(1, rawValue);
5904               } else {
5905                 bitField0_ |= 0x00000001;
5906                 format_ = value;
5907               }
5908               break;
5909             }
5910           }
5911         }
5912       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5913         throw e.setUnfinishedMessage(this);
5914       } catch (java.io.IOException e) {
5915         throw new com.google.protobuf.InvalidProtocolBufferException(
5916             e.getMessage()).setUnfinishedMessage(this);
5917       } finally {
5918         this.unknownFields = unknownFields.build();
5919         makeExtensionsImmutable();
5920       }
5921     }
5922     public static final com.google.protobuf.Descriptors.Descriptor
5923         getDescriptor() {
5924       return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
5925     }
5926
5927     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5928         internalGetFieldAccessorTable() {
5929       return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_fieldAccessorTable
5930           .ensureFieldAccessorsInitialized(
5931               com.openxc.BinaryMessages.PayloadFormatCommand.class, com.openxc.BinaryMessages.PayloadFormatCommand.Builder.class);
5932     }
5933
5934     public static com.google.protobuf.Parser<PayloadFormatCommand> PARSER =
5935         new com.google.protobuf.AbstractParser<PayloadFormatCommand>() {
5936       public PayloadFormatCommand parsePartialFrom(
5937           com.google.protobuf.CodedInputStream input,
5938           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5939           throws com.google.protobuf.InvalidProtocolBufferException {
5940         return new PayloadFormatCommand(input, extensionRegistry);
5941       }
5942     };
5943
5944     @java.lang.Override
5945     public com.google.protobuf.Parser<PayloadFormatCommand> getParserForType() {
5946       return PARSER;
5947     }
5948
5949     /**
5950      * Protobuf enum {@code openxc.PayloadFormatCommand.PayloadFormat}
5951      */
5952     public enum PayloadFormat
5953         implements com.google.protobuf.ProtocolMessageEnum {
5954       /**
5955        * <code>JSON = 1;</code>
5956        */
5957       JSON(0, 1),
5958       /**
5959        * <code>PROTOBUF = 2;</code>
5960        */
5961       PROTOBUF(1, 2),
5962       /**
5963        * <code>MESSAGEPACK = 3;</code>
5964        */
5965       MESSAGEPACK(2, 3),
5966       ;
5967
5968       /**
5969        * <code>JSON = 1;</code>
5970        */
5971       public static final int JSON_VALUE = 1;
5972       /**
5973        * <code>PROTOBUF = 2;</code>
5974        */
5975       public static final int PROTOBUF_VALUE = 2;
5976       /**
5977        * <code>MESSAGEPACK = 3;</code>
5978        */
5979       public static final int MESSAGEPACK_VALUE = 3;
5980
5981
5982       public final int getNumber() { return value; }
5983
5984       public static PayloadFormat valueOf(int value) {
5985         switch (value) {
5986           case 1: return JSON;
5987           case 2: return PROTOBUF;
5988           case 3: return MESSAGEPACK;
5989           default: return null;
5990         }
5991       }
5992
5993       public static com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>
5994           internalGetValueMap() {
5995         return internalValueMap;
5996       }
5997       private static com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>
5998           internalValueMap =
5999             new com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>() {
6000               public PayloadFormat findValueByNumber(int number) {
6001                 return PayloadFormat.valueOf(number);
6002               }
6003             };
6004
6005       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6006           getValueDescriptor() {
6007         return getDescriptor().getValues().get(index);
6008       }
6009       public final com.google.protobuf.Descriptors.EnumDescriptor
6010           getDescriptorForType() {
6011         return getDescriptor();
6012       }
6013       public static final com.google.protobuf.Descriptors.EnumDescriptor
6014           getDescriptor() {
6015         return com.openxc.BinaryMessages.PayloadFormatCommand.getDescriptor().getEnumTypes().get(0);
6016       }
6017
6018       private static final PayloadFormat[] VALUES = values();
6019
6020       public static PayloadFormat valueOf(
6021           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6022         if (desc.getType() != getDescriptor()) {
6023           throw new java.lang.IllegalArgumentException(
6024             "EnumValueDescriptor is not for this type.");
6025         }
6026         return VALUES[desc.getIndex()];
6027       }
6028
6029       private final int index;
6030       private final int value;
6031
6032       private PayloadFormat(int index, int value) {
6033         this.index = index;
6034         this.value = value;
6035       }
6036
6037       // @@protoc_insertion_point(enum_scope:openxc.PayloadFormatCommand.PayloadFormat)
6038     }
6039
6040     private int bitField0_;
6041     // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
6042     public static final int FORMAT_FIELD_NUMBER = 1;
6043     private com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat format_;
6044     /**
6045      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
6046      */
6047     public boolean hasFormat() {
6048       return ((bitField0_ & 0x00000001) == 0x00000001);
6049     }
6050     /**
6051      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
6052      */
6053     public com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat() {
6054       return format_;
6055     }
6056
6057     private void initFields() {
6058       format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
6059     }
6060     private byte memoizedIsInitialized = -1;
6061     public final boolean isInitialized() {
6062       byte isInitialized = memoizedIsInitialized;
6063       if (isInitialized != -1) return isInitialized == 1;
6064
6065       memoizedIsInitialized = 1;
6066       return true;
6067     }
6068
6069     public void writeTo(com.google.protobuf.CodedOutputStream output)
6070                         throws java.io.IOException {
6071       getSerializedSize();
6072       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6073         output.writeEnum(1, format_.getNumber());
6074       }
6075       getUnknownFields().writeTo(output);
6076     }
6077
6078     private int memoizedSerializedSize = -1;
6079     public int getSerializedSize() {
6080       int size = memoizedSerializedSize;
6081       if (size != -1) return size;
6082
6083       size = 0;
6084       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6085         size += com.google.protobuf.CodedOutputStream
6086           .computeEnumSize(1, format_.getNumber());
6087       }
6088       size += getUnknownFields().getSerializedSize();
6089       memoizedSerializedSize = size;
6090       return size;
6091     }
6092
6093     private static final long serialVersionUID = 0L;
6094     @java.lang.Override
6095     protected java.lang.Object writeReplace()
6096         throws java.io.ObjectStreamException {
6097       return super.writeReplace();
6098     }
6099
6100     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
6101         com.google.protobuf.ByteString data)
6102         throws com.google.protobuf.InvalidProtocolBufferException {
6103       return PARSER.parseFrom(data);
6104     }
6105     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
6106         com.google.protobuf.ByteString data,
6107         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6108         throws com.google.protobuf.InvalidProtocolBufferException {
6109       return PARSER.parseFrom(data, extensionRegistry);
6110     }
6111     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(byte[] data)
6112         throws com.google.protobuf.InvalidProtocolBufferException {
6113       return PARSER.parseFrom(data);
6114     }
6115     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
6116         byte[] data,
6117         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6118         throws com.google.protobuf.InvalidProtocolBufferException {
6119       return PARSER.parseFrom(data, extensionRegistry);
6120     }
6121     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(java.io.InputStream input)
6122         throws java.io.IOException {
6123       return PARSER.parseFrom(input);
6124     }
6125     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
6126         java.io.InputStream input,
6127         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6128         throws java.io.IOException {
6129       return PARSER.parseFrom(input, extensionRegistry);
6130     }
6131     public static com.openxc.BinaryMessages.PayloadFormatCommand parseDelimitedFrom(java.io.InputStream input)
6132         throws java.io.IOException {
6133       return PARSER.parseDelimitedFrom(input);
6134     }
6135     public static com.openxc.BinaryMessages.PayloadFormatCommand parseDelimitedFrom(
6136         java.io.InputStream input,
6137         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6138         throws java.io.IOException {
6139       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6140     }
6141     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
6142         com.google.protobuf.CodedInputStream input)
6143         throws java.io.IOException {
6144       return PARSER.parseFrom(input);
6145     }
6146     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
6147         com.google.protobuf.CodedInputStream input,
6148         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6149         throws java.io.IOException {
6150       return PARSER.parseFrom(input, extensionRegistry);
6151     }
6152
6153     public static Builder newBuilder() { return Builder.create(); }
6154     public Builder newBuilderForType() { return newBuilder(); }
6155     public static Builder newBuilder(com.openxc.BinaryMessages.PayloadFormatCommand prototype) {
6156       return newBuilder().mergeFrom(prototype);
6157     }
6158     public Builder toBuilder() { return newBuilder(this); }
6159
6160     @java.lang.Override
6161     protected Builder newBuilderForType(
6162         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6163       Builder builder = new Builder(parent);
6164       return builder;
6165     }
6166     /**
6167      * Protobuf type {@code openxc.PayloadFormatCommand}
6168      */
6169     public static final class Builder extends
6170         com.google.protobuf.GeneratedMessage.Builder<Builder>
6171        implements com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder {
6172       public static final com.google.protobuf.Descriptors.Descriptor
6173           getDescriptor() {
6174         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
6175       }
6176
6177       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6178           internalGetFieldAccessorTable() {
6179         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_fieldAccessorTable
6180             .ensureFieldAccessorsInitialized(
6181                 com.openxc.BinaryMessages.PayloadFormatCommand.class, com.openxc.BinaryMessages.PayloadFormatCommand.Builder.class);
6182       }
6183
6184       // Construct using com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder()
6185       private Builder() {
6186         maybeForceBuilderInitialization();
6187       }
6188
6189       private Builder(
6190           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6191         super(parent);
6192         maybeForceBuilderInitialization();
6193       }
6194       private void maybeForceBuilderInitialization() {
6195         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6196         }
6197       }
6198       private static Builder create() {
6199         return new Builder();
6200       }
6201
6202       public Builder clear() {
6203         super.clear();
6204         format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
6205         bitField0_ = (bitField0_ & ~0x00000001);
6206         return this;
6207       }
6208
6209       public Builder clone() {
6210         return create().mergeFrom(buildPartial());
6211       }
6212
6213       public com.google.protobuf.Descriptors.Descriptor
6214           getDescriptorForType() {
6215         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
6216       }
6217
6218       public com.openxc.BinaryMessages.PayloadFormatCommand getDefaultInstanceForType() {
6219         return com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
6220       }
6221
6222       public com.openxc.BinaryMessages.PayloadFormatCommand build() {
6223         com.openxc.BinaryMessages.PayloadFormatCommand result = buildPartial();
6224         if (!result.isInitialized()) {
6225           throw newUninitializedMessageException(result);
6226         }
6227         return result;
6228       }
6229
6230       public com.openxc.BinaryMessages.PayloadFormatCommand buildPartial() {
6231         com.openxc.BinaryMessages.PayloadFormatCommand result = new com.openxc.BinaryMessages.PayloadFormatCommand(this);
6232         int from_bitField0_ = bitField0_;
6233         int to_bitField0_ = 0;
6234         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6235           to_bitField0_ |= 0x00000001;
6236         }
6237         result.format_ = format_;
6238         result.bitField0_ = to_bitField0_;
6239         onBuilt();
6240         return result;
6241       }
6242
6243       public Builder mergeFrom(com.google.protobuf.Message other) {
6244         if (other instanceof com.openxc.BinaryMessages.PayloadFormatCommand) {
6245           return mergeFrom((com.openxc.BinaryMessages.PayloadFormatCommand)other);
6246         } else {
6247           super.mergeFrom(other);
6248           return this;
6249         }
6250       }
6251
6252       public Builder mergeFrom(com.openxc.BinaryMessages.PayloadFormatCommand other) {
6253         if (other == com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance()) return this;
6254         if (other.hasFormat()) {
6255           setFormat(other.getFormat());
6256         }
6257         this.mergeUnknownFields(other.getUnknownFields());
6258         return this;
6259       }
6260
6261       public final boolean isInitialized() {
6262         return true;
6263       }
6264
6265       public Builder mergeFrom(
6266           com.google.protobuf.CodedInputStream input,
6267           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6268           throws java.io.IOException {
6269         com.openxc.BinaryMessages.PayloadFormatCommand parsedMessage = null;
6270         try {
6271           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6272         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6273           parsedMessage = (com.openxc.BinaryMessages.PayloadFormatCommand) e.getUnfinishedMessage();
6274           throw e;
6275         } finally {
6276           if (parsedMessage != null) {
6277             mergeFrom(parsedMessage);
6278           }
6279         }
6280         return this;
6281       }
6282       private int bitField0_;
6283
6284       // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
6285       private com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
6286       /**
6287        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
6288        */
6289       public boolean hasFormat() {
6290         return ((bitField0_ & 0x00000001) == 0x00000001);
6291       }
6292       /**
6293        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
6294        */
6295       public com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat() {
6296         return format_;
6297       }
6298       /**
6299        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
6300        */
6301       public Builder setFormat(com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat value) {
6302         if (value == null) {
6303           throw new NullPointerException();
6304         }
6305         bitField0_ |= 0x00000001;
6306         format_ = value;
6307         onChanged();
6308         return this;
6309       }
6310       /**
6311        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
6312        */
6313       public Builder clearFormat() {
6314         bitField0_ = (bitField0_ & ~0x00000001);
6315         format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
6316         onChanged();
6317         return this;
6318       }
6319
6320       // @@protoc_insertion_point(builder_scope:openxc.PayloadFormatCommand)
6321     }
6322
6323     static {
6324       defaultInstance = new PayloadFormatCommand(true);
6325       defaultInstance.initFields();
6326     }
6327
6328     // @@protoc_insertion_point(class_scope:openxc.PayloadFormatCommand)
6329   }
6330
6331   public interface PredefinedObd2RequestsCommandOrBuilder
6332       extends com.google.protobuf.MessageOrBuilder {
6333
6334     // optional bool enabled = 1;
6335     /**
6336      * <code>optional bool enabled = 1;</code>
6337      */
6338     boolean hasEnabled();
6339     /**
6340      * <code>optional bool enabled = 1;</code>
6341      */
6342     boolean getEnabled();
6343   }
6344   /**
6345    * Protobuf type {@code openxc.PredefinedObd2RequestsCommand}
6346    */
6347   public static final class PredefinedObd2RequestsCommand extends
6348       com.google.protobuf.GeneratedMessage
6349       implements PredefinedObd2RequestsCommandOrBuilder {
6350     // Use PredefinedObd2RequestsCommand.newBuilder() to construct.
6351     private PredefinedObd2RequestsCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6352       super(builder);
6353       this.unknownFields = builder.getUnknownFields();
6354     }
6355     private PredefinedObd2RequestsCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6356
6357     private static final PredefinedObd2RequestsCommand defaultInstance;
6358     public static PredefinedObd2RequestsCommand getDefaultInstance() {
6359       return defaultInstance;
6360     }
6361
6362     public PredefinedObd2RequestsCommand getDefaultInstanceForType() {
6363       return defaultInstance;
6364     }
6365
6366     private final com.google.protobuf.UnknownFieldSet unknownFields;
6367     @java.lang.Override
6368     public final com.google.protobuf.UnknownFieldSet
6369         getUnknownFields() {
6370       return this.unknownFields;
6371     }
6372     private PredefinedObd2RequestsCommand(
6373         com.google.protobuf.CodedInputStream input,
6374         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6375         throws com.google.protobuf.InvalidProtocolBufferException {
6376       initFields();
6377       int mutable_bitField0_ = 0;
6378       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6379           com.google.protobuf.UnknownFieldSet.newBuilder();
6380       try {
6381         boolean done = false;
6382         while (!done) {
6383           int tag = input.readTag();
6384           switch (tag) {
6385             case 0:
6386               done = true;
6387               break;
6388             default: {
6389               if (!parseUnknownField(input, unknownFields,
6390                                      extensionRegistry, tag)) {
6391                 done = true;
6392               }
6393               break;
6394             }
6395             case 8: {
6396               bitField0_ |= 0x00000001;
6397               enabled_ = input.readBool();
6398               break;
6399             }
6400           }
6401         }
6402       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6403         throw e.setUnfinishedMessage(this);
6404       } catch (java.io.IOException e) {
6405         throw new com.google.protobuf.InvalidProtocolBufferException(
6406             e.getMessage()).setUnfinishedMessage(this);
6407       } finally {
6408         this.unknownFields = unknownFields.build();
6409         makeExtensionsImmutable();
6410       }
6411     }
6412     public static final com.google.protobuf.Descriptors.Descriptor
6413         getDescriptor() {
6414       return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
6415     }
6416
6417     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6418         internalGetFieldAccessorTable() {
6419       return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable
6420           .ensureFieldAccessorsInitialized(
6421               com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.class, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder.class);
6422     }
6423
6424     public static com.google.protobuf.Parser<PredefinedObd2RequestsCommand> PARSER =
6425         new com.google.protobuf.AbstractParser<PredefinedObd2RequestsCommand>() {
6426       public PredefinedObd2RequestsCommand parsePartialFrom(
6427           com.google.protobuf.CodedInputStream input,
6428           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6429           throws com.google.protobuf.InvalidProtocolBufferException {
6430         return new PredefinedObd2RequestsCommand(input, extensionRegistry);
6431       }
6432     };
6433
6434     @java.lang.Override
6435     public com.google.protobuf.Parser<PredefinedObd2RequestsCommand> getParserForType() {
6436       return PARSER;
6437     }
6438
6439     private int bitField0_;
6440     // optional bool enabled = 1;
6441     public static final int ENABLED_FIELD_NUMBER = 1;
6442     private boolean enabled_;
6443     /**
6444      * <code>optional bool enabled = 1;</code>
6445      */
6446     public boolean hasEnabled() {
6447       return ((bitField0_ & 0x00000001) == 0x00000001);
6448     }
6449     /**
6450      * <code>optional bool enabled = 1;</code>
6451      */
6452     public boolean getEnabled() {
6453       return enabled_;
6454     }
6455
6456     private void initFields() {
6457       enabled_ = false;
6458     }
6459     private byte memoizedIsInitialized = -1;
6460     public final boolean isInitialized() {
6461       byte isInitialized = memoizedIsInitialized;
6462       if (isInitialized != -1) return isInitialized == 1;
6463
6464       memoizedIsInitialized = 1;
6465       return true;
6466     }
6467
6468     public void writeTo(com.google.protobuf.CodedOutputStream output)
6469                         throws java.io.IOException {
6470       getSerializedSize();
6471       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6472         output.writeBool(1, enabled_);
6473       }
6474       getUnknownFields().writeTo(output);
6475     }
6476
6477     private int memoizedSerializedSize = -1;
6478     public int getSerializedSize() {
6479       int size = memoizedSerializedSize;
6480       if (size != -1) return size;
6481
6482       size = 0;
6483       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6484         size += com.google.protobuf.CodedOutputStream
6485           .computeBoolSize(1, enabled_);
6486       }
6487       size += getUnknownFields().getSerializedSize();
6488       memoizedSerializedSize = size;
6489       return size;
6490     }
6491
6492     private static final long serialVersionUID = 0L;
6493     @java.lang.Override
6494     protected java.lang.Object writeReplace()
6495         throws java.io.ObjectStreamException {
6496       return super.writeReplace();
6497     }
6498
6499     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
6500         com.google.protobuf.ByteString data)
6501         throws com.google.protobuf.InvalidProtocolBufferException {
6502       return PARSER.parseFrom(data);
6503     }
6504     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
6505         com.google.protobuf.ByteString data,
6506         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6507         throws com.google.protobuf.InvalidProtocolBufferException {
6508       return PARSER.parseFrom(data, extensionRegistry);
6509     }
6510     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(byte[] data)
6511         throws com.google.protobuf.InvalidProtocolBufferException {
6512       return PARSER.parseFrom(data);
6513     }
6514     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
6515         byte[] data,
6516         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6517         throws com.google.protobuf.InvalidProtocolBufferException {
6518       return PARSER.parseFrom(data, extensionRegistry);
6519     }
6520     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(java.io.InputStream input)
6521         throws java.io.IOException {
6522       return PARSER.parseFrom(input);
6523     }
6524     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
6525         java.io.InputStream input,
6526         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6527         throws java.io.IOException {
6528       return PARSER.parseFrom(input, extensionRegistry);
6529     }
6530     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseDelimitedFrom(java.io.InputStream input)
6531         throws java.io.IOException {
6532       return PARSER.parseDelimitedFrom(input);
6533     }
6534     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseDelimitedFrom(
6535         java.io.InputStream input,
6536         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6537         throws java.io.IOException {
6538       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6539     }
6540     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
6541         com.google.protobuf.CodedInputStream input)
6542         throws java.io.IOException {
6543       return PARSER.parseFrom(input);
6544     }
6545     public static com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parseFrom(
6546         com.google.protobuf.CodedInputStream input,
6547         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6548         throws java.io.IOException {
6549       return PARSER.parseFrom(input, extensionRegistry);
6550     }
6551
6552     public static Builder newBuilder() { return Builder.create(); }
6553     public Builder newBuilderForType() { return newBuilder(); }
6554     public static Builder newBuilder(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand prototype) {
6555       return newBuilder().mergeFrom(prototype);
6556     }
6557     public Builder toBuilder() { return newBuilder(this); }
6558
6559     @java.lang.Override
6560     protected Builder newBuilderForType(
6561         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6562       Builder builder = new Builder(parent);
6563       return builder;
6564     }
6565     /**
6566      * Protobuf type {@code openxc.PredefinedObd2RequestsCommand}
6567      */
6568     public static final class Builder extends
6569         com.google.protobuf.GeneratedMessage.Builder<Builder>
6570        implements com.openxc.BinaryMessages.PredefinedObd2RequestsCommandOrBuilder {
6571       public static final com.google.protobuf.Descriptors.Descriptor
6572           getDescriptor() {
6573         return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
6574       }
6575
6576       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6577           internalGetFieldAccessorTable() {
6578         return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable
6579             .ensureFieldAccessorsInitialized(
6580                 com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.class, com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.Builder.class);
6581       }
6582
6583       // Construct using com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.newBuilder()
6584       private Builder() {
6585         maybeForceBuilderInitialization();
6586       }
6587
6588       private Builder(
6589           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6590         super(parent);
6591         maybeForceBuilderInitialization();
6592       }
6593       private void maybeForceBuilderInitialization() {
6594         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6595         }
6596       }
6597       private static Builder create() {
6598         return new Builder();
6599       }
6600
6601       public Builder clear() {
6602         super.clear();
6603         enabled_ = false;
6604         bitField0_ = (bitField0_ & ~0x00000001);
6605         return this;
6606       }
6607
6608       public Builder clone() {
6609         return create().mergeFrom(buildPartial());
6610       }
6611
6612       public com.google.protobuf.Descriptors.Descriptor
6613           getDescriptorForType() {
6614         return com.openxc.BinaryMessages.internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
6615       }
6616
6617       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand getDefaultInstanceForType() {
6618         return com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance();
6619       }
6620
6621       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand build() {
6622         com.openxc.BinaryMessages.PredefinedObd2RequestsCommand result = buildPartial();
6623         if (!result.isInitialized()) {
6624           throw newUninitializedMessageException(result);
6625         }
6626         return result;
6627       }
6628
6629       public com.openxc.BinaryMessages.PredefinedObd2RequestsCommand buildPartial() {
6630         com.openxc.BinaryMessages.PredefinedObd2RequestsCommand result = new com.openxc.BinaryMessages.PredefinedObd2RequestsCommand(this);
6631         int from_bitField0_ = bitField0_;
6632         int to_bitField0_ = 0;
6633         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6634           to_bitField0_ |= 0x00000001;
6635         }
6636         result.enabled_ = enabled_;
6637         result.bitField0_ = to_bitField0_;
6638         onBuilt();
6639         return result;
6640       }
6641
6642       public Builder mergeFrom(com.google.protobuf.Message other) {
6643         if (other instanceof com.openxc.BinaryMessages.PredefinedObd2RequestsCommand) {
6644           return mergeFrom((com.openxc.BinaryMessages.PredefinedObd2RequestsCommand)other);
6645         } else {
6646           super.mergeFrom(other);
6647           return this;
6648         }
6649       }
6650
6651       public Builder mergeFrom(com.openxc.BinaryMessages.PredefinedObd2RequestsCommand other) {
6652         if (other == com.openxc.BinaryMessages.PredefinedObd2RequestsCommand.getDefaultInstance()) return this;
6653         if (other.hasEnabled()) {
6654           setEnabled(other.getEnabled());
6655         }
6656         this.mergeUnknownFields(other.getUnknownFields());
6657         return this;
6658       }
6659
6660       public final boolean isInitialized() {
6661         return true;
6662       }
6663
6664       public Builder mergeFrom(
6665           com.google.protobuf.CodedInputStream input,
6666           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6667           throws java.io.IOException {
6668         com.openxc.BinaryMessages.PredefinedObd2RequestsCommand parsedMessage = null;
6669         try {
6670           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6671         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6672           parsedMessage = (com.openxc.BinaryMessages.PredefinedObd2RequestsCommand) e.getUnfinishedMessage();
6673           throw e;
6674         } finally {
6675           if (parsedMessage != null) {
6676             mergeFrom(parsedMessage);
6677           }
6678         }
6679         return this;
6680       }
6681       private int bitField0_;
6682
6683       // optional bool enabled = 1;
6684       private boolean enabled_ ;
6685       /**
6686        * <code>optional bool enabled = 1;</code>
6687        */
6688       public boolean hasEnabled() {
6689         return ((bitField0_ & 0x00000001) == 0x00000001);
6690       }
6691       /**
6692        * <code>optional bool enabled = 1;</code>
6693        */
6694       public boolean getEnabled() {
6695         return enabled_;
6696       }
6697       /**
6698        * <code>optional bool enabled = 1;</code>
6699        */
6700       public Builder setEnabled(boolean value) {
6701         bitField0_ |= 0x00000001;
6702         enabled_ = value;
6703         onChanged();
6704         return this;
6705       }
6706       /**
6707        * <code>optional bool enabled = 1;</code>
6708        */
6709       public Builder clearEnabled() {
6710         bitField0_ = (bitField0_ & ~0x00000001);
6711         enabled_ = false;
6712         onChanged();
6713         return this;
6714       }
6715
6716       // @@protoc_insertion_point(builder_scope:openxc.PredefinedObd2RequestsCommand)
6717     }
6718
6719     static {
6720       defaultInstance = new PredefinedObd2RequestsCommand(true);
6721       defaultInstance.initFields();
6722     }
6723
6724     // @@protoc_insertion_point(class_scope:openxc.PredefinedObd2RequestsCommand)
6725   }
6726
6727   public interface NetworkOperatorSettingsOrBuilder
6728       extends com.google.protobuf.MessageOrBuilder {
6729
6730     // optional bool allowDataRoaming = 1;
6731     /**
6732      * <code>optional bool allowDataRoaming = 1;</code>
6733      */
6734     boolean hasAllowDataRoaming();
6735     /**
6736      * <code>optional bool allowDataRoaming = 1;</code>
6737      */
6738     boolean getAllowDataRoaming();
6739
6740     // optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;
6741     /**
6742      * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
6743      */
6744     boolean hasOperatorSelectMode();
6745     /**
6746      * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
6747      */
6748     com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode getOperatorSelectMode();
6749
6750     // optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;
6751     /**
6752      * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
6753      */
6754     boolean hasNetworkDescriptor();
6755     /**
6756      * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
6757      */
6758     com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getNetworkDescriptor();
6759     /**
6760      * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
6761      */
6762     com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder getNetworkDescriptorOrBuilder();
6763   }
6764   /**
6765    * Protobuf type {@code openxc.NetworkOperatorSettings}
6766    */
6767   public static final class NetworkOperatorSettings extends
6768       com.google.protobuf.GeneratedMessage
6769       implements NetworkOperatorSettingsOrBuilder {
6770     // Use NetworkOperatorSettings.newBuilder() to construct.
6771     private NetworkOperatorSettings(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6772       super(builder);
6773       this.unknownFields = builder.getUnknownFields();
6774     }
6775     private NetworkOperatorSettings(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6776
6777     private static final NetworkOperatorSettings defaultInstance;
6778     public static NetworkOperatorSettings getDefaultInstance() {
6779       return defaultInstance;
6780     }
6781
6782     public NetworkOperatorSettings getDefaultInstanceForType() {
6783       return defaultInstance;
6784     }
6785
6786     private final com.google.protobuf.UnknownFieldSet unknownFields;
6787     @java.lang.Override
6788     public final com.google.protobuf.UnknownFieldSet
6789         getUnknownFields() {
6790       return this.unknownFields;
6791     }
6792     private NetworkOperatorSettings(
6793         com.google.protobuf.CodedInputStream input,
6794         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6795         throws com.google.protobuf.InvalidProtocolBufferException {
6796       initFields();
6797       int mutable_bitField0_ = 0;
6798       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6799           com.google.protobuf.UnknownFieldSet.newBuilder();
6800       try {
6801         boolean done = false;
6802         while (!done) {
6803           int tag = input.readTag();
6804           switch (tag) {
6805             case 0:
6806               done = true;
6807               break;
6808             default: {
6809               if (!parseUnknownField(input, unknownFields,
6810                                      extensionRegistry, tag)) {
6811                 done = true;
6812               }
6813               break;
6814             }
6815             case 8: {
6816               bitField0_ |= 0x00000001;
6817               allowDataRoaming_ = input.readBool();
6818               break;
6819             }
6820             case 16: {
6821               int rawValue = input.readEnum();
6822               com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode value = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.valueOf(rawValue);
6823               if (value == null) {
6824                 unknownFields.mergeVarintField(2, rawValue);
6825               } else {
6826                 bitField0_ |= 0x00000002;
6827                 operatorSelectMode_ = value;
6828               }
6829               break;
6830             }
6831             case 26: {
6832               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder subBuilder = null;
6833               if (((bitField0_ & 0x00000004) == 0x00000004)) {
6834                 subBuilder = networkDescriptor_.toBuilder();
6835               }
6836               networkDescriptor_ = input.readMessage(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.PARSER, extensionRegistry);
6837               if (subBuilder != null) {
6838                 subBuilder.mergeFrom(networkDescriptor_);
6839                 networkDescriptor_ = subBuilder.buildPartial();
6840               }
6841               bitField0_ |= 0x00000004;
6842               break;
6843             }
6844           }
6845         }
6846       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6847         throw e.setUnfinishedMessage(this);
6848       } catch (java.io.IOException e) {
6849         throw new com.google.protobuf.InvalidProtocolBufferException(
6850             e.getMessage()).setUnfinishedMessage(this);
6851       } finally {
6852         this.unknownFields = unknownFields.build();
6853         makeExtensionsImmutable();
6854       }
6855     }
6856     public static final com.google.protobuf.Descriptors.Descriptor
6857         getDescriptor() {
6858       return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_descriptor;
6859     }
6860
6861     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6862         internalGetFieldAccessorTable() {
6863       return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable
6864           .ensureFieldAccessorsInitialized(
6865               com.openxc.BinaryMessages.NetworkOperatorSettings.class, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder.class);
6866     }
6867
6868     public static com.google.protobuf.Parser<NetworkOperatorSettings> PARSER =
6869         new com.google.protobuf.AbstractParser<NetworkOperatorSettings>() {
6870       public NetworkOperatorSettings parsePartialFrom(
6871           com.google.protobuf.CodedInputStream input,
6872           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6873           throws com.google.protobuf.InvalidProtocolBufferException {
6874         return new NetworkOperatorSettings(input, extensionRegistry);
6875       }
6876     };
6877
6878     @java.lang.Override
6879     public com.google.protobuf.Parser<NetworkOperatorSettings> getParserForType() {
6880       return PARSER;
6881     }
6882
6883     /**
6884      * Protobuf enum {@code openxc.NetworkOperatorSettings.OperatorSelectMode}
6885      */
6886     public enum OperatorSelectMode
6887         implements com.google.protobuf.ProtocolMessageEnum {
6888       /**
6889        * <code>AUTOMATIC = 0;</code>
6890        */
6891       AUTOMATIC(0, 0),
6892       /**
6893        * <code>MANUAL = 1;</code>
6894        */
6895       MANUAL(1, 1),
6896       /**
6897        * <code>DEREGISTER = 2;</code>
6898        */
6899       DEREGISTER(2, 2),
6900       /**
6901        * <code>SET_ONLY = 3;</code>
6902        */
6903       SET_ONLY(3, 3),
6904       /**
6905        * <code>MANUAL_AUTOMATIC = 4;</code>
6906        */
6907       MANUAL_AUTOMATIC(4, 4),
6908       ;
6909
6910       /**
6911        * <code>AUTOMATIC = 0;</code>
6912        */
6913       public static final int AUTOMATIC_VALUE = 0;
6914       /**
6915        * <code>MANUAL = 1;</code>
6916        */
6917       public static final int MANUAL_VALUE = 1;
6918       /**
6919        * <code>DEREGISTER = 2;</code>
6920        */
6921       public static final int DEREGISTER_VALUE = 2;
6922       /**
6923        * <code>SET_ONLY = 3;</code>
6924        */
6925       public static final int SET_ONLY_VALUE = 3;
6926       /**
6927        * <code>MANUAL_AUTOMATIC = 4;</code>
6928        */
6929       public static final int MANUAL_AUTOMATIC_VALUE = 4;
6930
6931
6932       public final int getNumber() { return value; }
6933
6934       public static OperatorSelectMode valueOf(int value) {
6935         switch (value) {
6936           case 0: return AUTOMATIC;
6937           case 1: return MANUAL;
6938           case 2: return DEREGISTER;
6939           case 3: return SET_ONLY;
6940           case 4: return MANUAL_AUTOMATIC;
6941           default: return null;
6942         }
6943       }
6944
6945       public static com.google.protobuf.Internal.EnumLiteMap<OperatorSelectMode>
6946           internalGetValueMap() {
6947         return internalValueMap;
6948       }
6949       private static com.google.protobuf.Internal.EnumLiteMap<OperatorSelectMode>
6950           internalValueMap =
6951             new com.google.protobuf.Internal.EnumLiteMap<OperatorSelectMode>() {
6952               public OperatorSelectMode findValueByNumber(int number) {
6953                 return OperatorSelectMode.valueOf(number);
6954               }
6955             };
6956
6957       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6958           getValueDescriptor() {
6959         return getDescriptor().getValues().get(index);
6960       }
6961       public final com.google.protobuf.Descriptors.EnumDescriptor
6962           getDescriptorForType() {
6963         return getDescriptor();
6964       }
6965       public static final com.google.protobuf.Descriptors.EnumDescriptor
6966           getDescriptor() {
6967         return com.openxc.BinaryMessages.NetworkOperatorSettings.getDescriptor().getEnumTypes().get(0);
6968       }
6969
6970       private static final OperatorSelectMode[] VALUES = values();
6971
6972       public static OperatorSelectMode valueOf(
6973           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6974         if (desc.getType() != getDescriptor()) {
6975           throw new java.lang.IllegalArgumentException(
6976             "EnumValueDescriptor is not for this type.");
6977         }
6978         return VALUES[desc.getIndex()];
6979       }
6980
6981       private final int index;
6982       private final int value;
6983
6984       private OperatorSelectMode(int index, int value) {
6985         this.index = index;
6986         this.value = value;
6987       }
6988
6989       // @@protoc_insertion_point(enum_scope:openxc.NetworkOperatorSettings.OperatorSelectMode)
6990     }
6991
6992     public interface NetworkDescriptorOrBuilder
6993         extends com.google.protobuf.MessageOrBuilder {
6994
6995       // optional uint32 PLMN = 1;
6996       /**
6997        * <code>optional uint32 PLMN = 1;</code>
6998        */
6999       boolean hasPLMN();
7000       /**
7001        * <code>optional uint32 PLMN = 1;</code>
7002        */
7003       int getPLMN();
7004
7005       // optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;
7006       /**
7007        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7008        */
7009       boolean hasNetworkType();
7010       /**
7011        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7012        */
7013       com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType getNetworkType();
7014     }
7015     /**
7016      * Protobuf type {@code openxc.NetworkOperatorSettings.NetworkDescriptor}
7017      */
7018     public static final class NetworkDescriptor extends
7019         com.google.protobuf.GeneratedMessage
7020         implements NetworkDescriptorOrBuilder {
7021       // Use NetworkDescriptor.newBuilder() to construct.
7022       private NetworkDescriptor(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
7023         super(builder);
7024         this.unknownFields = builder.getUnknownFields();
7025       }
7026       private NetworkDescriptor(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
7027
7028       private static final NetworkDescriptor defaultInstance;
7029       public static NetworkDescriptor getDefaultInstance() {
7030         return defaultInstance;
7031       }
7032
7033       public NetworkDescriptor getDefaultInstanceForType() {
7034         return defaultInstance;
7035       }
7036
7037       private final com.google.protobuf.UnknownFieldSet unknownFields;
7038       @java.lang.Override
7039       public final com.google.protobuf.UnknownFieldSet
7040           getUnknownFields() {
7041         return this.unknownFields;
7042       }
7043       private NetworkDescriptor(
7044           com.google.protobuf.CodedInputStream input,
7045           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7046           throws com.google.protobuf.InvalidProtocolBufferException {
7047         initFields();
7048         int mutable_bitField0_ = 0;
7049         com.google.protobuf.UnknownFieldSet.Builder unknownFields =
7050             com.google.protobuf.UnknownFieldSet.newBuilder();
7051         try {
7052           boolean done = false;
7053           while (!done) {
7054             int tag = input.readTag();
7055             switch (tag) {
7056               case 0:
7057                 done = true;
7058                 break;
7059               default: {
7060                 if (!parseUnknownField(input, unknownFields,
7061                                        extensionRegistry, tag)) {
7062                   done = true;
7063                 }
7064                 break;
7065               }
7066               case 8: {
7067                 bitField0_ |= 0x00000001;
7068                 pLMN_ = input.readUInt32();
7069                 break;
7070               }
7071               case 16: {
7072                 int rawValue = input.readEnum();
7073                 com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType value = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.valueOf(rawValue);
7074                 if (value == null) {
7075                   unknownFields.mergeVarintField(2, rawValue);
7076                 } else {
7077                   bitField0_ |= 0x00000002;
7078                   networkType_ = value;
7079                 }
7080                 break;
7081               }
7082             }
7083           }
7084         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7085           throw e.setUnfinishedMessage(this);
7086         } catch (java.io.IOException e) {
7087           throw new com.google.protobuf.InvalidProtocolBufferException(
7088               e.getMessage()).setUnfinishedMessage(this);
7089         } finally {
7090           this.unknownFields = unknownFields.build();
7091           makeExtensionsImmutable();
7092         }
7093       }
7094       public static final com.google.protobuf.Descriptors.Descriptor
7095           getDescriptor() {
7096         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
7097       }
7098
7099       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7100           internalGetFieldAccessorTable() {
7101         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable
7102             .ensureFieldAccessorsInitialized(
7103                 com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.class, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder.class);
7104       }
7105
7106       public static com.google.protobuf.Parser<NetworkDescriptor> PARSER =
7107           new com.google.protobuf.AbstractParser<NetworkDescriptor>() {
7108         public NetworkDescriptor parsePartialFrom(
7109             com.google.protobuf.CodedInputStream input,
7110             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7111             throws com.google.protobuf.InvalidProtocolBufferException {
7112           return new NetworkDescriptor(input, extensionRegistry);
7113         }
7114       };
7115
7116       @java.lang.Override
7117       public com.google.protobuf.Parser<NetworkDescriptor> getParserForType() {
7118         return PARSER;
7119       }
7120
7121       /**
7122        * Protobuf enum {@code openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType}
7123        */
7124       public enum NetworkType
7125           implements com.google.protobuf.ProtocolMessageEnum {
7126         /**
7127          * <code>GSM = 0;</code>
7128          */
7129         GSM(0, 0),
7130         /**
7131          * <code>UTRAN = 2;</code>
7132          */
7133         UTRAN(1, 2),
7134         ;
7135
7136         /**
7137          * <code>GSM = 0;</code>
7138          */
7139         public static final int GSM_VALUE = 0;
7140         /**
7141          * <code>UTRAN = 2;</code>
7142          */
7143         public static final int UTRAN_VALUE = 2;
7144
7145
7146         public final int getNumber() { return value; }
7147
7148         public static NetworkType valueOf(int value) {
7149           switch (value) {
7150             case 0: return GSM;
7151             case 2: return UTRAN;
7152             default: return null;
7153           }
7154         }
7155
7156         public static com.google.protobuf.Internal.EnumLiteMap<NetworkType>
7157             internalGetValueMap() {
7158           return internalValueMap;
7159         }
7160         private static com.google.protobuf.Internal.EnumLiteMap<NetworkType>
7161             internalValueMap =
7162               new com.google.protobuf.Internal.EnumLiteMap<NetworkType>() {
7163                 public NetworkType findValueByNumber(int number) {
7164                   return NetworkType.valueOf(number);
7165                 }
7166               };
7167
7168         public final com.google.protobuf.Descriptors.EnumValueDescriptor
7169             getValueDescriptor() {
7170           return getDescriptor().getValues().get(index);
7171         }
7172         public final com.google.protobuf.Descriptors.EnumDescriptor
7173             getDescriptorForType() {
7174           return getDescriptor();
7175         }
7176         public static final com.google.protobuf.Descriptors.EnumDescriptor
7177             getDescriptor() {
7178           return com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDescriptor().getEnumTypes().get(0);
7179         }
7180
7181         private static final NetworkType[] VALUES = values();
7182
7183         public static NetworkType valueOf(
7184             com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
7185           if (desc.getType() != getDescriptor()) {
7186             throw new java.lang.IllegalArgumentException(
7187               "EnumValueDescriptor is not for this type.");
7188           }
7189           return VALUES[desc.getIndex()];
7190         }
7191
7192         private final int index;
7193         private final int value;
7194
7195         private NetworkType(int index, int value) {
7196           this.index = index;
7197           this.value = value;
7198         }
7199
7200         // @@protoc_insertion_point(enum_scope:openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType)
7201       }
7202
7203       private int bitField0_;
7204       // optional uint32 PLMN = 1;
7205       public static final int PLMN_FIELD_NUMBER = 1;
7206       private int pLMN_;
7207       /**
7208        * <code>optional uint32 PLMN = 1;</code>
7209        */
7210       public boolean hasPLMN() {
7211         return ((bitField0_ & 0x00000001) == 0x00000001);
7212       }
7213       /**
7214        * <code>optional uint32 PLMN = 1;</code>
7215        */
7216       public int getPLMN() {
7217         return pLMN_;
7218       }
7219
7220       // optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;
7221       public static final int NETWORKTYPE_FIELD_NUMBER = 2;
7222       private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType_;
7223       /**
7224        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7225        */
7226       public boolean hasNetworkType() {
7227         return ((bitField0_ & 0x00000002) == 0x00000002);
7228       }
7229       /**
7230        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7231        */
7232       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType getNetworkType() {
7233         return networkType_;
7234       }
7235
7236       private void initFields() {
7237         pLMN_ = 0;
7238         networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
7239       }
7240       private byte memoizedIsInitialized = -1;
7241       public final boolean isInitialized() {
7242         byte isInitialized = memoizedIsInitialized;
7243         if (isInitialized != -1) return isInitialized == 1;
7244
7245         memoizedIsInitialized = 1;
7246         return true;
7247       }
7248
7249       public void writeTo(com.google.protobuf.CodedOutputStream output)
7250                           throws java.io.IOException {
7251         getSerializedSize();
7252         if (((bitField0_ & 0x00000001) == 0x00000001)) {
7253           output.writeUInt32(1, pLMN_);
7254         }
7255         if (((bitField0_ & 0x00000002) == 0x00000002)) {
7256           output.writeEnum(2, networkType_.getNumber());
7257         }
7258         getUnknownFields().writeTo(output);
7259       }
7260
7261       private int memoizedSerializedSize = -1;
7262       public int getSerializedSize() {
7263         int size = memoizedSerializedSize;
7264         if (size != -1) return size;
7265
7266         size = 0;
7267         if (((bitField0_ & 0x00000001) == 0x00000001)) {
7268           size += com.google.protobuf.CodedOutputStream
7269             .computeUInt32Size(1, pLMN_);
7270         }
7271         if (((bitField0_ & 0x00000002) == 0x00000002)) {
7272           size += com.google.protobuf.CodedOutputStream
7273             .computeEnumSize(2, networkType_.getNumber());
7274         }
7275         size += getUnknownFields().getSerializedSize();
7276         memoizedSerializedSize = size;
7277         return size;
7278       }
7279
7280       private static final long serialVersionUID = 0L;
7281       @java.lang.Override
7282       protected java.lang.Object writeReplace()
7283           throws java.io.ObjectStreamException {
7284         return super.writeReplace();
7285       }
7286
7287       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
7288           com.google.protobuf.ByteString data)
7289           throws com.google.protobuf.InvalidProtocolBufferException {
7290         return PARSER.parseFrom(data);
7291       }
7292       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
7293           com.google.protobuf.ByteString data,
7294           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7295           throws com.google.protobuf.InvalidProtocolBufferException {
7296         return PARSER.parseFrom(data, extensionRegistry);
7297       }
7298       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(byte[] data)
7299           throws com.google.protobuf.InvalidProtocolBufferException {
7300         return PARSER.parseFrom(data);
7301       }
7302       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
7303           byte[] data,
7304           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7305           throws com.google.protobuf.InvalidProtocolBufferException {
7306         return PARSER.parseFrom(data, extensionRegistry);
7307       }
7308       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(java.io.InputStream input)
7309           throws java.io.IOException {
7310         return PARSER.parseFrom(input);
7311       }
7312       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
7313           java.io.InputStream input,
7314           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7315           throws java.io.IOException {
7316         return PARSER.parseFrom(input, extensionRegistry);
7317       }
7318       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseDelimitedFrom(java.io.InputStream input)
7319           throws java.io.IOException {
7320         return PARSER.parseDelimitedFrom(input);
7321       }
7322       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseDelimitedFrom(
7323           java.io.InputStream input,
7324           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7325           throws java.io.IOException {
7326         return PARSER.parseDelimitedFrom(input, extensionRegistry);
7327       }
7328       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
7329           com.google.protobuf.CodedInputStream input)
7330           throws java.io.IOException {
7331         return PARSER.parseFrom(input);
7332       }
7333       public static com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parseFrom(
7334           com.google.protobuf.CodedInputStream input,
7335           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7336           throws java.io.IOException {
7337         return PARSER.parseFrom(input, extensionRegistry);
7338       }
7339
7340       public static Builder newBuilder() { return Builder.create(); }
7341       public Builder newBuilderForType() { return newBuilder(); }
7342       public static Builder newBuilder(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor prototype) {
7343         return newBuilder().mergeFrom(prototype);
7344       }
7345       public Builder toBuilder() { return newBuilder(this); }
7346
7347       @java.lang.Override
7348       protected Builder newBuilderForType(
7349           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7350         Builder builder = new Builder(parent);
7351         return builder;
7352       }
7353       /**
7354        * Protobuf type {@code openxc.NetworkOperatorSettings.NetworkDescriptor}
7355        */
7356       public static final class Builder extends
7357           com.google.protobuf.GeneratedMessage.Builder<Builder>
7358          implements com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder {
7359         public static final com.google.protobuf.Descriptors.Descriptor
7360             getDescriptor() {
7361           return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
7362         }
7363
7364         protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7365             internalGetFieldAccessorTable() {
7366           return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable
7367               .ensureFieldAccessorsInitialized(
7368                   com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.class, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder.class);
7369         }
7370
7371         // Construct using com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.newBuilder()
7372         private Builder() {
7373           maybeForceBuilderInitialization();
7374         }
7375
7376         private Builder(
7377             com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7378           super(parent);
7379           maybeForceBuilderInitialization();
7380         }
7381         private void maybeForceBuilderInitialization() {
7382           if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7383           }
7384         }
7385         private static Builder create() {
7386           return new Builder();
7387         }
7388
7389         public Builder clear() {
7390           super.clear();
7391           pLMN_ = 0;
7392           bitField0_ = (bitField0_ & ~0x00000001);
7393           networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
7394           bitField0_ = (bitField0_ & ~0x00000002);
7395           return this;
7396         }
7397
7398         public Builder clone() {
7399           return create().mergeFrom(buildPartial());
7400         }
7401
7402         public com.google.protobuf.Descriptors.Descriptor
7403             getDescriptorForType() {
7404           return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
7405         }
7406
7407         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getDefaultInstanceForType() {
7408           return com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
7409         }
7410
7411         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor build() {
7412           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor result = buildPartial();
7413           if (!result.isInitialized()) {
7414             throw newUninitializedMessageException(result);
7415           }
7416           return result;
7417         }
7418
7419         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor buildPartial() {
7420           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor result = new com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor(this);
7421           int from_bitField0_ = bitField0_;
7422           int to_bitField0_ = 0;
7423           if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7424             to_bitField0_ |= 0x00000001;
7425           }
7426           result.pLMN_ = pLMN_;
7427           if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7428             to_bitField0_ |= 0x00000002;
7429           }
7430           result.networkType_ = networkType_;
7431           result.bitField0_ = to_bitField0_;
7432           onBuilt();
7433           return result;
7434         }
7435
7436         public Builder mergeFrom(com.google.protobuf.Message other) {
7437           if (other instanceof com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor) {
7438             return mergeFrom((com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor)other);
7439           } else {
7440             super.mergeFrom(other);
7441             return this;
7442           }
7443         }
7444
7445         public Builder mergeFrom(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor other) {
7446           if (other == com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance()) return this;
7447           if (other.hasPLMN()) {
7448             setPLMN(other.getPLMN());
7449           }
7450           if (other.hasNetworkType()) {
7451             setNetworkType(other.getNetworkType());
7452           }
7453           this.mergeUnknownFields(other.getUnknownFields());
7454           return this;
7455         }
7456
7457         public final boolean isInitialized() {
7458           return true;
7459         }
7460
7461         public Builder mergeFrom(
7462             com.google.protobuf.CodedInputStream input,
7463             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7464             throws java.io.IOException {
7465           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor parsedMessage = null;
7466           try {
7467             parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
7468           } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7469             parsedMessage = (com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor) e.getUnfinishedMessage();
7470             throw e;
7471           } finally {
7472             if (parsedMessage != null) {
7473               mergeFrom(parsedMessage);
7474             }
7475           }
7476           return this;
7477         }
7478         private int bitField0_;
7479
7480         // optional uint32 PLMN = 1;
7481         private int pLMN_ ;
7482         /**
7483          * <code>optional uint32 PLMN = 1;</code>
7484          */
7485         public boolean hasPLMN() {
7486           return ((bitField0_ & 0x00000001) == 0x00000001);
7487         }
7488         /**
7489          * <code>optional uint32 PLMN = 1;</code>
7490          */
7491         public int getPLMN() {
7492           return pLMN_;
7493         }
7494         /**
7495          * <code>optional uint32 PLMN = 1;</code>
7496          */
7497         public Builder setPLMN(int value) {
7498           bitField0_ |= 0x00000001;
7499           pLMN_ = value;
7500           onChanged();
7501           return this;
7502         }
7503         /**
7504          * <code>optional uint32 PLMN = 1;</code>
7505          */
7506         public Builder clearPLMN() {
7507           bitField0_ = (bitField0_ & ~0x00000001);
7508           pLMN_ = 0;
7509           onChanged();
7510           return this;
7511         }
7512
7513         // optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;
7514         private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
7515         /**
7516          * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7517          */
7518         public boolean hasNetworkType() {
7519           return ((bitField0_ & 0x00000002) == 0x00000002);
7520         }
7521         /**
7522          * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7523          */
7524         public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType getNetworkType() {
7525           return networkType_;
7526         }
7527         /**
7528          * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7529          */
7530         public Builder setNetworkType(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType value) {
7531           if (value == null) {
7532             throw new NullPointerException();
7533           }
7534           bitField0_ |= 0x00000002;
7535           networkType_ = value;
7536           onChanged();
7537           return this;
7538         }
7539         /**
7540          * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType networkType = 2;</code>
7541          */
7542         public Builder clearNetworkType() {
7543           bitField0_ = (bitField0_ & ~0x00000002);
7544           networkType_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.NetworkType.GSM;
7545           onChanged();
7546           return this;
7547         }
7548
7549         // @@protoc_insertion_point(builder_scope:openxc.NetworkOperatorSettings.NetworkDescriptor)
7550       }
7551
7552       static {
7553         defaultInstance = new NetworkDescriptor(true);
7554         defaultInstance.initFields();
7555       }
7556
7557       // @@protoc_insertion_point(class_scope:openxc.NetworkOperatorSettings.NetworkDescriptor)
7558     }
7559
7560     private int bitField0_;
7561     // optional bool allowDataRoaming = 1;
7562     public static final int ALLOWDATAROAMING_FIELD_NUMBER = 1;
7563     private boolean allowDataRoaming_;
7564     /**
7565      * <code>optional bool allowDataRoaming = 1;</code>
7566      */
7567     public boolean hasAllowDataRoaming() {
7568       return ((bitField0_ & 0x00000001) == 0x00000001);
7569     }
7570     /**
7571      * <code>optional bool allowDataRoaming = 1;</code>
7572      */
7573     public boolean getAllowDataRoaming() {
7574       return allowDataRoaming_;
7575     }
7576
7577     // optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;
7578     public static final int OPERATORSELECTMODE_FIELD_NUMBER = 2;
7579     private com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode_;
7580     /**
7581      * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
7582      */
7583     public boolean hasOperatorSelectMode() {
7584       return ((bitField0_ & 0x00000002) == 0x00000002);
7585     }
7586     /**
7587      * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
7588      */
7589     public com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode getOperatorSelectMode() {
7590       return operatorSelectMode_;
7591     }
7592
7593     // optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;
7594     public static final int NETWORKDESCRIPTOR_FIELD_NUMBER = 3;
7595     private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor networkDescriptor_;
7596     /**
7597      * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7598      */
7599     public boolean hasNetworkDescriptor() {
7600       return ((bitField0_ & 0x00000004) == 0x00000004);
7601     }
7602     /**
7603      * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7604      */
7605     public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getNetworkDescriptor() {
7606       return networkDescriptor_;
7607     }
7608     /**
7609      * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7610      */
7611     public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder getNetworkDescriptorOrBuilder() {
7612       return networkDescriptor_;
7613     }
7614
7615     private void initFields() {
7616       allowDataRoaming_ = false;
7617       operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
7618       networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
7619     }
7620     private byte memoizedIsInitialized = -1;
7621     public final boolean isInitialized() {
7622       byte isInitialized = memoizedIsInitialized;
7623       if (isInitialized != -1) return isInitialized == 1;
7624
7625       memoizedIsInitialized = 1;
7626       return true;
7627     }
7628
7629     public void writeTo(com.google.protobuf.CodedOutputStream output)
7630                         throws java.io.IOException {
7631       getSerializedSize();
7632       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7633         output.writeBool(1, allowDataRoaming_);
7634       }
7635       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7636         output.writeEnum(2, operatorSelectMode_.getNumber());
7637       }
7638       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7639         output.writeMessage(3, networkDescriptor_);
7640       }
7641       getUnknownFields().writeTo(output);
7642     }
7643
7644     private int memoizedSerializedSize = -1;
7645     public int getSerializedSize() {
7646       int size = memoizedSerializedSize;
7647       if (size != -1) return size;
7648
7649       size = 0;
7650       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7651         size += com.google.protobuf.CodedOutputStream
7652           .computeBoolSize(1, allowDataRoaming_);
7653       }
7654       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7655         size += com.google.protobuf.CodedOutputStream
7656           .computeEnumSize(2, operatorSelectMode_.getNumber());
7657       }
7658       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7659         size += com.google.protobuf.CodedOutputStream
7660           .computeMessageSize(3, networkDescriptor_);
7661       }
7662       size += getUnknownFields().getSerializedSize();
7663       memoizedSerializedSize = size;
7664       return size;
7665     }
7666
7667     private static final long serialVersionUID = 0L;
7668     @java.lang.Override
7669     protected java.lang.Object writeReplace()
7670         throws java.io.ObjectStreamException {
7671       return super.writeReplace();
7672     }
7673
7674     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
7675         com.google.protobuf.ByteString data)
7676         throws com.google.protobuf.InvalidProtocolBufferException {
7677       return PARSER.parseFrom(data);
7678     }
7679     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
7680         com.google.protobuf.ByteString data,
7681         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7682         throws com.google.protobuf.InvalidProtocolBufferException {
7683       return PARSER.parseFrom(data, extensionRegistry);
7684     }
7685     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(byte[] data)
7686         throws com.google.protobuf.InvalidProtocolBufferException {
7687       return PARSER.parseFrom(data);
7688     }
7689     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
7690         byte[] data,
7691         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7692         throws com.google.protobuf.InvalidProtocolBufferException {
7693       return PARSER.parseFrom(data, extensionRegistry);
7694     }
7695     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(java.io.InputStream input)
7696         throws java.io.IOException {
7697       return PARSER.parseFrom(input);
7698     }
7699     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
7700         java.io.InputStream input,
7701         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7702         throws java.io.IOException {
7703       return PARSER.parseFrom(input, extensionRegistry);
7704     }
7705     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseDelimitedFrom(java.io.InputStream input)
7706         throws java.io.IOException {
7707       return PARSER.parseDelimitedFrom(input);
7708     }
7709     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseDelimitedFrom(
7710         java.io.InputStream input,
7711         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7712         throws java.io.IOException {
7713       return PARSER.parseDelimitedFrom(input, extensionRegistry);
7714     }
7715     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
7716         com.google.protobuf.CodedInputStream input)
7717         throws java.io.IOException {
7718       return PARSER.parseFrom(input);
7719     }
7720     public static com.openxc.BinaryMessages.NetworkOperatorSettings parseFrom(
7721         com.google.protobuf.CodedInputStream input,
7722         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7723         throws java.io.IOException {
7724       return PARSER.parseFrom(input, extensionRegistry);
7725     }
7726
7727     public static Builder newBuilder() { return Builder.create(); }
7728     public Builder newBuilderForType() { return newBuilder(); }
7729     public static Builder newBuilder(com.openxc.BinaryMessages.NetworkOperatorSettings prototype) {
7730       return newBuilder().mergeFrom(prototype);
7731     }
7732     public Builder toBuilder() { return newBuilder(this); }
7733
7734     @java.lang.Override
7735     protected Builder newBuilderForType(
7736         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7737       Builder builder = new Builder(parent);
7738       return builder;
7739     }
7740     /**
7741      * Protobuf type {@code openxc.NetworkOperatorSettings}
7742      */
7743     public static final class Builder extends
7744         com.google.protobuf.GeneratedMessage.Builder<Builder>
7745        implements com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder {
7746       public static final com.google.protobuf.Descriptors.Descriptor
7747           getDescriptor() {
7748         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_descriptor;
7749       }
7750
7751       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7752           internalGetFieldAccessorTable() {
7753         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable
7754             .ensureFieldAccessorsInitialized(
7755                 com.openxc.BinaryMessages.NetworkOperatorSettings.class, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder.class);
7756       }
7757
7758       // Construct using com.openxc.BinaryMessages.NetworkOperatorSettings.newBuilder()
7759       private Builder() {
7760         maybeForceBuilderInitialization();
7761       }
7762
7763       private Builder(
7764           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7765         super(parent);
7766         maybeForceBuilderInitialization();
7767       }
7768       private void maybeForceBuilderInitialization() {
7769         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7770           getNetworkDescriptorFieldBuilder();
7771         }
7772       }
7773       private static Builder create() {
7774         return new Builder();
7775       }
7776
7777       public Builder clear() {
7778         super.clear();
7779         allowDataRoaming_ = false;
7780         bitField0_ = (bitField0_ & ~0x00000001);
7781         operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
7782         bitField0_ = (bitField0_ & ~0x00000002);
7783         if (networkDescriptorBuilder_ == null) {
7784           networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
7785         } else {
7786           networkDescriptorBuilder_.clear();
7787         }
7788         bitField0_ = (bitField0_ & ~0x00000004);
7789         return this;
7790       }
7791
7792       public Builder clone() {
7793         return create().mergeFrom(buildPartial());
7794       }
7795
7796       public com.google.protobuf.Descriptors.Descriptor
7797           getDescriptorForType() {
7798         return com.openxc.BinaryMessages.internal_static_openxc_NetworkOperatorSettings_descriptor;
7799       }
7800
7801       public com.openxc.BinaryMessages.NetworkOperatorSettings getDefaultInstanceForType() {
7802         return com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
7803       }
7804
7805       public com.openxc.BinaryMessages.NetworkOperatorSettings build() {
7806         com.openxc.BinaryMessages.NetworkOperatorSettings result = buildPartial();
7807         if (!result.isInitialized()) {
7808           throw newUninitializedMessageException(result);
7809         }
7810         return result;
7811       }
7812
7813       public com.openxc.BinaryMessages.NetworkOperatorSettings buildPartial() {
7814         com.openxc.BinaryMessages.NetworkOperatorSettings result = new com.openxc.BinaryMessages.NetworkOperatorSettings(this);
7815         int from_bitField0_ = bitField0_;
7816         int to_bitField0_ = 0;
7817         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7818           to_bitField0_ |= 0x00000001;
7819         }
7820         result.allowDataRoaming_ = allowDataRoaming_;
7821         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7822           to_bitField0_ |= 0x00000002;
7823         }
7824         result.operatorSelectMode_ = operatorSelectMode_;
7825         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
7826           to_bitField0_ |= 0x00000004;
7827         }
7828         if (networkDescriptorBuilder_ == null) {
7829           result.networkDescriptor_ = networkDescriptor_;
7830         } else {
7831           result.networkDescriptor_ = networkDescriptorBuilder_.build();
7832         }
7833         result.bitField0_ = to_bitField0_;
7834         onBuilt();
7835         return result;
7836       }
7837
7838       public Builder mergeFrom(com.google.protobuf.Message other) {
7839         if (other instanceof com.openxc.BinaryMessages.NetworkOperatorSettings) {
7840           return mergeFrom((com.openxc.BinaryMessages.NetworkOperatorSettings)other);
7841         } else {
7842           super.mergeFrom(other);
7843           return this;
7844         }
7845       }
7846
7847       public Builder mergeFrom(com.openxc.BinaryMessages.NetworkOperatorSettings other) {
7848         if (other == com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance()) return this;
7849         if (other.hasAllowDataRoaming()) {
7850           setAllowDataRoaming(other.getAllowDataRoaming());
7851         }
7852         if (other.hasOperatorSelectMode()) {
7853           setOperatorSelectMode(other.getOperatorSelectMode());
7854         }
7855         if (other.hasNetworkDescriptor()) {
7856           mergeNetworkDescriptor(other.getNetworkDescriptor());
7857         }
7858         this.mergeUnknownFields(other.getUnknownFields());
7859         return this;
7860       }
7861
7862       public final boolean isInitialized() {
7863         return true;
7864       }
7865
7866       public Builder mergeFrom(
7867           com.google.protobuf.CodedInputStream input,
7868           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7869           throws java.io.IOException {
7870         com.openxc.BinaryMessages.NetworkOperatorSettings parsedMessage = null;
7871         try {
7872           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
7873         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7874           parsedMessage = (com.openxc.BinaryMessages.NetworkOperatorSettings) e.getUnfinishedMessage();
7875           throw e;
7876         } finally {
7877           if (parsedMessage != null) {
7878             mergeFrom(parsedMessage);
7879           }
7880         }
7881         return this;
7882       }
7883       private int bitField0_;
7884
7885       // optional bool allowDataRoaming = 1;
7886       private boolean allowDataRoaming_ ;
7887       /**
7888        * <code>optional bool allowDataRoaming = 1;</code>
7889        */
7890       public boolean hasAllowDataRoaming() {
7891         return ((bitField0_ & 0x00000001) == 0x00000001);
7892       }
7893       /**
7894        * <code>optional bool allowDataRoaming = 1;</code>
7895        */
7896       public boolean getAllowDataRoaming() {
7897         return allowDataRoaming_;
7898       }
7899       /**
7900        * <code>optional bool allowDataRoaming = 1;</code>
7901        */
7902       public Builder setAllowDataRoaming(boolean value) {
7903         bitField0_ |= 0x00000001;
7904         allowDataRoaming_ = value;
7905         onChanged();
7906         return this;
7907       }
7908       /**
7909        * <code>optional bool allowDataRoaming = 1;</code>
7910        */
7911       public Builder clearAllowDataRoaming() {
7912         bitField0_ = (bitField0_ & ~0x00000001);
7913         allowDataRoaming_ = false;
7914         onChanged();
7915         return this;
7916       }
7917
7918       // optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;
7919       private com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
7920       /**
7921        * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
7922        */
7923       public boolean hasOperatorSelectMode() {
7924         return ((bitField0_ & 0x00000002) == 0x00000002);
7925       }
7926       /**
7927        * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
7928        */
7929       public com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode getOperatorSelectMode() {
7930         return operatorSelectMode_;
7931       }
7932       /**
7933        * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
7934        */
7935       public Builder setOperatorSelectMode(com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode value) {
7936         if (value == null) {
7937           throw new NullPointerException();
7938         }
7939         bitField0_ |= 0x00000002;
7940         operatorSelectMode_ = value;
7941         onChanged();
7942         return this;
7943       }
7944       /**
7945        * <code>optional .openxc.NetworkOperatorSettings.OperatorSelectMode operatorSelectMode = 2;</code>
7946        */
7947       public Builder clearOperatorSelectMode() {
7948         bitField0_ = (bitField0_ & ~0x00000002);
7949         operatorSelectMode_ = com.openxc.BinaryMessages.NetworkOperatorSettings.OperatorSelectMode.AUTOMATIC;
7950         onChanged();
7951         return this;
7952       }
7953
7954       // optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;
7955       private com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
7956       private com.google.protobuf.SingleFieldBuilder<
7957           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder> networkDescriptorBuilder_;
7958       /**
7959        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7960        */
7961       public boolean hasNetworkDescriptor() {
7962         return ((bitField0_ & 0x00000004) == 0x00000004);
7963       }
7964       /**
7965        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7966        */
7967       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor getNetworkDescriptor() {
7968         if (networkDescriptorBuilder_ == null) {
7969           return networkDescriptor_;
7970         } else {
7971           return networkDescriptorBuilder_.getMessage();
7972         }
7973       }
7974       /**
7975        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7976        */
7977       public Builder setNetworkDescriptor(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor value) {
7978         if (networkDescriptorBuilder_ == null) {
7979           if (value == null) {
7980             throw new NullPointerException();
7981           }
7982           networkDescriptor_ = value;
7983           onChanged();
7984         } else {
7985           networkDescriptorBuilder_.setMessage(value);
7986         }
7987         bitField0_ |= 0x00000004;
7988         return this;
7989       }
7990       /**
7991        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
7992        */
7993       public Builder setNetworkDescriptor(
7994           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder builderForValue) {
7995         if (networkDescriptorBuilder_ == null) {
7996           networkDescriptor_ = builderForValue.build();
7997           onChanged();
7998         } else {
7999           networkDescriptorBuilder_.setMessage(builderForValue.build());
8000         }
8001         bitField0_ |= 0x00000004;
8002         return this;
8003       }
8004       /**
8005        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
8006        */
8007       public Builder mergeNetworkDescriptor(com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor value) {
8008         if (networkDescriptorBuilder_ == null) {
8009           if (((bitField0_ & 0x00000004) == 0x00000004) &&
8010               networkDescriptor_ != com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance()) {
8011             networkDescriptor_ =
8012               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.newBuilder(networkDescriptor_).mergeFrom(value).buildPartial();
8013           } else {
8014             networkDescriptor_ = value;
8015           }
8016           onChanged();
8017         } else {
8018           networkDescriptorBuilder_.mergeFrom(value);
8019         }
8020         bitField0_ |= 0x00000004;
8021         return this;
8022       }
8023       /**
8024        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
8025        */
8026       public Builder clearNetworkDescriptor() {
8027         if (networkDescriptorBuilder_ == null) {
8028           networkDescriptor_ = com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.getDefaultInstance();
8029           onChanged();
8030         } else {
8031           networkDescriptorBuilder_.clear();
8032         }
8033         bitField0_ = (bitField0_ & ~0x00000004);
8034         return this;
8035       }
8036       /**
8037        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
8038        */
8039       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder getNetworkDescriptorBuilder() {
8040         bitField0_ |= 0x00000004;
8041         onChanged();
8042         return getNetworkDescriptorFieldBuilder().getBuilder();
8043       }
8044       /**
8045        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
8046        */
8047       public com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder getNetworkDescriptorOrBuilder() {
8048         if (networkDescriptorBuilder_ != null) {
8049           return networkDescriptorBuilder_.getMessageOrBuilder();
8050         } else {
8051           return networkDescriptor_;
8052         }
8053       }
8054       /**
8055        * <code>optional .openxc.NetworkOperatorSettings.NetworkDescriptor networkDescriptor = 3;</code>
8056        */
8057       private com.google.protobuf.SingleFieldBuilder<
8058           com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder>
8059           getNetworkDescriptorFieldBuilder() {
8060         if (networkDescriptorBuilder_ == null) {
8061           networkDescriptorBuilder_ = new com.google.protobuf.SingleFieldBuilder<
8062               com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptor.Builder, com.openxc.BinaryMessages.NetworkOperatorSettings.NetworkDescriptorOrBuilder>(
8063                   networkDescriptor_,
8064                   getParentForChildren(),
8065                   isClean());
8066           networkDescriptor_ = null;
8067         }
8068         return networkDescriptorBuilder_;
8069       }
8070
8071       // @@protoc_insertion_point(builder_scope:openxc.NetworkOperatorSettings)
8072     }
8073
8074     static {
8075       defaultInstance = new NetworkOperatorSettings(true);
8076       defaultInstance.initFields();
8077     }
8078
8079     // @@protoc_insertion_point(class_scope:openxc.NetworkOperatorSettings)
8080   }
8081
8082   public interface NetworkDataSettingsOrBuilder
8083       extends com.google.protobuf.MessageOrBuilder {
8084
8085     // optional string APN = 1;
8086     /**
8087      * <code>optional string APN = 1;</code>
8088      */
8089     boolean hasAPN();
8090     /**
8091      * <code>optional string APN = 1;</code>
8092      */
8093     java.lang.String getAPN();
8094     /**
8095      * <code>optional string APN = 1;</code>
8096      */
8097     com.google.protobuf.ByteString
8098         getAPNBytes();
8099   }
8100   /**
8101    * Protobuf type {@code openxc.NetworkDataSettings}
8102    */
8103   public static final class NetworkDataSettings extends
8104       com.google.protobuf.GeneratedMessage
8105       implements NetworkDataSettingsOrBuilder {
8106     // Use NetworkDataSettings.newBuilder() to construct.
8107     private NetworkDataSettings(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
8108       super(builder);
8109       this.unknownFields = builder.getUnknownFields();
8110     }
8111     private NetworkDataSettings(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
8112
8113     private static final NetworkDataSettings defaultInstance;
8114     public static NetworkDataSettings getDefaultInstance() {
8115       return defaultInstance;
8116     }
8117
8118     public NetworkDataSettings getDefaultInstanceForType() {
8119       return defaultInstance;
8120     }
8121
8122     private final com.google.protobuf.UnknownFieldSet unknownFields;
8123     @java.lang.Override
8124     public final com.google.protobuf.UnknownFieldSet
8125         getUnknownFields() {
8126       return this.unknownFields;
8127     }
8128     private NetworkDataSettings(
8129         com.google.protobuf.CodedInputStream input,
8130         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8131         throws com.google.protobuf.InvalidProtocolBufferException {
8132       initFields();
8133       int mutable_bitField0_ = 0;
8134       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
8135           com.google.protobuf.UnknownFieldSet.newBuilder();
8136       try {
8137         boolean done = false;
8138         while (!done) {
8139           int tag = input.readTag();
8140           switch (tag) {
8141             case 0:
8142               done = true;
8143               break;
8144             default: {
8145               if (!parseUnknownField(input, unknownFields,
8146                                      extensionRegistry, tag)) {
8147                 done = true;
8148               }
8149               break;
8150             }
8151             case 10: {
8152               bitField0_ |= 0x00000001;
8153               aPN_ = input.readBytes();
8154               break;
8155             }
8156           }
8157         }
8158       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8159         throw e.setUnfinishedMessage(this);
8160       } catch (java.io.IOException e) {
8161         throw new com.google.protobuf.InvalidProtocolBufferException(
8162             e.getMessage()).setUnfinishedMessage(this);
8163       } finally {
8164         this.unknownFields = unknownFields.build();
8165         makeExtensionsImmutable();
8166       }
8167     }
8168     public static final com.google.protobuf.Descriptors.Descriptor
8169         getDescriptor() {
8170       return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_descriptor;
8171     }
8172
8173     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8174         internalGetFieldAccessorTable() {
8175       return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_fieldAccessorTable
8176           .ensureFieldAccessorsInitialized(
8177               com.openxc.BinaryMessages.NetworkDataSettings.class, com.openxc.BinaryMessages.NetworkDataSettings.Builder.class);
8178     }
8179
8180     public static com.google.protobuf.Parser<NetworkDataSettings> PARSER =
8181         new com.google.protobuf.AbstractParser<NetworkDataSettings>() {
8182       public NetworkDataSettings parsePartialFrom(
8183           com.google.protobuf.CodedInputStream input,
8184           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8185           throws com.google.protobuf.InvalidProtocolBufferException {
8186         return new NetworkDataSettings(input, extensionRegistry);
8187       }
8188     };
8189
8190     @java.lang.Override
8191     public com.google.protobuf.Parser<NetworkDataSettings> getParserForType() {
8192       return PARSER;
8193     }
8194
8195     private int bitField0_;
8196     // optional string APN = 1;
8197     public static final int APN_FIELD_NUMBER = 1;
8198     private java.lang.Object aPN_;
8199     /**
8200      * <code>optional string APN = 1;</code>
8201      */
8202     public boolean hasAPN() {
8203       return ((bitField0_ & 0x00000001) == 0x00000001);
8204     }
8205     /**
8206      * <code>optional string APN = 1;</code>
8207      */
8208     public java.lang.String getAPN() {
8209       java.lang.Object ref = aPN_;
8210       if (ref instanceof java.lang.String) {
8211         return (java.lang.String) ref;
8212       } else {
8213         com.google.protobuf.ByteString bs =
8214             (com.google.protobuf.ByteString) ref;
8215         java.lang.String s = bs.toStringUtf8();
8216         if (bs.isValidUtf8()) {
8217           aPN_ = s;
8218         }
8219         return s;
8220       }
8221     }
8222     /**
8223      * <code>optional string APN = 1;</code>
8224      */
8225     public com.google.protobuf.ByteString
8226         getAPNBytes() {
8227       java.lang.Object ref = aPN_;
8228       if (ref instanceof java.lang.String) {
8229         com.google.protobuf.ByteString b =
8230             com.google.protobuf.ByteString.copyFromUtf8(
8231                 (java.lang.String) ref);
8232         aPN_ = b;
8233         return b;
8234       } else {
8235         return (com.google.protobuf.ByteString) ref;
8236       }
8237     }
8238
8239     private void initFields() {
8240       aPN_ = "";
8241     }
8242     private byte memoizedIsInitialized = -1;
8243     public final boolean isInitialized() {
8244       byte isInitialized = memoizedIsInitialized;
8245       if (isInitialized != -1) return isInitialized == 1;
8246
8247       memoizedIsInitialized = 1;
8248       return true;
8249     }
8250
8251     public void writeTo(com.google.protobuf.CodedOutputStream output)
8252                         throws java.io.IOException {
8253       getSerializedSize();
8254       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8255         output.writeBytes(1, getAPNBytes());
8256       }
8257       getUnknownFields().writeTo(output);
8258     }
8259
8260     private int memoizedSerializedSize = -1;
8261     public int getSerializedSize() {
8262       int size = memoizedSerializedSize;
8263       if (size != -1) return size;
8264
8265       size = 0;
8266       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8267         size += com.google.protobuf.CodedOutputStream
8268           .computeBytesSize(1, getAPNBytes());
8269       }
8270       size += getUnknownFields().getSerializedSize();
8271       memoizedSerializedSize = size;
8272       return size;
8273     }
8274
8275     private static final long serialVersionUID = 0L;
8276     @java.lang.Override
8277     protected java.lang.Object writeReplace()
8278         throws java.io.ObjectStreamException {
8279       return super.writeReplace();
8280     }
8281
8282     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
8283         com.google.protobuf.ByteString data)
8284         throws com.google.protobuf.InvalidProtocolBufferException {
8285       return PARSER.parseFrom(data);
8286     }
8287     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
8288         com.google.protobuf.ByteString data,
8289         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8290         throws com.google.protobuf.InvalidProtocolBufferException {
8291       return PARSER.parseFrom(data, extensionRegistry);
8292     }
8293     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(byte[] data)
8294         throws com.google.protobuf.InvalidProtocolBufferException {
8295       return PARSER.parseFrom(data);
8296     }
8297     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
8298         byte[] data,
8299         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8300         throws com.google.protobuf.InvalidProtocolBufferException {
8301       return PARSER.parseFrom(data, extensionRegistry);
8302     }
8303     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(java.io.InputStream input)
8304         throws java.io.IOException {
8305       return PARSER.parseFrom(input);
8306     }
8307     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
8308         java.io.InputStream input,
8309         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8310         throws java.io.IOException {
8311       return PARSER.parseFrom(input, extensionRegistry);
8312     }
8313     public static com.openxc.BinaryMessages.NetworkDataSettings parseDelimitedFrom(java.io.InputStream input)
8314         throws java.io.IOException {
8315       return PARSER.parseDelimitedFrom(input);
8316     }
8317     public static com.openxc.BinaryMessages.NetworkDataSettings parseDelimitedFrom(
8318         java.io.InputStream input,
8319         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8320         throws java.io.IOException {
8321       return PARSER.parseDelimitedFrom(input, extensionRegistry);
8322     }
8323     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
8324         com.google.protobuf.CodedInputStream input)
8325         throws java.io.IOException {
8326       return PARSER.parseFrom(input);
8327     }
8328     public static com.openxc.BinaryMessages.NetworkDataSettings parseFrom(
8329         com.google.protobuf.CodedInputStream input,
8330         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8331         throws java.io.IOException {
8332       return PARSER.parseFrom(input, extensionRegistry);
8333     }
8334
8335     public static Builder newBuilder() { return Builder.create(); }
8336     public Builder newBuilderForType() { return newBuilder(); }
8337     public static Builder newBuilder(com.openxc.BinaryMessages.NetworkDataSettings prototype) {
8338       return newBuilder().mergeFrom(prototype);
8339     }
8340     public Builder toBuilder() { return newBuilder(this); }
8341
8342     @java.lang.Override
8343     protected Builder newBuilderForType(
8344         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8345       Builder builder = new Builder(parent);
8346       return builder;
8347     }
8348     /**
8349      * Protobuf type {@code openxc.NetworkDataSettings}
8350      */
8351     public static final class Builder extends
8352         com.google.protobuf.GeneratedMessage.Builder<Builder>
8353        implements com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder {
8354       public static final com.google.protobuf.Descriptors.Descriptor
8355           getDescriptor() {
8356         return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_descriptor;
8357       }
8358
8359       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8360           internalGetFieldAccessorTable() {
8361         return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_fieldAccessorTable
8362             .ensureFieldAccessorsInitialized(
8363                 com.openxc.BinaryMessages.NetworkDataSettings.class, com.openxc.BinaryMessages.NetworkDataSettings.Builder.class);
8364       }
8365
8366       // Construct using com.openxc.BinaryMessages.NetworkDataSettings.newBuilder()
8367       private Builder() {
8368         maybeForceBuilderInitialization();
8369       }
8370
8371       private Builder(
8372           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8373         super(parent);
8374         maybeForceBuilderInitialization();
8375       }
8376       private void maybeForceBuilderInitialization() {
8377         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
8378         }
8379       }
8380       private static Builder create() {
8381         return new Builder();
8382       }
8383
8384       public Builder clear() {
8385         super.clear();
8386         aPN_ = "";
8387         bitField0_ = (bitField0_ & ~0x00000001);
8388         return this;
8389       }
8390
8391       public Builder clone() {
8392         return create().mergeFrom(buildPartial());
8393       }
8394
8395       public com.google.protobuf.Descriptors.Descriptor
8396           getDescriptorForType() {
8397         return com.openxc.BinaryMessages.internal_static_openxc_NetworkDataSettings_descriptor;
8398       }
8399
8400       public com.openxc.BinaryMessages.NetworkDataSettings getDefaultInstanceForType() {
8401         return com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
8402       }
8403
8404       public com.openxc.BinaryMessages.NetworkDataSettings build() {
8405         com.openxc.BinaryMessages.NetworkDataSettings result = buildPartial();
8406         if (!result.isInitialized()) {
8407           throw newUninitializedMessageException(result);
8408         }
8409         return result;
8410       }
8411
8412       public com.openxc.BinaryMessages.NetworkDataSettings buildPartial() {
8413         com.openxc.BinaryMessages.NetworkDataSettings result = new com.openxc.BinaryMessages.NetworkDataSettings(this);
8414         int from_bitField0_ = bitField0_;
8415         int to_bitField0_ = 0;
8416         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
8417           to_bitField0_ |= 0x00000001;
8418         }
8419         result.aPN_ = aPN_;
8420         result.bitField0_ = to_bitField0_;
8421         onBuilt();
8422         return result;
8423       }
8424
8425       public Builder mergeFrom(com.google.protobuf.Message other) {
8426         if (other instanceof com.openxc.BinaryMessages.NetworkDataSettings) {
8427           return mergeFrom((com.openxc.BinaryMessages.NetworkDataSettings)other);
8428         } else {
8429           super.mergeFrom(other);
8430           return this;
8431         }
8432       }
8433
8434       public Builder mergeFrom(com.openxc.BinaryMessages.NetworkDataSettings other) {
8435         if (other == com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance()) return this;
8436         if (other.hasAPN()) {
8437           bitField0_ |= 0x00000001;
8438           aPN_ = other.aPN_;
8439           onChanged();
8440         }
8441         this.mergeUnknownFields(other.getUnknownFields());
8442         return this;
8443       }
8444
8445       public final boolean isInitialized() {
8446         return true;
8447       }
8448
8449       public Builder mergeFrom(
8450           com.google.protobuf.CodedInputStream input,
8451           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8452           throws java.io.IOException {
8453         com.openxc.BinaryMessages.NetworkDataSettings parsedMessage = null;
8454         try {
8455           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
8456         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8457           parsedMessage = (com.openxc.BinaryMessages.NetworkDataSettings) e.getUnfinishedMessage();
8458           throw e;
8459         } finally {
8460           if (parsedMessage != null) {
8461             mergeFrom(parsedMessage);
8462           }
8463         }
8464         return this;
8465       }
8466       private int bitField0_;
8467
8468       // optional string APN = 1;
8469       private java.lang.Object aPN_ = "";
8470       /**
8471        * <code>optional string APN = 1;</code>
8472        */
8473       public boolean hasAPN() {
8474         return ((bitField0_ & 0x00000001) == 0x00000001);
8475       }
8476       /**
8477        * <code>optional string APN = 1;</code>
8478        */
8479       public java.lang.String getAPN() {
8480         java.lang.Object ref = aPN_;
8481         if (!(ref instanceof java.lang.String)) {
8482           java.lang.String s = ((com.google.protobuf.ByteString) ref)
8483               .toStringUtf8();
8484           aPN_ = s;
8485           return s;
8486         } else {
8487           return (java.lang.String) ref;
8488         }
8489       }
8490       /**
8491        * <code>optional string APN = 1;</code>
8492        */
8493       public com.google.protobuf.ByteString
8494           getAPNBytes() {
8495         java.lang.Object ref = aPN_;
8496         if (ref instanceof String) {
8497           com.google.protobuf.ByteString b =
8498               com.google.protobuf.ByteString.copyFromUtf8(
8499                   (java.lang.String) ref);
8500           aPN_ = b;
8501           return b;
8502         } else {
8503           return (com.google.protobuf.ByteString) ref;
8504         }
8505       }
8506       /**
8507        * <code>optional string APN = 1;</code>
8508        */
8509       public Builder setAPN(
8510           java.lang.String value) {
8511         if (value == null) {
8512     throw new NullPointerException();
8513   }
8514   bitField0_ |= 0x00000001;
8515         aPN_ = value;
8516         onChanged();
8517         return this;
8518       }
8519       /**
8520        * <code>optional string APN = 1;</code>
8521        */
8522       public Builder clearAPN() {
8523         bitField0_ = (bitField0_ & ~0x00000001);
8524         aPN_ = getDefaultInstance().getAPN();
8525         onChanged();
8526         return this;
8527       }
8528       /**
8529        * <code>optional string APN = 1;</code>
8530        */
8531       public Builder setAPNBytes(
8532           com.google.protobuf.ByteString value) {
8533         if (value == null) {
8534     throw new NullPointerException();
8535   }
8536   bitField0_ |= 0x00000001;
8537         aPN_ = value;
8538         onChanged();
8539         return this;
8540       }
8541
8542       // @@protoc_insertion_point(builder_scope:openxc.NetworkDataSettings)
8543     }
8544
8545     static {
8546       defaultInstance = new NetworkDataSettings(true);
8547       defaultInstance.initFields();
8548     }
8549
8550     // @@protoc_insertion_point(class_scope:openxc.NetworkDataSettings)
8551   }
8552
8553   public interface ServerConnectSettingsOrBuilder
8554       extends com.google.protobuf.MessageOrBuilder {
8555
8556     // optional string host = 1;
8557     /**
8558      * <code>optional string host = 1;</code>
8559      */
8560     boolean hasHost();
8561     /**
8562      * <code>optional string host = 1;</code>
8563      */
8564     java.lang.String getHost();
8565     /**
8566      * <code>optional string host = 1;</code>
8567      */
8568     com.google.protobuf.ByteString
8569         getHostBytes();
8570
8571     // optional uint32 port = 2;
8572     /**
8573      * <code>optional uint32 port = 2;</code>
8574      */
8575     boolean hasPort();
8576     /**
8577      * <code>optional uint32 port = 2;</code>
8578      */
8579     int getPort();
8580   }
8581   /**
8582    * Protobuf type {@code openxc.ServerConnectSettings}
8583    */
8584   public static final class ServerConnectSettings extends
8585       com.google.protobuf.GeneratedMessage
8586       implements ServerConnectSettingsOrBuilder {
8587     // Use ServerConnectSettings.newBuilder() to construct.
8588     private ServerConnectSettings(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
8589       super(builder);
8590       this.unknownFields = builder.getUnknownFields();
8591     }
8592     private ServerConnectSettings(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
8593
8594     private static final ServerConnectSettings defaultInstance;
8595     public static ServerConnectSettings getDefaultInstance() {
8596       return defaultInstance;
8597     }
8598
8599     public ServerConnectSettings getDefaultInstanceForType() {
8600       return defaultInstance;
8601     }
8602
8603     private final com.google.protobuf.UnknownFieldSet unknownFields;
8604     @java.lang.Override
8605     public final com.google.protobuf.UnknownFieldSet
8606         getUnknownFields() {
8607       return this.unknownFields;
8608     }
8609     private ServerConnectSettings(
8610         com.google.protobuf.CodedInputStream input,
8611         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8612         throws com.google.protobuf.InvalidProtocolBufferException {
8613       initFields();
8614       int mutable_bitField0_ = 0;
8615       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
8616           com.google.protobuf.UnknownFieldSet.newBuilder();
8617       try {
8618         boolean done = false;
8619         while (!done) {
8620           int tag = input.readTag();
8621           switch (tag) {
8622             case 0:
8623               done = true;
8624               break;
8625             default: {
8626               if (!parseUnknownField(input, unknownFields,
8627                                      extensionRegistry, tag)) {
8628                 done = true;
8629               }
8630               break;
8631             }
8632             case 10: {
8633               bitField0_ |= 0x00000001;
8634               host_ = input.readBytes();
8635               break;
8636             }
8637             case 16: {
8638               bitField0_ |= 0x00000002;
8639               port_ = input.readUInt32();
8640               break;
8641             }
8642           }
8643         }
8644       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8645         throw e.setUnfinishedMessage(this);
8646       } catch (java.io.IOException e) {
8647         throw new com.google.protobuf.InvalidProtocolBufferException(
8648             e.getMessage()).setUnfinishedMessage(this);
8649       } finally {
8650         this.unknownFields = unknownFields.build();
8651         makeExtensionsImmutable();
8652       }
8653     }
8654     public static final com.google.protobuf.Descriptors.Descriptor
8655         getDescriptor() {
8656       return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_descriptor;
8657     }
8658
8659     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8660         internalGetFieldAccessorTable() {
8661       return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_fieldAccessorTable
8662           .ensureFieldAccessorsInitialized(
8663               com.openxc.BinaryMessages.ServerConnectSettings.class, com.openxc.BinaryMessages.ServerConnectSettings.Builder.class);
8664     }
8665
8666     public static com.google.protobuf.Parser<ServerConnectSettings> PARSER =
8667         new com.google.protobuf.AbstractParser<ServerConnectSettings>() {
8668       public ServerConnectSettings parsePartialFrom(
8669           com.google.protobuf.CodedInputStream input,
8670           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8671           throws com.google.protobuf.InvalidProtocolBufferException {
8672         return new ServerConnectSettings(input, extensionRegistry);
8673       }
8674     };
8675
8676     @java.lang.Override
8677     public com.google.protobuf.Parser<ServerConnectSettings> getParserForType() {
8678       return PARSER;
8679     }
8680
8681     private int bitField0_;
8682     // optional string host = 1;
8683     public static final int HOST_FIELD_NUMBER = 1;
8684     private java.lang.Object host_;
8685     /**
8686      * <code>optional string host = 1;</code>
8687      */
8688     public boolean hasHost() {
8689       return ((bitField0_ & 0x00000001) == 0x00000001);
8690     }
8691     /**
8692      * <code>optional string host = 1;</code>
8693      */
8694     public java.lang.String getHost() {
8695       java.lang.Object ref = host_;
8696       if (ref instanceof java.lang.String) {
8697         return (java.lang.String) ref;
8698       } else {
8699         com.google.protobuf.ByteString bs =
8700             (com.google.protobuf.ByteString) ref;
8701         java.lang.String s = bs.toStringUtf8();
8702         if (bs.isValidUtf8()) {
8703           host_ = s;
8704         }
8705         return s;
8706       }
8707     }
8708     /**
8709      * <code>optional string host = 1;</code>
8710      */
8711     public com.google.protobuf.ByteString
8712         getHostBytes() {
8713       java.lang.Object ref = host_;
8714       if (ref instanceof java.lang.String) {
8715         com.google.protobuf.ByteString b =
8716             com.google.protobuf.ByteString.copyFromUtf8(
8717                 (java.lang.String) ref);
8718         host_ = b;
8719         return b;
8720       } else {
8721         return (com.google.protobuf.ByteString) ref;
8722       }
8723     }
8724
8725     // optional uint32 port = 2;
8726     public static final int PORT_FIELD_NUMBER = 2;
8727     private int port_;
8728     /**
8729      * <code>optional uint32 port = 2;</code>
8730      */
8731     public boolean hasPort() {
8732       return ((bitField0_ & 0x00000002) == 0x00000002);
8733     }
8734     /**
8735      * <code>optional uint32 port = 2;</code>
8736      */
8737     public int getPort() {
8738       return port_;
8739     }
8740
8741     private void initFields() {
8742       host_ = "";
8743       port_ = 0;
8744     }
8745     private byte memoizedIsInitialized = -1;
8746     public final boolean isInitialized() {
8747       byte isInitialized = memoizedIsInitialized;
8748       if (isInitialized != -1) return isInitialized == 1;
8749
8750       memoizedIsInitialized = 1;
8751       return true;
8752     }
8753
8754     public void writeTo(com.google.protobuf.CodedOutputStream output)
8755                         throws java.io.IOException {
8756       getSerializedSize();
8757       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8758         output.writeBytes(1, getHostBytes());
8759       }
8760       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8761         output.writeUInt32(2, port_);
8762       }
8763       getUnknownFields().writeTo(output);
8764     }
8765
8766     private int memoizedSerializedSize = -1;
8767     public int getSerializedSize() {
8768       int size = memoizedSerializedSize;
8769       if (size != -1) return size;
8770
8771       size = 0;
8772       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8773         size += com.google.protobuf.CodedOutputStream
8774           .computeBytesSize(1, getHostBytes());
8775       }
8776       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8777         size += com.google.protobuf.CodedOutputStream
8778           .computeUInt32Size(2, port_);
8779       }
8780       size += getUnknownFields().getSerializedSize();
8781       memoizedSerializedSize = size;
8782       return size;
8783     }
8784
8785     private static final long serialVersionUID = 0L;
8786     @java.lang.Override
8787     protected java.lang.Object writeReplace()
8788         throws java.io.ObjectStreamException {
8789       return super.writeReplace();
8790     }
8791
8792     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
8793         com.google.protobuf.ByteString data)
8794         throws com.google.protobuf.InvalidProtocolBufferException {
8795       return PARSER.parseFrom(data);
8796     }
8797     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
8798         com.google.protobuf.ByteString data,
8799         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8800         throws com.google.protobuf.InvalidProtocolBufferException {
8801       return PARSER.parseFrom(data, extensionRegistry);
8802     }
8803     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(byte[] data)
8804         throws com.google.protobuf.InvalidProtocolBufferException {
8805       return PARSER.parseFrom(data);
8806     }
8807     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
8808         byte[] data,
8809         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8810         throws com.google.protobuf.InvalidProtocolBufferException {
8811       return PARSER.parseFrom(data, extensionRegistry);
8812     }
8813     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(java.io.InputStream input)
8814         throws java.io.IOException {
8815       return PARSER.parseFrom(input);
8816     }
8817     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
8818         java.io.InputStream input,
8819         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8820         throws java.io.IOException {
8821       return PARSER.parseFrom(input, extensionRegistry);
8822     }
8823     public static com.openxc.BinaryMessages.ServerConnectSettings parseDelimitedFrom(java.io.InputStream input)
8824         throws java.io.IOException {
8825       return PARSER.parseDelimitedFrom(input);
8826     }
8827     public static com.openxc.BinaryMessages.ServerConnectSettings parseDelimitedFrom(
8828         java.io.InputStream input,
8829         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8830         throws java.io.IOException {
8831       return PARSER.parseDelimitedFrom(input, extensionRegistry);
8832     }
8833     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
8834         com.google.protobuf.CodedInputStream input)
8835         throws java.io.IOException {
8836       return PARSER.parseFrom(input);
8837     }
8838     public static com.openxc.BinaryMessages.ServerConnectSettings parseFrom(
8839         com.google.protobuf.CodedInputStream input,
8840         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8841         throws java.io.IOException {
8842       return PARSER.parseFrom(input, extensionRegistry);
8843     }
8844
8845     public static Builder newBuilder() { return Builder.create(); }
8846     public Builder newBuilderForType() { return newBuilder(); }
8847     public static Builder newBuilder(com.openxc.BinaryMessages.ServerConnectSettings prototype) {
8848       return newBuilder().mergeFrom(prototype);
8849     }
8850     public Builder toBuilder() { return newBuilder(this); }
8851
8852     @java.lang.Override
8853     protected Builder newBuilderForType(
8854         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8855       Builder builder = new Builder(parent);
8856       return builder;
8857     }
8858     /**
8859      * Protobuf type {@code openxc.ServerConnectSettings}
8860      */
8861     public static final class Builder extends
8862         com.google.protobuf.GeneratedMessage.Builder<Builder>
8863        implements com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder {
8864       public static final com.google.protobuf.Descriptors.Descriptor
8865           getDescriptor() {
8866         return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_descriptor;
8867       }
8868
8869       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8870           internalGetFieldAccessorTable() {
8871         return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_fieldAccessorTable
8872             .ensureFieldAccessorsInitialized(
8873                 com.openxc.BinaryMessages.ServerConnectSettings.class, com.openxc.BinaryMessages.ServerConnectSettings.Builder.class);
8874       }
8875
8876       // Construct using com.openxc.BinaryMessages.ServerConnectSettings.newBuilder()
8877       private Builder() {
8878         maybeForceBuilderInitialization();
8879       }
8880
8881       private Builder(
8882           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8883         super(parent);
8884         maybeForceBuilderInitialization();
8885       }
8886       private void maybeForceBuilderInitialization() {
8887         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
8888         }
8889       }
8890       private static Builder create() {
8891         return new Builder();
8892       }
8893
8894       public Builder clear() {
8895         super.clear();
8896         host_ = "";
8897         bitField0_ = (bitField0_ & ~0x00000001);
8898         port_ = 0;
8899         bitField0_ = (bitField0_ & ~0x00000002);
8900         return this;
8901       }
8902
8903       public Builder clone() {
8904         return create().mergeFrom(buildPartial());
8905       }
8906
8907       public com.google.protobuf.Descriptors.Descriptor
8908           getDescriptorForType() {
8909         return com.openxc.BinaryMessages.internal_static_openxc_ServerConnectSettings_descriptor;
8910       }
8911
8912       public com.openxc.BinaryMessages.ServerConnectSettings getDefaultInstanceForType() {
8913         return com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
8914       }
8915
8916       public com.openxc.BinaryMessages.ServerConnectSettings build() {
8917         com.openxc.BinaryMessages.ServerConnectSettings result = buildPartial();
8918         if (!result.isInitialized()) {
8919           throw newUninitializedMessageException(result);
8920         }
8921         return result;
8922       }
8923
8924       public com.openxc.BinaryMessages.ServerConnectSettings buildPartial() {
8925         com.openxc.BinaryMessages.ServerConnectSettings result = new com.openxc.BinaryMessages.ServerConnectSettings(this);
8926         int from_bitField0_ = bitField0_;
8927         int to_bitField0_ = 0;
8928         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
8929           to_bitField0_ |= 0x00000001;
8930         }
8931         result.host_ = host_;
8932         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
8933           to_bitField0_ |= 0x00000002;
8934         }
8935         result.port_ = port_;
8936         result.bitField0_ = to_bitField0_;
8937         onBuilt();
8938         return result;
8939       }
8940
8941       public Builder mergeFrom(com.google.protobuf.Message other) {
8942         if (other instanceof com.openxc.BinaryMessages.ServerConnectSettings) {
8943           return mergeFrom((com.openxc.BinaryMessages.ServerConnectSettings)other);
8944         } else {
8945           super.mergeFrom(other);
8946           return this;
8947         }
8948       }
8949
8950       public Builder mergeFrom(com.openxc.BinaryMessages.ServerConnectSettings other) {
8951         if (other == com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance()) return this;
8952         if (other.hasHost()) {
8953           bitField0_ |= 0x00000001;
8954           host_ = other.host_;
8955           onChanged();
8956         }
8957         if (other.hasPort()) {
8958           setPort(other.getPort());
8959         }
8960         this.mergeUnknownFields(other.getUnknownFields());
8961         return this;
8962       }
8963
8964       public final boolean isInitialized() {
8965         return true;
8966       }
8967
8968       public Builder mergeFrom(
8969           com.google.protobuf.CodedInputStream input,
8970           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8971           throws java.io.IOException {
8972         com.openxc.BinaryMessages.ServerConnectSettings parsedMessage = null;
8973         try {
8974           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
8975         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8976           parsedMessage = (com.openxc.BinaryMessages.ServerConnectSettings) e.getUnfinishedMessage();
8977           throw e;
8978         } finally {
8979           if (parsedMessage != null) {
8980             mergeFrom(parsedMessage);
8981           }
8982         }
8983         return this;
8984       }
8985       private int bitField0_;
8986
8987       // optional string host = 1;
8988       private java.lang.Object host_ = "";
8989       /**
8990        * <code>optional string host = 1;</code>
8991        */
8992       public boolean hasHost() {
8993         return ((bitField0_ & 0x00000001) == 0x00000001);
8994       }
8995       /**
8996        * <code>optional string host = 1;</code>
8997        */
8998       public java.lang.String getHost() {
8999         java.lang.Object ref = host_;
9000         if (!(ref instanceof java.lang.String)) {
9001           java.lang.String s = ((com.google.protobuf.ByteString) ref)
9002               .toStringUtf8();
9003           host_ = s;
9004           return s;
9005         } else {
9006           return (java.lang.String) ref;
9007         }
9008       }
9009       /**
9010        * <code>optional string host = 1;</code>
9011        */
9012       public com.google.protobuf.ByteString
9013           getHostBytes() {
9014         java.lang.Object ref = host_;
9015         if (ref instanceof String) {
9016           com.google.protobuf.ByteString b =
9017               com.google.protobuf.ByteString.copyFromUtf8(
9018                   (java.lang.String) ref);
9019           host_ = b;
9020           return b;
9021         } else {
9022           return (com.google.protobuf.ByteString) ref;
9023         }
9024       }
9025       /**
9026        * <code>optional string host = 1;</code>
9027        */
9028       public Builder setHost(
9029           java.lang.String value) {
9030         if (value == null) {
9031     throw new NullPointerException();
9032   }
9033   bitField0_ |= 0x00000001;
9034         host_ = value;
9035         onChanged();
9036         return this;
9037       }
9038       /**
9039        * <code>optional string host = 1;</code>
9040        */
9041       public Builder clearHost() {
9042         bitField0_ = (bitField0_ & ~0x00000001);
9043         host_ = getDefaultInstance().getHost();
9044         onChanged();
9045         return this;
9046       }
9047       /**
9048        * <code>optional string host = 1;</code>
9049        */
9050       public Builder setHostBytes(
9051           com.google.protobuf.ByteString value) {
9052         if (value == null) {
9053     throw new NullPointerException();
9054   }
9055   bitField0_ |= 0x00000001;
9056         host_ = value;
9057         onChanged();
9058         return this;
9059       }
9060
9061       // optional uint32 port = 2;
9062       private int port_ ;
9063       /**
9064        * <code>optional uint32 port = 2;</code>
9065        */
9066       public boolean hasPort() {
9067         return ((bitField0_ & 0x00000002) == 0x00000002);
9068       }
9069       /**
9070        * <code>optional uint32 port = 2;</code>
9071        */
9072       public int getPort() {
9073         return port_;
9074       }
9075       /**
9076        * <code>optional uint32 port = 2;</code>
9077        */
9078       public Builder setPort(int value) {
9079         bitField0_ |= 0x00000002;
9080         port_ = value;
9081         onChanged();
9082         return this;
9083       }
9084       /**
9085        * <code>optional uint32 port = 2;</code>
9086        */
9087       public Builder clearPort() {
9088         bitField0_ = (bitField0_ & ~0x00000002);
9089         port_ = 0;
9090         onChanged();
9091         return this;
9092       }
9093
9094       // @@protoc_insertion_point(builder_scope:openxc.ServerConnectSettings)
9095     }
9096
9097     static {
9098       defaultInstance = new ServerConnectSettings(true);
9099       defaultInstance.initFields();
9100     }
9101
9102     // @@protoc_insertion_point(class_scope:openxc.ServerConnectSettings)
9103   }
9104
9105   public interface ModemConfigurationCommandOrBuilder
9106       extends com.google.protobuf.MessageOrBuilder {
9107
9108     // optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;
9109     /**
9110      * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9111      */
9112     boolean hasNetworkOperatorSettings();
9113     /**
9114      * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9115      */
9116     com.openxc.BinaryMessages.NetworkOperatorSettings getNetworkOperatorSettings();
9117     /**
9118      * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9119      */
9120     com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder getNetworkOperatorSettingsOrBuilder();
9121
9122     // optional .openxc.NetworkDataSettings networkDataSettings = 2;
9123     /**
9124      * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9125      */
9126     boolean hasNetworkDataSettings();
9127     /**
9128      * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9129      */
9130     com.openxc.BinaryMessages.NetworkDataSettings getNetworkDataSettings();
9131     /**
9132      * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9133      */
9134     com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder getNetworkDataSettingsOrBuilder();
9135
9136     // optional .openxc.ServerConnectSettings serverConnectSettings = 3;
9137     /**
9138      * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9139      */
9140     boolean hasServerConnectSettings();
9141     /**
9142      * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9143      */
9144     com.openxc.BinaryMessages.ServerConnectSettings getServerConnectSettings();
9145     /**
9146      * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9147      */
9148     com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder getServerConnectSettingsOrBuilder();
9149   }
9150   /**
9151    * Protobuf type {@code openxc.ModemConfigurationCommand}
9152    */
9153   public static final class ModemConfigurationCommand extends
9154       com.google.protobuf.GeneratedMessage
9155       implements ModemConfigurationCommandOrBuilder {
9156     // Use ModemConfigurationCommand.newBuilder() to construct.
9157     private ModemConfigurationCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
9158       super(builder);
9159       this.unknownFields = builder.getUnknownFields();
9160     }
9161     private ModemConfigurationCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
9162
9163     private static final ModemConfigurationCommand defaultInstance;
9164     public static ModemConfigurationCommand getDefaultInstance() {
9165       return defaultInstance;
9166     }
9167
9168     public ModemConfigurationCommand getDefaultInstanceForType() {
9169       return defaultInstance;
9170     }
9171
9172     private final com.google.protobuf.UnknownFieldSet unknownFields;
9173     @java.lang.Override
9174     public final com.google.protobuf.UnknownFieldSet
9175         getUnknownFields() {
9176       return this.unknownFields;
9177     }
9178     private ModemConfigurationCommand(
9179         com.google.protobuf.CodedInputStream input,
9180         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9181         throws com.google.protobuf.InvalidProtocolBufferException {
9182       initFields();
9183       int mutable_bitField0_ = 0;
9184       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
9185           com.google.protobuf.UnknownFieldSet.newBuilder();
9186       try {
9187         boolean done = false;
9188         while (!done) {
9189           int tag = input.readTag();
9190           switch (tag) {
9191             case 0:
9192               done = true;
9193               break;
9194             default: {
9195               if (!parseUnknownField(input, unknownFields,
9196                                      extensionRegistry, tag)) {
9197                 done = true;
9198               }
9199               break;
9200             }
9201             case 10: {
9202               com.openxc.BinaryMessages.NetworkOperatorSettings.Builder subBuilder = null;
9203               if (((bitField0_ & 0x00000001) == 0x00000001)) {
9204                 subBuilder = networkOperatorSettings_.toBuilder();
9205               }
9206               networkOperatorSettings_ = input.readMessage(com.openxc.BinaryMessages.NetworkOperatorSettings.PARSER, extensionRegistry);
9207               if (subBuilder != null) {
9208                 subBuilder.mergeFrom(networkOperatorSettings_);
9209                 networkOperatorSettings_ = subBuilder.buildPartial();
9210               }
9211               bitField0_ |= 0x00000001;
9212               break;
9213             }
9214             case 18: {
9215               com.openxc.BinaryMessages.NetworkDataSettings.Builder subBuilder = null;
9216               if (((bitField0_ & 0x00000002) == 0x00000002)) {
9217                 subBuilder = networkDataSettings_.toBuilder();
9218               }
9219               networkDataSettings_ = input.readMessage(com.openxc.BinaryMessages.NetworkDataSettings.PARSER, extensionRegistry);
9220               if (subBuilder != null) {
9221                 subBuilder.mergeFrom(networkDataSettings_);
9222                 networkDataSettings_ = subBuilder.buildPartial();
9223               }
9224               bitField0_ |= 0x00000002;
9225               break;
9226             }
9227             case 26: {
9228               com.openxc.BinaryMessages.ServerConnectSettings.Builder subBuilder = null;
9229               if (((bitField0_ & 0x00000004) == 0x00000004)) {
9230                 subBuilder = serverConnectSettings_.toBuilder();
9231               }
9232               serverConnectSettings_ = input.readMessage(com.openxc.BinaryMessages.ServerConnectSettings.PARSER, extensionRegistry);
9233               if (subBuilder != null) {
9234                 subBuilder.mergeFrom(serverConnectSettings_);
9235                 serverConnectSettings_ = subBuilder.buildPartial();
9236               }
9237               bitField0_ |= 0x00000004;
9238               break;
9239             }
9240           }
9241         }
9242       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
9243         throw e.setUnfinishedMessage(this);
9244       } catch (java.io.IOException e) {
9245         throw new com.google.protobuf.InvalidProtocolBufferException(
9246             e.getMessage()).setUnfinishedMessage(this);
9247       } finally {
9248         this.unknownFields = unknownFields.build();
9249         makeExtensionsImmutable();
9250       }
9251     }
9252     public static final com.google.protobuf.Descriptors.Descriptor
9253         getDescriptor() {
9254       return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_descriptor;
9255     }
9256
9257     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
9258         internalGetFieldAccessorTable() {
9259       return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable
9260           .ensureFieldAccessorsInitialized(
9261               com.openxc.BinaryMessages.ModemConfigurationCommand.class, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder.class);
9262     }
9263
9264     public static com.google.protobuf.Parser<ModemConfigurationCommand> PARSER =
9265         new com.google.protobuf.AbstractParser<ModemConfigurationCommand>() {
9266       public ModemConfigurationCommand parsePartialFrom(
9267           com.google.protobuf.CodedInputStream input,
9268           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9269           throws com.google.protobuf.InvalidProtocolBufferException {
9270         return new ModemConfigurationCommand(input, extensionRegistry);
9271       }
9272     };
9273
9274     @java.lang.Override
9275     public com.google.protobuf.Parser<ModemConfigurationCommand> getParserForType() {
9276       return PARSER;
9277     }
9278
9279     private int bitField0_;
9280     // optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;
9281     public static final int NETWORKOPERATORSETTINGS_FIELD_NUMBER = 1;
9282     private com.openxc.BinaryMessages.NetworkOperatorSettings networkOperatorSettings_;
9283     /**
9284      * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9285      */
9286     public boolean hasNetworkOperatorSettings() {
9287       return ((bitField0_ & 0x00000001) == 0x00000001);
9288     }
9289     /**
9290      * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9291      */
9292     public com.openxc.BinaryMessages.NetworkOperatorSettings getNetworkOperatorSettings() {
9293       return networkOperatorSettings_;
9294     }
9295     /**
9296      * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9297      */
9298     public com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder getNetworkOperatorSettingsOrBuilder() {
9299       return networkOperatorSettings_;
9300     }
9301
9302     // optional .openxc.NetworkDataSettings networkDataSettings = 2;
9303     public static final int NETWORKDATASETTINGS_FIELD_NUMBER = 2;
9304     private com.openxc.BinaryMessages.NetworkDataSettings networkDataSettings_;
9305     /**
9306      * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9307      */
9308     public boolean hasNetworkDataSettings() {
9309       return ((bitField0_ & 0x00000002) == 0x00000002);
9310     }
9311     /**
9312      * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9313      */
9314     public com.openxc.BinaryMessages.NetworkDataSettings getNetworkDataSettings() {
9315       return networkDataSettings_;
9316     }
9317     /**
9318      * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9319      */
9320     public com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder getNetworkDataSettingsOrBuilder() {
9321       return networkDataSettings_;
9322     }
9323
9324     // optional .openxc.ServerConnectSettings serverConnectSettings = 3;
9325     public static final int SERVERCONNECTSETTINGS_FIELD_NUMBER = 3;
9326     private com.openxc.BinaryMessages.ServerConnectSettings serverConnectSettings_;
9327     /**
9328      * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9329      */
9330     public boolean hasServerConnectSettings() {
9331       return ((bitField0_ & 0x00000004) == 0x00000004);
9332     }
9333     /**
9334      * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9335      */
9336     public com.openxc.BinaryMessages.ServerConnectSettings getServerConnectSettings() {
9337       return serverConnectSettings_;
9338     }
9339     /**
9340      * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9341      */
9342     public com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder getServerConnectSettingsOrBuilder() {
9343       return serverConnectSettings_;
9344     }
9345
9346     private void initFields() {
9347       networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
9348       networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
9349       serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
9350     }
9351     private byte memoizedIsInitialized = -1;
9352     public final boolean isInitialized() {
9353       byte isInitialized = memoizedIsInitialized;
9354       if (isInitialized != -1) return isInitialized == 1;
9355
9356       memoizedIsInitialized = 1;
9357       return true;
9358     }
9359
9360     public void writeTo(com.google.protobuf.CodedOutputStream output)
9361                         throws java.io.IOException {
9362       getSerializedSize();
9363       if (((bitField0_ & 0x00000001) == 0x00000001)) {
9364         output.writeMessage(1, networkOperatorSettings_);
9365       }
9366       if (((bitField0_ & 0x00000002) == 0x00000002)) {
9367         output.writeMessage(2, networkDataSettings_);
9368       }
9369       if (((bitField0_ & 0x00000004) == 0x00000004)) {
9370         output.writeMessage(3, serverConnectSettings_);
9371       }
9372       getUnknownFields().writeTo(output);
9373     }
9374
9375     private int memoizedSerializedSize = -1;
9376     public int getSerializedSize() {
9377       int size = memoizedSerializedSize;
9378       if (size != -1) return size;
9379
9380       size = 0;
9381       if (((bitField0_ & 0x00000001) == 0x00000001)) {
9382         size += com.google.protobuf.CodedOutputStream
9383           .computeMessageSize(1, networkOperatorSettings_);
9384       }
9385       if (((bitField0_ & 0x00000002) == 0x00000002)) {
9386         size += com.google.protobuf.CodedOutputStream
9387           .computeMessageSize(2, networkDataSettings_);
9388       }
9389       if (((bitField0_ & 0x00000004) == 0x00000004)) {
9390         size += com.google.protobuf.CodedOutputStream
9391           .computeMessageSize(3, serverConnectSettings_);
9392       }
9393       size += getUnknownFields().getSerializedSize();
9394       memoizedSerializedSize = size;
9395       return size;
9396     }
9397
9398     private static final long serialVersionUID = 0L;
9399     @java.lang.Override
9400     protected java.lang.Object writeReplace()
9401         throws java.io.ObjectStreamException {
9402       return super.writeReplace();
9403     }
9404
9405     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
9406         com.google.protobuf.ByteString data)
9407         throws com.google.protobuf.InvalidProtocolBufferException {
9408       return PARSER.parseFrom(data);
9409     }
9410     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
9411         com.google.protobuf.ByteString data,
9412         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9413         throws com.google.protobuf.InvalidProtocolBufferException {
9414       return PARSER.parseFrom(data, extensionRegistry);
9415     }
9416     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(byte[] data)
9417         throws com.google.protobuf.InvalidProtocolBufferException {
9418       return PARSER.parseFrom(data);
9419     }
9420     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
9421         byte[] data,
9422         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9423         throws com.google.protobuf.InvalidProtocolBufferException {
9424       return PARSER.parseFrom(data, extensionRegistry);
9425     }
9426     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(java.io.InputStream input)
9427         throws java.io.IOException {
9428       return PARSER.parseFrom(input);
9429     }
9430     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
9431         java.io.InputStream input,
9432         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9433         throws java.io.IOException {
9434       return PARSER.parseFrom(input, extensionRegistry);
9435     }
9436     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseDelimitedFrom(java.io.InputStream input)
9437         throws java.io.IOException {
9438       return PARSER.parseDelimitedFrom(input);
9439     }
9440     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseDelimitedFrom(
9441         java.io.InputStream input,
9442         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9443         throws java.io.IOException {
9444       return PARSER.parseDelimitedFrom(input, extensionRegistry);
9445     }
9446     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
9447         com.google.protobuf.CodedInputStream input)
9448         throws java.io.IOException {
9449       return PARSER.parseFrom(input);
9450     }
9451     public static com.openxc.BinaryMessages.ModemConfigurationCommand parseFrom(
9452         com.google.protobuf.CodedInputStream input,
9453         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9454         throws java.io.IOException {
9455       return PARSER.parseFrom(input, extensionRegistry);
9456     }
9457
9458     public static Builder newBuilder() { return Builder.create(); }
9459     public Builder newBuilderForType() { return newBuilder(); }
9460     public static Builder newBuilder(com.openxc.BinaryMessages.ModemConfigurationCommand prototype) {
9461       return newBuilder().mergeFrom(prototype);
9462     }
9463     public Builder toBuilder() { return newBuilder(this); }
9464
9465     @java.lang.Override
9466     protected Builder newBuilderForType(
9467         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
9468       Builder builder = new Builder(parent);
9469       return builder;
9470     }
9471     /**
9472      * Protobuf type {@code openxc.ModemConfigurationCommand}
9473      */
9474     public static final class Builder extends
9475         com.google.protobuf.GeneratedMessage.Builder<Builder>
9476        implements com.openxc.BinaryMessages.ModemConfigurationCommandOrBuilder {
9477       public static final com.google.protobuf.Descriptors.Descriptor
9478           getDescriptor() {
9479         return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_descriptor;
9480       }
9481
9482       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
9483           internalGetFieldAccessorTable() {
9484         return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable
9485             .ensureFieldAccessorsInitialized(
9486                 com.openxc.BinaryMessages.ModemConfigurationCommand.class, com.openxc.BinaryMessages.ModemConfigurationCommand.Builder.class);
9487       }
9488
9489       // Construct using com.openxc.BinaryMessages.ModemConfigurationCommand.newBuilder()
9490       private Builder() {
9491         maybeForceBuilderInitialization();
9492       }
9493
9494       private Builder(
9495           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
9496         super(parent);
9497         maybeForceBuilderInitialization();
9498       }
9499       private void maybeForceBuilderInitialization() {
9500         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
9501           getNetworkOperatorSettingsFieldBuilder();
9502           getNetworkDataSettingsFieldBuilder();
9503           getServerConnectSettingsFieldBuilder();
9504         }
9505       }
9506       private static Builder create() {
9507         return new Builder();
9508       }
9509
9510       public Builder clear() {
9511         super.clear();
9512         if (networkOperatorSettingsBuilder_ == null) {
9513           networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
9514         } else {
9515           networkOperatorSettingsBuilder_.clear();
9516         }
9517         bitField0_ = (bitField0_ & ~0x00000001);
9518         if (networkDataSettingsBuilder_ == null) {
9519           networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
9520         } else {
9521           networkDataSettingsBuilder_.clear();
9522         }
9523         bitField0_ = (bitField0_ & ~0x00000002);
9524         if (serverConnectSettingsBuilder_ == null) {
9525           serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
9526         } else {
9527           serverConnectSettingsBuilder_.clear();
9528         }
9529         bitField0_ = (bitField0_ & ~0x00000004);
9530         return this;
9531       }
9532
9533       public Builder clone() {
9534         return create().mergeFrom(buildPartial());
9535       }
9536
9537       public com.google.protobuf.Descriptors.Descriptor
9538           getDescriptorForType() {
9539         return com.openxc.BinaryMessages.internal_static_openxc_ModemConfigurationCommand_descriptor;
9540       }
9541
9542       public com.openxc.BinaryMessages.ModemConfigurationCommand getDefaultInstanceForType() {
9543         return com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance();
9544       }
9545
9546       public com.openxc.BinaryMessages.ModemConfigurationCommand build() {
9547         com.openxc.BinaryMessages.ModemConfigurationCommand result = buildPartial();
9548         if (!result.isInitialized()) {
9549           throw newUninitializedMessageException(result);
9550         }
9551         return result;
9552       }
9553
9554       public com.openxc.BinaryMessages.ModemConfigurationCommand buildPartial() {
9555         com.openxc.BinaryMessages.ModemConfigurationCommand result = new com.openxc.BinaryMessages.ModemConfigurationCommand(this);
9556         int from_bitField0_ = bitField0_;
9557         int to_bitField0_ = 0;
9558         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
9559           to_bitField0_ |= 0x00000001;
9560         }
9561         if (networkOperatorSettingsBuilder_ == null) {
9562           result.networkOperatorSettings_ = networkOperatorSettings_;
9563         } else {
9564           result.networkOperatorSettings_ = networkOperatorSettingsBuilder_.build();
9565         }
9566         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
9567           to_bitField0_ |= 0x00000002;
9568         }
9569         if (networkDataSettingsBuilder_ == null) {
9570           result.networkDataSettings_ = networkDataSettings_;
9571         } else {
9572           result.networkDataSettings_ = networkDataSettingsBuilder_.build();
9573         }
9574         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
9575           to_bitField0_ |= 0x00000004;
9576         }
9577         if (serverConnectSettingsBuilder_ == null) {
9578           result.serverConnectSettings_ = serverConnectSettings_;
9579         } else {
9580           result.serverConnectSettings_ = serverConnectSettingsBuilder_.build();
9581         }
9582         result.bitField0_ = to_bitField0_;
9583         onBuilt();
9584         return result;
9585       }
9586
9587       public Builder mergeFrom(com.google.protobuf.Message other) {
9588         if (other instanceof com.openxc.BinaryMessages.ModemConfigurationCommand) {
9589           return mergeFrom((com.openxc.BinaryMessages.ModemConfigurationCommand)other);
9590         } else {
9591           super.mergeFrom(other);
9592           return this;
9593         }
9594       }
9595
9596       public Builder mergeFrom(com.openxc.BinaryMessages.ModemConfigurationCommand other) {
9597         if (other == com.openxc.BinaryMessages.ModemConfigurationCommand.getDefaultInstance()) return this;
9598         if (other.hasNetworkOperatorSettings()) {
9599           mergeNetworkOperatorSettings(other.getNetworkOperatorSettings());
9600         }
9601         if (other.hasNetworkDataSettings()) {
9602           mergeNetworkDataSettings(other.getNetworkDataSettings());
9603         }
9604         if (other.hasServerConnectSettings()) {
9605           mergeServerConnectSettings(other.getServerConnectSettings());
9606         }
9607         this.mergeUnknownFields(other.getUnknownFields());
9608         return this;
9609       }
9610
9611       public final boolean isInitialized() {
9612         return true;
9613       }
9614
9615       public Builder mergeFrom(
9616           com.google.protobuf.CodedInputStream input,
9617           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9618           throws java.io.IOException {
9619         com.openxc.BinaryMessages.ModemConfigurationCommand parsedMessage = null;
9620         try {
9621           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
9622         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
9623           parsedMessage = (com.openxc.BinaryMessages.ModemConfigurationCommand) e.getUnfinishedMessage();
9624           throw e;
9625         } finally {
9626           if (parsedMessage != null) {
9627             mergeFrom(parsedMessage);
9628           }
9629         }
9630         return this;
9631       }
9632       private int bitField0_;
9633
9634       // optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;
9635       private com.openxc.BinaryMessages.NetworkOperatorSettings networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
9636       private com.google.protobuf.SingleFieldBuilder<
9637           com.openxc.BinaryMessages.NetworkOperatorSettings, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder, com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder> networkOperatorSettingsBuilder_;
9638       /**
9639        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9640        */
9641       public boolean hasNetworkOperatorSettings() {
9642         return ((bitField0_ & 0x00000001) == 0x00000001);
9643       }
9644       /**
9645        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9646        */
9647       public com.openxc.BinaryMessages.NetworkOperatorSettings getNetworkOperatorSettings() {
9648         if (networkOperatorSettingsBuilder_ == null) {
9649           return networkOperatorSettings_;
9650         } else {
9651           return networkOperatorSettingsBuilder_.getMessage();
9652         }
9653       }
9654       /**
9655        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9656        */
9657       public Builder setNetworkOperatorSettings(com.openxc.BinaryMessages.NetworkOperatorSettings value) {
9658         if (networkOperatorSettingsBuilder_ == null) {
9659           if (value == null) {
9660             throw new NullPointerException();
9661           }
9662           networkOperatorSettings_ = value;
9663           onChanged();
9664         } else {
9665           networkOperatorSettingsBuilder_.setMessage(value);
9666         }
9667         bitField0_ |= 0x00000001;
9668         return this;
9669       }
9670       /**
9671        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9672        */
9673       public Builder setNetworkOperatorSettings(
9674           com.openxc.BinaryMessages.NetworkOperatorSettings.Builder builderForValue) {
9675         if (networkOperatorSettingsBuilder_ == null) {
9676           networkOperatorSettings_ = builderForValue.build();
9677           onChanged();
9678         } else {
9679           networkOperatorSettingsBuilder_.setMessage(builderForValue.build());
9680         }
9681         bitField0_ |= 0x00000001;
9682         return this;
9683       }
9684       /**
9685        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9686        */
9687       public Builder mergeNetworkOperatorSettings(com.openxc.BinaryMessages.NetworkOperatorSettings value) {
9688         if (networkOperatorSettingsBuilder_ == null) {
9689           if (((bitField0_ & 0x00000001) == 0x00000001) &&
9690               networkOperatorSettings_ != com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance()) {
9691             networkOperatorSettings_ =
9692               com.openxc.BinaryMessages.NetworkOperatorSettings.newBuilder(networkOperatorSettings_).mergeFrom(value).buildPartial();
9693           } else {
9694             networkOperatorSettings_ = value;
9695           }
9696           onChanged();
9697         } else {
9698           networkOperatorSettingsBuilder_.mergeFrom(value);
9699         }
9700         bitField0_ |= 0x00000001;
9701         return this;
9702       }
9703       /**
9704        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9705        */
9706       public Builder clearNetworkOperatorSettings() {
9707         if (networkOperatorSettingsBuilder_ == null) {
9708           networkOperatorSettings_ = com.openxc.BinaryMessages.NetworkOperatorSettings.getDefaultInstance();
9709           onChanged();
9710         } else {
9711           networkOperatorSettingsBuilder_.clear();
9712         }
9713         bitField0_ = (bitField0_ & ~0x00000001);
9714         return this;
9715       }
9716       /**
9717        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9718        */
9719       public com.openxc.BinaryMessages.NetworkOperatorSettings.Builder getNetworkOperatorSettingsBuilder() {
9720         bitField0_ |= 0x00000001;
9721         onChanged();
9722         return getNetworkOperatorSettingsFieldBuilder().getBuilder();
9723       }
9724       /**
9725        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9726        */
9727       public com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder getNetworkOperatorSettingsOrBuilder() {
9728         if (networkOperatorSettingsBuilder_ != null) {
9729           return networkOperatorSettingsBuilder_.getMessageOrBuilder();
9730         } else {
9731           return networkOperatorSettings_;
9732         }
9733       }
9734       /**
9735        * <code>optional .openxc.NetworkOperatorSettings networkOperatorSettings = 1;</code>
9736        */
9737       private com.google.protobuf.SingleFieldBuilder<
9738           com.openxc.BinaryMessages.NetworkOperatorSettings, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder, com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder>
9739           getNetworkOperatorSettingsFieldBuilder() {
9740         if (networkOperatorSettingsBuilder_ == null) {
9741           networkOperatorSettingsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
9742               com.openxc.BinaryMessages.NetworkOperatorSettings, com.openxc.BinaryMessages.NetworkOperatorSettings.Builder, com.openxc.BinaryMessages.NetworkOperatorSettingsOrBuilder>(
9743                   networkOperatorSettings_,
9744                   getParentForChildren(),
9745                   isClean());
9746           networkOperatorSettings_ = null;
9747         }
9748         return networkOperatorSettingsBuilder_;
9749       }
9750
9751       // optional .openxc.NetworkDataSettings networkDataSettings = 2;
9752       private com.openxc.BinaryMessages.NetworkDataSettings networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
9753       private com.google.protobuf.SingleFieldBuilder<
9754           com.openxc.BinaryMessages.NetworkDataSettings, com.openxc.BinaryMessages.NetworkDataSettings.Builder, com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder> networkDataSettingsBuilder_;
9755       /**
9756        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9757        */
9758       public boolean hasNetworkDataSettings() {
9759         return ((bitField0_ & 0x00000002) == 0x00000002);
9760       }
9761       /**
9762        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9763        */
9764       public com.openxc.BinaryMessages.NetworkDataSettings getNetworkDataSettings() {
9765         if (networkDataSettingsBuilder_ == null) {
9766           return networkDataSettings_;
9767         } else {
9768           return networkDataSettingsBuilder_.getMessage();
9769         }
9770       }
9771       /**
9772        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9773        */
9774       public Builder setNetworkDataSettings(com.openxc.BinaryMessages.NetworkDataSettings value) {
9775         if (networkDataSettingsBuilder_ == null) {
9776           if (value == null) {
9777             throw new NullPointerException();
9778           }
9779           networkDataSettings_ = value;
9780           onChanged();
9781         } else {
9782           networkDataSettingsBuilder_.setMessage(value);
9783         }
9784         bitField0_ |= 0x00000002;
9785         return this;
9786       }
9787       /**
9788        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9789        */
9790       public Builder setNetworkDataSettings(
9791           com.openxc.BinaryMessages.NetworkDataSettings.Builder builderForValue) {
9792         if (networkDataSettingsBuilder_ == null) {
9793           networkDataSettings_ = builderForValue.build();
9794           onChanged();
9795         } else {
9796           networkDataSettingsBuilder_.setMessage(builderForValue.build());
9797         }
9798         bitField0_ |= 0x00000002;
9799         return this;
9800       }
9801       /**
9802        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9803        */
9804       public Builder mergeNetworkDataSettings(com.openxc.BinaryMessages.NetworkDataSettings value) {
9805         if (networkDataSettingsBuilder_ == null) {
9806           if (((bitField0_ & 0x00000002) == 0x00000002) &&
9807               networkDataSettings_ != com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance()) {
9808             networkDataSettings_ =
9809               com.openxc.BinaryMessages.NetworkDataSettings.newBuilder(networkDataSettings_).mergeFrom(value).buildPartial();
9810           } else {
9811             networkDataSettings_ = value;
9812           }
9813           onChanged();
9814         } else {
9815           networkDataSettingsBuilder_.mergeFrom(value);
9816         }
9817         bitField0_ |= 0x00000002;
9818         return this;
9819       }
9820       /**
9821        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9822        */
9823       public Builder clearNetworkDataSettings() {
9824         if (networkDataSettingsBuilder_ == null) {
9825           networkDataSettings_ = com.openxc.BinaryMessages.NetworkDataSettings.getDefaultInstance();
9826           onChanged();
9827         } else {
9828           networkDataSettingsBuilder_.clear();
9829         }
9830         bitField0_ = (bitField0_ & ~0x00000002);
9831         return this;
9832       }
9833       /**
9834        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9835        */
9836       public com.openxc.BinaryMessages.NetworkDataSettings.Builder getNetworkDataSettingsBuilder() {
9837         bitField0_ |= 0x00000002;
9838         onChanged();
9839         return getNetworkDataSettingsFieldBuilder().getBuilder();
9840       }
9841       /**
9842        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9843        */
9844       public com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder getNetworkDataSettingsOrBuilder() {
9845         if (networkDataSettingsBuilder_ != null) {
9846           return networkDataSettingsBuilder_.getMessageOrBuilder();
9847         } else {
9848           return networkDataSettings_;
9849         }
9850       }
9851       /**
9852        * <code>optional .openxc.NetworkDataSettings networkDataSettings = 2;</code>
9853        */
9854       private com.google.protobuf.SingleFieldBuilder<
9855           com.openxc.BinaryMessages.NetworkDataSettings, com.openxc.BinaryMessages.NetworkDataSettings.Builder, com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder>
9856           getNetworkDataSettingsFieldBuilder() {
9857         if (networkDataSettingsBuilder_ == null) {
9858           networkDataSettingsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
9859               com.openxc.BinaryMessages.NetworkDataSettings, com.openxc.BinaryMessages.NetworkDataSettings.Builder, com.openxc.BinaryMessages.NetworkDataSettingsOrBuilder>(
9860                   networkDataSettings_,
9861                   getParentForChildren(),
9862                   isClean());
9863           networkDataSettings_ = null;
9864         }
9865         return networkDataSettingsBuilder_;
9866       }
9867
9868       // optional .openxc.ServerConnectSettings serverConnectSettings = 3;
9869       private com.openxc.BinaryMessages.ServerConnectSettings serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
9870       private com.google.protobuf.SingleFieldBuilder<
9871           com.openxc.BinaryMessages.ServerConnectSettings, com.openxc.BinaryMessages.ServerConnectSettings.Builder, com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder> serverConnectSettingsBuilder_;
9872       /**
9873        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9874        */
9875       public boolean hasServerConnectSettings() {
9876         return ((bitField0_ & 0x00000004) == 0x00000004);
9877       }
9878       /**
9879        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9880        */
9881       public com.openxc.BinaryMessages.ServerConnectSettings getServerConnectSettings() {
9882         if (serverConnectSettingsBuilder_ == null) {
9883           return serverConnectSettings_;
9884         } else {
9885           return serverConnectSettingsBuilder_.getMessage();
9886         }
9887       }
9888       /**
9889        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9890        */
9891       public Builder setServerConnectSettings(com.openxc.BinaryMessages.ServerConnectSettings value) {
9892         if (serverConnectSettingsBuilder_ == null) {
9893           if (value == null) {
9894             throw new NullPointerException();
9895           }
9896           serverConnectSettings_ = value;
9897           onChanged();
9898         } else {
9899           serverConnectSettingsBuilder_.setMessage(value);
9900         }
9901         bitField0_ |= 0x00000004;
9902         return this;
9903       }
9904       /**
9905        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9906        */
9907       public Builder setServerConnectSettings(
9908           com.openxc.BinaryMessages.ServerConnectSettings.Builder builderForValue) {
9909         if (serverConnectSettingsBuilder_ == null) {
9910           serverConnectSettings_ = builderForValue.build();
9911           onChanged();
9912         } else {
9913           serverConnectSettingsBuilder_.setMessage(builderForValue.build());
9914         }
9915         bitField0_ |= 0x00000004;
9916         return this;
9917       }
9918       /**
9919        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9920        */
9921       public Builder mergeServerConnectSettings(com.openxc.BinaryMessages.ServerConnectSettings value) {
9922         if (serverConnectSettingsBuilder_ == null) {
9923           if (((bitField0_ & 0x00000004) == 0x00000004) &&
9924               serverConnectSettings_ != com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance()) {
9925             serverConnectSettings_ =
9926               com.openxc.BinaryMessages.ServerConnectSettings.newBuilder(serverConnectSettings_).mergeFrom(value).buildPartial();
9927           } else {
9928             serverConnectSettings_ = value;
9929           }
9930           onChanged();
9931         } else {
9932           serverConnectSettingsBuilder_.mergeFrom(value);
9933         }
9934         bitField0_ |= 0x00000004;
9935         return this;
9936       }
9937       /**
9938        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9939        */
9940       public Builder clearServerConnectSettings() {
9941         if (serverConnectSettingsBuilder_ == null) {
9942           serverConnectSettings_ = com.openxc.BinaryMessages.ServerConnectSettings.getDefaultInstance();
9943           onChanged();
9944         } else {
9945           serverConnectSettingsBuilder_.clear();
9946         }
9947         bitField0_ = (bitField0_ & ~0x00000004);
9948         return this;
9949       }
9950       /**
9951        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9952        */
9953       public com.openxc.BinaryMessages.ServerConnectSettings.Builder getServerConnectSettingsBuilder() {
9954         bitField0_ |= 0x00000004;
9955         onChanged();
9956         return getServerConnectSettingsFieldBuilder().getBuilder();
9957       }
9958       /**
9959        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9960        */
9961       public com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder getServerConnectSettingsOrBuilder() {
9962         if (serverConnectSettingsBuilder_ != null) {
9963           return serverConnectSettingsBuilder_.getMessageOrBuilder();
9964         } else {
9965           return serverConnectSettings_;
9966         }
9967       }
9968       /**
9969        * <code>optional .openxc.ServerConnectSettings serverConnectSettings = 3;</code>
9970        */
9971       private com.google.protobuf.SingleFieldBuilder<
9972           com.openxc.BinaryMessages.ServerConnectSettings, com.openxc.BinaryMessages.ServerConnectSettings.Builder, com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder>
9973           getServerConnectSettingsFieldBuilder() {
9974         if (serverConnectSettingsBuilder_ == null) {
9975           serverConnectSettingsBuilder_ = new com.google.protobuf.SingleFieldBuilder<
9976               com.openxc.BinaryMessages.ServerConnectSettings, com.openxc.BinaryMessages.ServerConnectSettings.Builder, com.openxc.BinaryMessages.ServerConnectSettingsOrBuilder>(
9977                   serverConnectSettings_,
9978                   getParentForChildren(),
9979                   isClean());
9980           serverConnectSettings_ = null;
9981         }
9982         return serverConnectSettingsBuilder_;
9983       }
9984
9985       // @@protoc_insertion_point(builder_scope:openxc.ModemConfigurationCommand)
9986     }
9987
9988     static {
9989       defaultInstance = new ModemConfigurationCommand(true);
9990       defaultInstance.initFields();
9991     }
9992
9993     // @@protoc_insertion_point(class_scope:openxc.ModemConfigurationCommand)
9994   }
9995
9996   public interface RTCConfigurationCommandOrBuilder
9997       extends com.google.protobuf.MessageOrBuilder {
9998
9999     // optional uint32 unix_time = 1;
10000     /**
10001      * <code>optional uint32 unix_time = 1;</code>
10002      */
10003     boolean hasUnixTime();
10004     /**
10005      * <code>optional uint32 unix_time = 1;</code>
10006      */
10007     int getUnixTime();
10008   }
10009   /**
10010    * Protobuf type {@code openxc.RTCConfigurationCommand}
10011    */
10012   public static final class RTCConfigurationCommand extends
10013       com.google.protobuf.GeneratedMessage
10014       implements RTCConfigurationCommandOrBuilder {
10015     // Use RTCConfigurationCommand.newBuilder() to construct.
10016     private RTCConfigurationCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
10017       super(builder);
10018       this.unknownFields = builder.getUnknownFields();
10019     }
10020     private RTCConfigurationCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
10021
10022     private static final RTCConfigurationCommand defaultInstance;
10023     public static RTCConfigurationCommand getDefaultInstance() {
10024       return defaultInstance;
10025     }
10026
10027     public RTCConfigurationCommand getDefaultInstanceForType() {
10028       return defaultInstance;
10029     }
10030
10031     private final com.google.protobuf.UnknownFieldSet unknownFields;
10032     @java.lang.Override
10033     public final com.google.protobuf.UnknownFieldSet
10034         getUnknownFields() {
10035       return this.unknownFields;
10036     }
10037     private RTCConfigurationCommand(
10038         com.google.protobuf.CodedInputStream input,
10039         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10040         throws com.google.protobuf.InvalidProtocolBufferException {
10041       initFields();
10042       int mutable_bitField0_ = 0;
10043       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
10044           com.google.protobuf.UnknownFieldSet.newBuilder();
10045       try {
10046         boolean done = false;
10047         while (!done) {
10048           int tag = input.readTag();
10049           switch (tag) {
10050             case 0:
10051               done = true;
10052               break;
10053             default: {
10054               if (!parseUnknownField(input, unknownFields,
10055                                      extensionRegistry, tag)) {
10056                 done = true;
10057               }
10058               break;
10059             }
10060             case 8: {
10061               bitField0_ |= 0x00000001;
10062               unixTime_ = input.readUInt32();
10063               break;
10064             }
10065           }
10066         }
10067       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
10068         throw e.setUnfinishedMessage(this);
10069       } catch (java.io.IOException e) {
10070         throw new com.google.protobuf.InvalidProtocolBufferException(
10071             e.getMessage()).setUnfinishedMessage(this);
10072       } finally {
10073         this.unknownFields = unknownFields.build();
10074         makeExtensionsImmutable();
10075       }
10076     }
10077     public static final com.google.protobuf.Descriptors.Descriptor
10078         getDescriptor() {
10079       return com.openxc.BinaryMessages.internal_static_openxc_RTCConfigurationCommand_descriptor;
10080     }
10081
10082     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10083         internalGetFieldAccessorTable() {
10084       return com.openxc.BinaryMessages.internal_static_openxc_RTCConfigurationCommand_fieldAccessorTable
10085           .ensureFieldAccessorsInitialized(
10086               com.openxc.BinaryMessages.RTCConfigurationCommand.class, com.openxc.BinaryMessages.RTCConfigurationCommand.Builder.class);
10087     }
10088
10089     public static com.google.protobuf.Parser<RTCConfigurationCommand> PARSER =
10090         new com.google.protobuf.AbstractParser<RTCConfigurationCommand>() {
10091       public RTCConfigurationCommand parsePartialFrom(
10092           com.google.protobuf.CodedInputStream input,
10093           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10094           throws com.google.protobuf.InvalidProtocolBufferException {
10095         return new RTCConfigurationCommand(input, extensionRegistry);
10096       }
10097     };
10098
10099     @java.lang.Override
10100     public com.google.protobuf.Parser<RTCConfigurationCommand> getParserForType() {
10101       return PARSER;
10102     }
10103
10104     private int bitField0_;
10105     // optional uint32 unix_time = 1;
10106     public static final int UNIX_TIME_FIELD_NUMBER = 1;
10107     private int unixTime_;
10108     /**
10109      * <code>optional uint32 unix_time = 1;</code>
10110      */
10111     public boolean hasUnixTime() {
10112       return ((bitField0_ & 0x00000001) == 0x00000001);
10113     }
10114     /**
10115      * <code>optional uint32 unix_time = 1;</code>
10116      */
10117     public int getUnixTime() {
10118       return unixTime_;
10119     }
10120
10121     private void initFields() {
10122       unixTime_ = 0;
10123     }
10124     private byte memoizedIsInitialized = -1;
10125     public final boolean isInitialized() {
10126       byte isInitialized = memoizedIsInitialized;
10127       if (isInitialized != -1) return isInitialized == 1;
10128
10129       memoizedIsInitialized = 1;
10130       return true;
10131     }
10132
10133     public void writeTo(com.google.protobuf.CodedOutputStream output)
10134                         throws java.io.IOException {
10135       getSerializedSize();
10136       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10137         output.writeUInt32(1, unixTime_);
10138       }
10139       getUnknownFields().writeTo(output);
10140     }
10141
10142     private int memoizedSerializedSize = -1;
10143     public int getSerializedSize() {
10144       int size = memoizedSerializedSize;
10145       if (size != -1) return size;
10146
10147       size = 0;
10148       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10149         size += com.google.protobuf.CodedOutputStream
10150           .computeUInt32Size(1, unixTime_);
10151       }
10152       size += getUnknownFields().getSerializedSize();
10153       memoizedSerializedSize = size;
10154       return size;
10155     }
10156
10157     private static final long serialVersionUID = 0L;
10158     @java.lang.Override
10159     protected java.lang.Object writeReplace()
10160         throws java.io.ObjectStreamException {
10161       return super.writeReplace();
10162     }
10163
10164     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(
10165         com.google.protobuf.ByteString data)
10166         throws com.google.protobuf.InvalidProtocolBufferException {
10167       return PARSER.parseFrom(data);
10168     }
10169     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(
10170         com.google.protobuf.ByteString data,
10171         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10172         throws com.google.protobuf.InvalidProtocolBufferException {
10173       return PARSER.parseFrom(data, extensionRegistry);
10174     }
10175     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(byte[] data)
10176         throws com.google.protobuf.InvalidProtocolBufferException {
10177       return PARSER.parseFrom(data);
10178     }
10179     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(
10180         byte[] data,
10181         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10182         throws com.google.protobuf.InvalidProtocolBufferException {
10183       return PARSER.parseFrom(data, extensionRegistry);
10184     }
10185     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(java.io.InputStream input)
10186         throws java.io.IOException {
10187       return PARSER.parseFrom(input);
10188     }
10189     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(
10190         java.io.InputStream input,
10191         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10192         throws java.io.IOException {
10193       return PARSER.parseFrom(input, extensionRegistry);
10194     }
10195     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseDelimitedFrom(java.io.InputStream input)
10196         throws java.io.IOException {
10197       return PARSER.parseDelimitedFrom(input);
10198     }
10199     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseDelimitedFrom(
10200         java.io.InputStream input,
10201         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10202         throws java.io.IOException {
10203       return PARSER.parseDelimitedFrom(input, extensionRegistry);
10204     }
10205     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(
10206         com.google.protobuf.CodedInputStream input)
10207         throws java.io.IOException {
10208       return PARSER.parseFrom(input);
10209     }
10210     public static com.openxc.BinaryMessages.RTCConfigurationCommand parseFrom(
10211         com.google.protobuf.CodedInputStream input,
10212         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10213         throws java.io.IOException {
10214       return PARSER.parseFrom(input, extensionRegistry);
10215     }
10216
10217     public static Builder newBuilder() { return Builder.create(); }
10218     public Builder newBuilderForType() { return newBuilder(); }
10219     public static Builder newBuilder(com.openxc.BinaryMessages.RTCConfigurationCommand prototype) {
10220       return newBuilder().mergeFrom(prototype);
10221     }
10222     public Builder toBuilder() { return newBuilder(this); }
10223
10224     @java.lang.Override
10225     protected Builder newBuilderForType(
10226         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
10227       Builder builder = new Builder(parent);
10228       return builder;
10229     }
10230     /**
10231      * Protobuf type {@code openxc.RTCConfigurationCommand}
10232      */
10233     public static final class Builder extends
10234         com.google.protobuf.GeneratedMessage.Builder<Builder>
10235        implements com.openxc.BinaryMessages.RTCConfigurationCommandOrBuilder {
10236       public static final com.google.protobuf.Descriptors.Descriptor
10237           getDescriptor() {
10238         return com.openxc.BinaryMessages.internal_static_openxc_RTCConfigurationCommand_descriptor;
10239       }
10240
10241       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10242           internalGetFieldAccessorTable() {
10243         return com.openxc.BinaryMessages.internal_static_openxc_RTCConfigurationCommand_fieldAccessorTable
10244             .ensureFieldAccessorsInitialized(
10245                 com.openxc.BinaryMessages.RTCConfigurationCommand.class, com.openxc.BinaryMessages.RTCConfigurationCommand.Builder.class);
10246       }
10247
10248       // Construct using com.openxc.BinaryMessages.RTCConfigurationCommand.newBuilder()
10249       private Builder() {
10250         maybeForceBuilderInitialization();
10251       }
10252
10253       private Builder(
10254           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
10255         super(parent);
10256         maybeForceBuilderInitialization();
10257       }
10258       private void maybeForceBuilderInitialization() {
10259         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
10260         }
10261       }
10262       private static Builder create() {
10263         return new Builder();
10264       }
10265
10266       public Builder clear() {
10267         super.clear();
10268         unixTime_ = 0;
10269         bitField0_ = (bitField0_ & ~0x00000001);
10270         return this;
10271       }
10272
10273       public Builder clone() {
10274         return create().mergeFrom(buildPartial());
10275       }
10276
10277       public com.google.protobuf.Descriptors.Descriptor
10278           getDescriptorForType() {
10279         return com.openxc.BinaryMessages.internal_static_openxc_RTCConfigurationCommand_descriptor;
10280       }
10281
10282       public com.openxc.BinaryMessages.RTCConfigurationCommand getDefaultInstanceForType() {
10283         return com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance();
10284       }
10285
10286       public com.openxc.BinaryMessages.RTCConfigurationCommand build() {
10287         com.openxc.BinaryMessages.RTCConfigurationCommand result = buildPartial();
10288         if (!result.isInitialized()) {
10289           throw newUninitializedMessageException(result);
10290         }
10291         return result;
10292       }
10293
10294       public com.openxc.BinaryMessages.RTCConfigurationCommand buildPartial() {
10295         com.openxc.BinaryMessages.RTCConfigurationCommand result = new com.openxc.BinaryMessages.RTCConfigurationCommand(this);
10296         int from_bitField0_ = bitField0_;
10297         int to_bitField0_ = 0;
10298         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
10299           to_bitField0_ |= 0x00000001;
10300         }
10301         result.unixTime_ = unixTime_;
10302         result.bitField0_ = to_bitField0_;
10303         onBuilt();
10304         return result;
10305       }
10306
10307       public Builder mergeFrom(com.google.protobuf.Message other) {
10308         if (other instanceof com.openxc.BinaryMessages.RTCConfigurationCommand) {
10309           return mergeFrom((com.openxc.BinaryMessages.RTCConfigurationCommand)other);
10310         } else {
10311           super.mergeFrom(other);
10312           return this;
10313         }
10314       }
10315
10316       public Builder mergeFrom(com.openxc.BinaryMessages.RTCConfigurationCommand other) {
10317         if (other == com.openxc.BinaryMessages.RTCConfigurationCommand.getDefaultInstance()) return this;
10318         if (other.hasUnixTime()) {
10319           setUnixTime(other.getUnixTime());
10320         }
10321         this.mergeUnknownFields(other.getUnknownFields());
10322         return this;
10323       }
10324
10325       public final boolean isInitialized() {
10326         return true;
10327       }
10328
10329       public Builder mergeFrom(
10330           com.google.protobuf.CodedInputStream input,
10331           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10332           throws java.io.IOException {
10333         com.openxc.BinaryMessages.RTCConfigurationCommand parsedMessage = null;
10334         try {
10335           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
10336         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
10337           parsedMessage = (com.openxc.BinaryMessages.RTCConfigurationCommand) e.getUnfinishedMessage();
10338           throw e;
10339         } finally {
10340           if (parsedMessage != null) {
10341             mergeFrom(parsedMessage);
10342           }
10343         }
10344         return this;
10345       }
10346       private int bitField0_;
10347
10348       // optional uint32 unix_time = 1;
10349       private int unixTime_ ;
10350       /**
10351        * <code>optional uint32 unix_time = 1;</code>
10352        */
10353       public boolean hasUnixTime() {
10354         return ((bitField0_ & 0x00000001) == 0x00000001);
10355       }
10356       /**
10357        * <code>optional uint32 unix_time = 1;</code>
10358        */
10359       public int getUnixTime() {
10360         return unixTime_;
10361       }
10362       /**
10363        * <code>optional uint32 unix_time = 1;</code>
10364        */
10365       public Builder setUnixTime(int value) {
10366         bitField0_ |= 0x00000001;
10367         unixTime_ = value;
10368         onChanged();
10369         return this;
10370       }
10371       /**
10372        * <code>optional uint32 unix_time = 1;</code>
10373        */
10374       public Builder clearUnixTime() {
10375         bitField0_ = (bitField0_ & ~0x00000001);
10376         unixTime_ = 0;
10377         onChanged();
10378         return this;
10379       }
10380
10381       // @@protoc_insertion_point(builder_scope:openxc.RTCConfigurationCommand)
10382     }
10383
10384     static {
10385       defaultInstance = new RTCConfigurationCommand(true);
10386       defaultInstance.initFields();
10387     }
10388
10389     // @@protoc_insertion_point(class_scope:openxc.RTCConfigurationCommand)
10390   }
10391
10392   public interface CommandResponseOrBuilder
10393       extends com.google.protobuf.MessageOrBuilder {
10394
10395     // optional .openxc.ControlCommand.Type type = 1;
10396     /**
10397      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10398      */
10399     boolean hasType();
10400     /**
10401      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10402      */
10403     com.openxc.BinaryMessages.ControlCommand.Type getType();
10404
10405     // optional string message = 2;
10406     /**
10407      * <code>optional string message = 2;</code>
10408      */
10409     boolean hasMessage();
10410     /**
10411      * <code>optional string message = 2;</code>
10412      */
10413     java.lang.String getMessage();
10414     /**
10415      * <code>optional string message = 2;</code>
10416      */
10417     com.google.protobuf.ByteString
10418         getMessageBytes();
10419
10420     // optional bool status = 3;
10421     /**
10422      * <code>optional bool status = 3;</code>
10423      */
10424     boolean hasStatus();
10425     /**
10426      * <code>optional bool status = 3;</code>
10427      */
10428     boolean getStatus();
10429   }
10430   /**
10431    * Protobuf type {@code openxc.CommandResponse}
10432    */
10433   public static final class CommandResponse extends
10434       com.google.protobuf.GeneratedMessage
10435       implements CommandResponseOrBuilder {
10436     // Use CommandResponse.newBuilder() to construct.
10437     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
10438       super(builder);
10439       this.unknownFields = builder.getUnknownFields();
10440     }
10441     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
10442
10443     private static final CommandResponse defaultInstance;
10444     public static CommandResponse getDefaultInstance() {
10445       return defaultInstance;
10446     }
10447
10448     public CommandResponse getDefaultInstanceForType() {
10449       return defaultInstance;
10450     }
10451
10452     private final com.google.protobuf.UnknownFieldSet unknownFields;
10453     @java.lang.Override
10454     public final com.google.protobuf.UnknownFieldSet
10455         getUnknownFields() {
10456       return this.unknownFields;
10457     }
10458     private CommandResponse(
10459         com.google.protobuf.CodedInputStream input,
10460         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10461         throws com.google.protobuf.InvalidProtocolBufferException {
10462       initFields();
10463       int mutable_bitField0_ = 0;
10464       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
10465           com.google.protobuf.UnknownFieldSet.newBuilder();
10466       try {
10467         boolean done = false;
10468         while (!done) {
10469           int tag = input.readTag();
10470           switch (tag) {
10471             case 0:
10472               done = true;
10473               break;
10474             default: {
10475               if (!parseUnknownField(input, unknownFields,
10476                                      extensionRegistry, tag)) {
10477                 done = true;
10478               }
10479               break;
10480             }
10481             case 8: {
10482               int rawValue = input.readEnum();
10483               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
10484               if (value == null) {
10485                 unknownFields.mergeVarintField(1, rawValue);
10486               } else {
10487                 bitField0_ |= 0x00000001;
10488                 type_ = value;
10489               }
10490               break;
10491             }
10492             case 18: {
10493               bitField0_ |= 0x00000002;
10494               message_ = input.readBytes();
10495               break;
10496             }
10497             case 24: {
10498               bitField0_ |= 0x00000004;
10499               status_ = input.readBool();
10500               break;
10501             }
10502           }
10503         }
10504       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
10505         throw e.setUnfinishedMessage(this);
10506       } catch (java.io.IOException e) {
10507         throw new com.google.protobuf.InvalidProtocolBufferException(
10508             e.getMessage()).setUnfinishedMessage(this);
10509       } finally {
10510         this.unknownFields = unknownFields.build();
10511         makeExtensionsImmutable();
10512       }
10513     }
10514     public static final com.google.protobuf.Descriptors.Descriptor
10515         getDescriptor() {
10516       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
10517     }
10518
10519     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10520         internalGetFieldAccessorTable() {
10521       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
10522           .ensureFieldAccessorsInitialized(
10523               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
10524     }
10525
10526     public static com.google.protobuf.Parser<CommandResponse> PARSER =
10527         new com.google.protobuf.AbstractParser<CommandResponse>() {
10528       public CommandResponse parsePartialFrom(
10529           com.google.protobuf.CodedInputStream input,
10530           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10531           throws com.google.protobuf.InvalidProtocolBufferException {
10532         return new CommandResponse(input, extensionRegistry);
10533       }
10534     };
10535
10536     @java.lang.Override
10537     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
10538       return PARSER;
10539     }
10540
10541     private int bitField0_;
10542     // optional .openxc.ControlCommand.Type type = 1;
10543     public static final int TYPE_FIELD_NUMBER = 1;
10544     private com.openxc.BinaryMessages.ControlCommand.Type type_;
10545     /**
10546      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10547      */
10548     public boolean hasType() {
10549       return ((bitField0_ & 0x00000001) == 0x00000001);
10550     }
10551     /**
10552      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10553      */
10554     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
10555       return type_;
10556     }
10557
10558     // optional string message = 2;
10559     public static final int MESSAGE_FIELD_NUMBER = 2;
10560     private java.lang.Object message_;
10561     /**
10562      * <code>optional string message = 2;</code>
10563      */
10564     public boolean hasMessage() {
10565       return ((bitField0_ & 0x00000002) == 0x00000002);
10566     }
10567     /**
10568      * <code>optional string message = 2;</code>
10569      */
10570     public java.lang.String getMessage() {
10571       java.lang.Object ref = message_;
10572       if (ref instanceof java.lang.String) {
10573         return (java.lang.String) ref;
10574       } else {
10575         com.google.protobuf.ByteString bs =
10576             (com.google.protobuf.ByteString) ref;
10577         java.lang.String s = bs.toStringUtf8();
10578         if (bs.isValidUtf8()) {
10579           message_ = s;
10580         }
10581         return s;
10582       }
10583     }
10584     /**
10585      * <code>optional string message = 2;</code>
10586      */
10587     public com.google.protobuf.ByteString
10588         getMessageBytes() {
10589       java.lang.Object ref = message_;
10590       if (ref instanceof java.lang.String) {
10591         com.google.protobuf.ByteString b =
10592             com.google.protobuf.ByteString.copyFromUtf8(
10593                 (java.lang.String) ref);
10594         message_ = b;
10595         return b;
10596       } else {
10597         return (com.google.protobuf.ByteString) ref;
10598       }
10599     }
10600
10601     // optional bool status = 3;
10602     public static final int STATUS_FIELD_NUMBER = 3;
10603     private boolean status_;
10604     /**
10605      * <code>optional bool status = 3;</code>
10606      */
10607     public boolean hasStatus() {
10608       return ((bitField0_ & 0x00000004) == 0x00000004);
10609     }
10610     /**
10611      * <code>optional bool status = 3;</code>
10612      */
10613     public boolean getStatus() {
10614       return status_;
10615     }
10616
10617     private void initFields() {
10618       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
10619       message_ = "";
10620       status_ = false;
10621     }
10622     private byte memoizedIsInitialized = -1;
10623     public final boolean isInitialized() {
10624       byte isInitialized = memoizedIsInitialized;
10625       if (isInitialized != -1) return isInitialized == 1;
10626
10627       memoizedIsInitialized = 1;
10628       return true;
10629     }
10630
10631     public void writeTo(com.google.protobuf.CodedOutputStream output)
10632                         throws java.io.IOException {
10633       getSerializedSize();
10634       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10635         output.writeEnum(1, type_.getNumber());
10636       }
10637       if (((bitField0_ & 0x00000002) == 0x00000002)) {
10638         output.writeBytes(2, getMessageBytes());
10639       }
10640       if (((bitField0_ & 0x00000004) == 0x00000004)) {
10641         output.writeBool(3, status_);
10642       }
10643       getUnknownFields().writeTo(output);
10644     }
10645
10646     private int memoizedSerializedSize = -1;
10647     public int getSerializedSize() {
10648       int size = memoizedSerializedSize;
10649       if (size != -1) return size;
10650
10651       size = 0;
10652       if (((bitField0_ & 0x00000001) == 0x00000001)) {
10653         size += com.google.protobuf.CodedOutputStream
10654           .computeEnumSize(1, type_.getNumber());
10655       }
10656       if (((bitField0_ & 0x00000002) == 0x00000002)) {
10657         size += com.google.protobuf.CodedOutputStream
10658           .computeBytesSize(2, getMessageBytes());
10659       }
10660       if (((bitField0_ & 0x00000004) == 0x00000004)) {
10661         size += com.google.protobuf.CodedOutputStream
10662           .computeBoolSize(3, status_);
10663       }
10664       size += getUnknownFields().getSerializedSize();
10665       memoizedSerializedSize = size;
10666       return size;
10667     }
10668
10669     private static final long serialVersionUID = 0L;
10670     @java.lang.Override
10671     protected java.lang.Object writeReplace()
10672         throws java.io.ObjectStreamException {
10673       return super.writeReplace();
10674     }
10675
10676     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
10677         com.google.protobuf.ByteString data)
10678         throws com.google.protobuf.InvalidProtocolBufferException {
10679       return PARSER.parseFrom(data);
10680     }
10681     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
10682         com.google.protobuf.ByteString data,
10683         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10684         throws com.google.protobuf.InvalidProtocolBufferException {
10685       return PARSER.parseFrom(data, extensionRegistry);
10686     }
10687     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
10688         throws com.google.protobuf.InvalidProtocolBufferException {
10689       return PARSER.parseFrom(data);
10690     }
10691     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
10692         byte[] data,
10693         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10694         throws com.google.protobuf.InvalidProtocolBufferException {
10695       return PARSER.parseFrom(data, extensionRegistry);
10696     }
10697     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
10698         throws java.io.IOException {
10699       return PARSER.parseFrom(input);
10700     }
10701     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
10702         java.io.InputStream input,
10703         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10704         throws java.io.IOException {
10705       return PARSER.parseFrom(input, extensionRegistry);
10706     }
10707     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
10708         throws java.io.IOException {
10709       return PARSER.parseDelimitedFrom(input);
10710     }
10711     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
10712         java.io.InputStream input,
10713         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10714         throws java.io.IOException {
10715       return PARSER.parseDelimitedFrom(input, extensionRegistry);
10716     }
10717     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
10718         com.google.protobuf.CodedInputStream input)
10719         throws java.io.IOException {
10720       return PARSER.parseFrom(input);
10721     }
10722     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
10723         com.google.protobuf.CodedInputStream input,
10724         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10725         throws java.io.IOException {
10726       return PARSER.parseFrom(input, extensionRegistry);
10727     }
10728
10729     public static Builder newBuilder() { return Builder.create(); }
10730     public Builder newBuilderForType() { return newBuilder(); }
10731     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
10732       return newBuilder().mergeFrom(prototype);
10733     }
10734     public Builder toBuilder() { return newBuilder(this); }
10735
10736     @java.lang.Override
10737     protected Builder newBuilderForType(
10738         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
10739       Builder builder = new Builder(parent);
10740       return builder;
10741     }
10742     /**
10743      * Protobuf type {@code openxc.CommandResponse}
10744      */
10745     public static final class Builder extends
10746         com.google.protobuf.GeneratedMessage.Builder<Builder>
10747        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
10748       public static final com.google.protobuf.Descriptors.Descriptor
10749           getDescriptor() {
10750         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
10751       }
10752
10753       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
10754           internalGetFieldAccessorTable() {
10755         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
10756             .ensureFieldAccessorsInitialized(
10757                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
10758       }
10759
10760       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
10761       private Builder() {
10762         maybeForceBuilderInitialization();
10763       }
10764
10765       private Builder(
10766           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
10767         super(parent);
10768         maybeForceBuilderInitialization();
10769       }
10770       private void maybeForceBuilderInitialization() {
10771         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
10772         }
10773       }
10774       private static Builder create() {
10775         return new Builder();
10776       }
10777
10778       public Builder clear() {
10779         super.clear();
10780         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
10781         bitField0_ = (bitField0_ & ~0x00000001);
10782         message_ = "";
10783         bitField0_ = (bitField0_ & ~0x00000002);
10784         status_ = false;
10785         bitField0_ = (bitField0_ & ~0x00000004);
10786         return this;
10787       }
10788
10789       public Builder clone() {
10790         return create().mergeFrom(buildPartial());
10791       }
10792
10793       public com.google.protobuf.Descriptors.Descriptor
10794           getDescriptorForType() {
10795         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
10796       }
10797
10798       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
10799         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
10800       }
10801
10802       public com.openxc.BinaryMessages.CommandResponse build() {
10803         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
10804         if (!result.isInitialized()) {
10805           throw newUninitializedMessageException(result);
10806         }
10807         return result;
10808       }
10809
10810       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
10811         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
10812         int from_bitField0_ = bitField0_;
10813         int to_bitField0_ = 0;
10814         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
10815           to_bitField0_ |= 0x00000001;
10816         }
10817         result.type_ = type_;
10818         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
10819           to_bitField0_ |= 0x00000002;
10820         }
10821         result.message_ = message_;
10822         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
10823           to_bitField0_ |= 0x00000004;
10824         }
10825         result.status_ = status_;
10826         result.bitField0_ = to_bitField0_;
10827         onBuilt();
10828         return result;
10829       }
10830
10831       public Builder mergeFrom(com.google.protobuf.Message other) {
10832         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
10833           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
10834         } else {
10835           super.mergeFrom(other);
10836           return this;
10837         }
10838       }
10839
10840       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
10841         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
10842         if (other.hasType()) {
10843           setType(other.getType());
10844         }
10845         if (other.hasMessage()) {
10846           bitField0_ |= 0x00000002;
10847           message_ = other.message_;
10848           onChanged();
10849         }
10850         if (other.hasStatus()) {
10851           setStatus(other.getStatus());
10852         }
10853         this.mergeUnknownFields(other.getUnknownFields());
10854         return this;
10855       }
10856
10857       public final boolean isInitialized() {
10858         return true;
10859       }
10860
10861       public Builder mergeFrom(
10862           com.google.protobuf.CodedInputStream input,
10863           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
10864           throws java.io.IOException {
10865         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
10866         try {
10867           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
10868         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
10869           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
10870           throw e;
10871         } finally {
10872           if (parsedMessage != null) {
10873             mergeFrom(parsedMessage);
10874           }
10875         }
10876         return this;
10877       }
10878       private int bitField0_;
10879
10880       // optional .openxc.ControlCommand.Type type = 1;
10881       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
10882       /**
10883        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10884        */
10885       public boolean hasType() {
10886         return ((bitField0_ & 0x00000001) == 0x00000001);
10887       }
10888       /**
10889        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10890        */
10891       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
10892         return type_;
10893       }
10894       /**
10895        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10896        */
10897       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
10898         if (value == null) {
10899           throw new NullPointerException();
10900         }
10901         bitField0_ |= 0x00000001;
10902         type_ = value;
10903         onChanged();
10904         return this;
10905       }
10906       /**
10907        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
10908        */
10909       public Builder clearType() {
10910         bitField0_ = (bitField0_ & ~0x00000001);
10911         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
10912         onChanged();
10913         return this;
10914       }
10915
10916       // optional string message = 2;
10917       private java.lang.Object message_ = "";
10918       /**
10919        * <code>optional string message = 2;</code>
10920        */
10921       public boolean hasMessage() {
10922         return ((bitField0_ & 0x00000002) == 0x00000002);
10923       }
10924       /**
10925        * <code>optional string message = 2;</code>
10926        */
10927       public java.lang.String getMessage() {
10928         java.lang.Object ref = message_;
10929         if (!(ref instanceof java.lang.String)) {
10930           java.lang.String s = ((com.google.protobuf.ByteString) ref)
10931               .toStringUtf8();
10932           message_ = s;
10933           return s;
10934         } else {
10935           return (java.lang.String) ref;
10936         }
10937       }
10938       /**
10939        * <code>optional string message = 2;</code>
10940        */
10941       public com.google.protobuf.ByteString
10942           getMessageBytes() {
10943         java.lang.Object ref = message_;
10944         if (ref instanceof String) {
10945           com.google.protobuf.ByteString b =
10946               com.google.protobuf.ByteString.copyFromUtf8(
10947                   (java.lang.String) ref);
10948           message_ = b;
10949           return b;
10950         } else {
10951           return (com.google.protobuf.ByteString) ref;
10952         }
10953       }
10954       /**
10955        * <code>optional string message = 2;</code>
10956        */
10957       public Builder setMessage(
10958           java.lang.String value) {
10959         if (value == null) {
10960     throw new NullPointerException();
10961   }
10962   bitField0_ |= 0x00000002;
10963         message_ = value;
10964         onChanged();
10965         return this;
10966       }
10967       /**
10968        * <code>optional string message = 2;</code>
10969        */
10970       public Builder clearMessage() {
10971         bitField0_ = (bitField0_ & ~0x00000002);
10972         message_ = getDefaultInstance().getMessage();
10973         onChanged();
10974         return this;
10975       }
10976       /**
10977        * <code>optional string message = 2;</code>
10978        */
10979       public Builder setMessageBytes(
10980           com.google.protobuf.ByteString value) {
10981         if (value == null) {
10982     throw new NullPointerException();
10983   }
10984   bitField0_ |= 0x00000002;
10985         message_ = value;
10986         onChanged();
10987         return this;
10988       }
10989
10990       // optional bool status = 3;
10991       private boolean status_ ;
10992       /**
10993        * <code>optional bool status = 3;</code>
10994        */
10995       public boolean hasStatus() {
10996         return ((bitField0_ & 0x00000004) == 0x00000004);
10997       }
10998       /**
10999        * <code>optional bool status = 3;</code>
11000        */
11001       public boolean getStatus() {
11002         return status_;
11003       }
11004       /**
11005        * <code>optional bool status = 3;</code>
11006        */
11007       public Builder setStatus(boolean value) {
11008         bitField0_ |= 0x00000004;
11009         status_ = value;
11010         onChanged();
11011         return this;
11012       }
11013       /**
11014        * <code>optional bool status = 3;</code>
11015        */
11016       public Builder clearStatus() {
11017         bitField0_ = (bitField0_ & ~0x00000004);
11018         status_ = false;
11019         onChanged();
11020         return this;
11021       }
11022
11023       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
11024     }
11025
11026     static {
11027       defaultInstance = new CommandResponse(true);
11028       defaultInstance.initFields();
11029     }
11030
11031     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
11032   }
11033
11034   public interface DiagnosticRequestOrBuilder
11035       extends com.google.protobuf.MessageOrBuilder {
11036
11037     // optional int32 bus = 1;
11038     /**
11039      * <code>optional int32 bus = 1;</code>
11040      */
11041     boolean hasBus();
11042     /**
11043      * <code>optional int32 bus = 1;</code>
11044      */
11045     int getBus();
11046
11047     // optional uint32 message_id = 2;
11048     /**
11049      * <code>optional uint32 message_id = 2;</code>
11050      */
11051     boolean hasMessageId();
11052     /**
11053      * <code>optional uint32 message_id = 2;</code>
11054      */
11055     int getMessageId();
11056
11057     // optional uint32 mode = 3;
11058     /**
11059      * <code>optional uint32 mode = 3;</code>
11060      */
11061     boolean hasMode();
11062     /**
11063      * <code>optional uint32 mode = 3;</code>
11064      */
11065     int getMode();
11066
11067     // optional uint32 pid = 4;
11068     /**
11069      * <code>optional uint32 pid = 4;</code>
11070      */
11071     boolean hasPid();
11072     /**
11073      * <code>optional uint32 pid = 4;</code>
11074      */
11075     int getPid();
11076
11077     // optional bytes payload = 5;
11078     /**
11079      * <code>optional bytes payload = 5;</code>
11080      *
11081      * <pre>
11082      * TODO we are capping this at 8 bytes for now - need to change when we
11083      * support multi-frame responses
11084      * </pre>
11085      */
11086     boolean hasPayload();
11087     /**
11088      * <code>optional bytes payload = 5;</code>
11089      *
11090      * <pre>
11091      * TODO we are capping this at 8 bytes for now - need to change when we
11092      * support multi-frame responses
11093      * </pre>
11094      */
11095     com.google.protobuf.ByteString getPayload();
11096
11097     // optional bool multiple_responses = 6;
11098     /**
11099      * <code>optional bool multiple_responses = 6;</code>
11100      */
11101     boolean hasMultipleResponses();
11102     /**
11103      * <code>optional bool multiple_responses = 6;</code>
11104      */
11105     boolean getMultipleResponses();
11106
11107     // optional double frequency = 7;
11108     /**
11109      * <code>optional double frequency = 7;</code>
11110      */
11111     boolean hasFrequency();
11112     /**
11113      * <code>optional double frequency = 7;</code>
11114      */
11115     double getFrequency();
11116
11117     // optional string name = 8;
11118     /**
11119      * <code>optional string name = 8;</code>
11120      */
11121     boolean hasName();
11122     /**
11123      * <code>optional string name = 8;</code>
11124      */
11125     java.lang.String getName();
11126     /**
11127      * <code>optional string name = 8;</code>
11128      */
11129     com.google.protobuf.ByteString
11130         getNameBytes();
11131
11132     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
11133     /**
11134      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
11135      */
11136     boolean hasDecodedType();
11137     /**
11138      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
11139      */
11140     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
11141   }
11142   /**
11143    * Protobuf type {@code openxc.DiagnosticRequest}
11144    */
11145   public static final class DiagnosticRequest extends
11146       com.google.protobuf.GeneratedMessage
11147       implements DiagnosticRequestOrBuilder {
11148     // Use DiagnosticRequest.newBuilder() to construct.
11149     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
11150       super(builder);
11151       this.unknownFields = builder.getUnknownFields();
11152     }
11153     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
11154
11155     private static final DiagnosticRequest defaultInstance;
11156     public static DiagnosticRequest getDefaultInstance() {
11157       return defaultInstance;
11158     }
11159
11160     public DiagnosticRequest getDefaultInstanceForType() {
11161       return defaultInstance;
11162     }
11163
11164     private final com.google.protobuf.UnknownFieldSet unknownFields;
11165     @java.lang.Override
11166     public final com.google.protobuf.UnknownFieldSet
11167         getUnknownFields() {
11168       return this.unknownFields;
11169     }
11170     private DiagnosticRequest(
11171         com.google.protobuf.CodedInputStream input,
11172         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11173         throws com.google.protobuf.InvalidProtocolBufferException {
11174       initFields();
11175       int mutable_bitField0_ = 0;
11176       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
11177           com.google.protobuf.UnknownFieldSet.newBuilder();
11178       try {
11179         boolean done = false;
11180         while (!done) {
11181           int tag = input.readTag();
11182           switch (tag) {
11183             case 0:
11184               done = true;
11185               break;
11186             default: {
11187               if (!parseUnknownField(input, unknownFields,
11188                                      extensionRegistry, tag)) {
11189                 done = true;
11190               }
11191               break;
11192             }
11193             case 8: {
11194               bitField0_ |= 0x00000001;
11195               bus_ = input.readInt32();
11196               break;
11197             }
11198             case 16: {
11199               bitField0_ |= 0x00000002;
11200               messageId_ = input.readUInt32();
11201               break;
11202             }
11203             case 24: {
11204               bitField0_ |= 0x00000004;
11205               mode_ = input.readUInt32();
11206               break;
11207             }
11208             case 32: {
11209               bitField0_ |= 0x00000008;
11210               pid_ = input.readUInt32();
11211               break;
11212             }
11213             case 42: {
11214               bitField0_ |= 0x00000010;
11215               payload_ = input.readBytes();
11216               break;
11217             }
11218             case 48: {
11219               bitField0_ |= 0x00000020;
11220               multipleResponses_ = input.readBool();
11221               break;
11222             }
11223             case 57: {
11224               bitField0_ |= 0x00000040;
11225               frequency_ = input.readDouble();
11226               break;
11227             }
11228             case 66: {
11229               bitField0_ |= 0x00000080;
11230               name_ = input.readBytes();
11231               break;
11232             }
11233             case 72: {
11234               int rawValue = input.readEnum();
11235               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
11236               if (value == null) {
11237                 unknownFields.mergeVarintField(9, rawValue);
11238               } else {
11239                 bitField0_ |= 0x00000100;
11240                 decodedType_ = value;
11241               }
11242               break;
11243             }
11244           }
11245         }
11246       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
11247         throw e.setUnfinishedMessage(this);
11248       } catch (java.io.IOException e) {
11249         throw new com.google.protobuf.InvalidProtocolBufferException(
11250             e.getMessage()).setUnfinishedMessage(this);
11251       } finally {
11252         this.unknownFields = unknownFields.build();
11253         makeExtensionsImmutable();
11254       }
11255     }
11256     public static final com.google.protobuf.Descriptors.Descriptor
11257         getDescriptor() {
11258       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
11259     }
11260
11261     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
11262         internalGetFieldAccessorTable() {
11263       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
11264           .ensureFieldAccessorsInitialized(
11265               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
11266     }
11267
11268     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
11269         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
11270       public DiagnosticRequest parsePartialFrom(
11271           com.google.protobuf.CodedInputStream input,
11272           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11273           throws com.google.protobuf.InvalidProtocolBufferException {
11274         return new DiagnosticRequest(input, extensionRegistry);
11275       }
11276     };
11277
11278     @java.lang.Override
11279     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
11280       return PARSER;
11281     }
11282
11283     /**
11284      * Protobuf enum {@code openxc.DiagnosticRequest.DecodedType}
11285      */
11286     public enum DecodedType
11287         implements com.google.protobuf.ProtocolMessageEnum {
11288       /**
11289        * <code>NONE = 1;</code>
11290        */
11291       NONE(0, 1),
11292       /**
11293        * <code>OBD2 = 2;</code>
11294        */
11295       OBD2(1, 2),
11296       ;
11297
11298       /**
11299        * <code>NONE = 1;</code>
11300        */
11301       public static final int NONE_VALUE = 1;
11302       /**
11303        * <code>OBD2 = 2;</code>
11304        */
11305       public static final int OBD2_VALUE = 2;
11306
11307
11308       public final int getNumber() { return value; }
11309
11310       public static DecodedType valueOf(int value) {
11311         switch (value) {
11312           case 1: return NONE;
11313           case 2: return OBD2;
11314           default: return null;
11315         }
11316       }
11317
11318       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
11319           internalGetValueMap() {
11320         return internalValueMap;
11321       }
11322       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
11323           internalValueMap =
11324             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
11325               public DecodedType findValueByNumber(int number) {
11326                 return DecodedType.valueOf(number);
11327               }
11328             };
11329
11330       public final com.google.protobuf.Descriptors.EnumValueDescriptor
11331           getValueDescriptor() {
11332         return getDescriptor().getValues().get(index);
11333       }
11334       public final com.google.protobuf.Descriptors.EnumDescriptor
11335           getDescriptorForType() {
11336         return getDescriptor();
11337       }
11338       public static final com.google.protobuf.Descriptors.EnumDescriptor
11339           getDescriptor() {
11340         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
11341       }
11342
11343       private static final DecodedType[] VALUES = values();
11344
11345       public static DecodedType valueOf(
11346           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
11347         if (desc.getType() != getDescriptor()) {
11348           throw new java.lang.IllegalArgumentException(
11349             "EnumValueDescriptor is not for this type.");
11350         }
11351         return VALUES[desc.getIndex()];
11352       }
11353
11354       private final int index;
11355       private final int value;
11356
11357       private DecodedType(int index, int value) {
11358         this.index = index;
11359         this.value = value;
11360       }
11361
11362       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
11363     }
11364
11365     private int bitField0_;
11366     // optional int32 bus = 1;
11367     public static final int BUS_FIELD_NUMBER = 1;
11368     private int bus_;
11369     /**
11370      * <code>optional int32 bus = 1;</code>
11371      */
11372     public boolean hasBus() {
11373       return ((bitField0_ & 0x00000001) == 0x00000001);
11374     }
11375     /**
11376      * <code>optional int32 bus = 1;</code>
11377      */
11378     public int getBus() {
11379       return bus_;
11380     }
11381
11382     // optional uint32 message_id = 2;
11383     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
11384     private int messageId_;
11385     /**
11386      * <code>optional uint32 message_id = 2;</code>
11387      */
11388     public boolean hasMessageId() {
11389       return ((bitField0_ & 0x00000002) == 0x00000002);
11390     }
11391     /**
11392      * <code>optional uint32 message_id = 2;</code>
11393      */
11394     public int getMessageId() {
11395       return messageId_;
11396     }
11397
11398     // optional uint32 mode = 3;
11399     public static final int MODE_FIELD_NUMBER = 3;
11400     private int mode_;
11401     /**
11402      * <code>optional uint32 mode = 3;</code>
11403      */
11404     public boolean hasMode() {
11405       return ((bitField0_ & 0x00000004) == 0x00000004);
11406     }
11407     /**
11408      * <code>optional uint32 mode = 3;</code>
11409      */
11410     public int getMode() {
11411       return mode_;
11412     }
11413
11414     // optional uint32 pid = 4;
11415     public static final int PID_FIELD_NUMBER = 4;
11416     private int pid_;
11417     /**
11418      * <code>optional uint32 pid = 4;</code>
11419      */
11420     public boolean hasPid() {
11421       return ((bitField0_ & 0x00000008) == 0x00000008);
11422     }
11423     /**
11424      * <code>optional uint32 pid = 4;</code>
11425      */
11426     public int getPid() {
11427       return pid_;
11428     }
11429
11430     // optional bytes payload = 5;
11431     public static final int PAYLOAD_FIELD_NUMBER = 5;
11432     private com.google.protobuf.ByteString payload_;
11433     /**
11434      * <code>optional bytes payload = 5;</code>
11435      *
11436      * <pre>
11437      * TODO we are capping this at 8 bytes for now - need to change when we
11438      * support multi-frame responses
11439      * </pre>
11440      */
11441     public boolean hasPayload() {
11442       return ((bitField0_ & 0x00000010) == 0x00000010);
11443     }
11444     /**
11445      * <code>optional bytes payload = 5;</code>
11446      *
11447      * <pre>
11448      * TODO we are capping this at 8 bytes for now - need to change when we
11449      * support multi-frame responses
11450      * </pre>
11451      */
11452     public com.google.protobuf.ByteString getPayload() {
11453       return payload_;
11454     }
11455
11456     // optional bool multiple_responses = 6;
11457     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
11458     private boolean multipleResponses_;
11459     /**
11460      * <code>optional bool multiple_responses = 6;</code>
11461      */
11462     public boolean hasMultipleResponses() {
11463       return ((bitField0_ & 0x00000020) == 0x00000020);
11464     }
11465     /**
11466      * <code>optional bool multiple_responses = 6;</code>
11467      */
11468     public boolean getMultipleResponses() {
11469       return multipleResponses_;
11470     }
11471
11472     // optional double frequency = 7;
11473     public static final int FREQUENCY_FIELD_NUMBER = 7;
11474     private double frequency_;
11475     /**
11476      * <code>optional double frequency = 7;</code>
11477      */
11478     public boolean hasFrequency() {
11479       return ((bitField0_ & 0x00000040) == 0x00000040);
11480     }
11481     /**
11482      * <code>optional double frequency = 7;</code>
11483      */
11484     public double getFrequency() {
11485       return frequency_;
11486     }
11487
11488     // optional string name = 8;
11489     public static final int NAME_FIELD_NUMBER = 8;
11490     private java.lang.Object name_;
11491     /**
11492      * <code>optional string name = 8;</code>
11493      */
11494     public boolean hasName() {
11495       return ((bitField0_ & 0x00000080) == 0x00000080);
11496     }
11497     /**
11498      * <code>optional string name = 8;</code>
11499      */
11500     public java.lang.String getName() {
11501       java.lang.Object ref = name_;
11502       if (ref instanceof java.lang.String) {
11503         return (java.lang.String) ref;
11504       } else {
11505         com.google.protobuf.ByteString bs =
11506             (com.google.protobuf.ByteString) ref;
11507         java.lang.String s = bs.toStringUtf8();
11508         if (bs.isValidUtf8()) {
11509           name_ = s;
11510         }
11511         return s;
11512       }
11513     }
11514     /**
11515      * <code>optional string name = 8;</code>
11516      */
11517     public com.google.protobuf.ByteString
11518         getNameBytes() {
11519       java.lang.Object ref = name_;
11520       if (ref instanceof java.lang.String) {
11521         com.google.protobuf.ByteString b =
11522             com.google.protobuf.ByteString.copyFromUtf8(
11523                 (java.lang.String) ref);
11524         name_ = b;
11525         return b;
11526       } else {
11527         return (com.google.protobuf.ByteString) ref;
11528       }
11529     }
11530
11531     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
11532     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
11533     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
11534     /**
11535      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
11536      */
11537     public boolean hasDecodedType() {
11538       return ((bitField0_ & 0x00000100) == 0x00000100);
11539     }
11540     /**
11541      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
11542      */
11543     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
11544       return decodedType_;
11545     }
11546
11547     private void initFields() {
11548       bus_ = 0;
11549       messageId_ = 0;
11550       mode_ = 0;
11551       pid_ = 0;
11552       payload_ = com.google.protobuf.ByteString.EMPTY;
11553       multipleResponses_ = false;
11554       frequency_ = 0D;
11555       name_ = "";
11556       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
11557     }
11558     private byte memoizedIsInitialized = -1;
11559     public final boolean isInitialized() {
11560       byte isInitialized = memoizedIsInitialized;
11561       if (isInitialized != -1) return isInitialized == 1;
11562
11563       memoizedIsInitialized = 1;
11564       return true;
11565     }
11566
11567     public void writeTo(com.google.protobuf.CodedOutputStream output)
11568                         throws java.io.IOException {
11569       getSerializedSize();
11570       if (((bitField0_ & 0x00000001) == 0x00000001)) {
11571         output.writeInt32(1, bus_);
11572       }
11573       if (((bitField0_ & 0x00000002) == 0x00000002)) {
11574         output.writeUInt32(2, messageId_);
11575       }
11576       if (((bitField0_ & 0x00000004) == 0x00000004)) {
11577         output.writeUInt32(3, mode_);
11578       }
11579       if (((bitField0_ & 0x00000008) == 0x00000008)) {
11580         output.writeUInt32(4, pid_);
11581       }
11582       if (((bitField0_ & 0x00000010) == 0x00000010)) {
11583         output.writeBytes(5, payload_);
11584       }
11585       if (((bitField0_ & 0x00000020) == 0x00000020)) {
11586         output.writeBool(6, multipleResponses_);
11587       }
11588       if (((bitField0_ & 0x00000040) == 0x00000040)) {
11589         output.writeDouble(7, frequency_);
11590       }
11591       if (((bitField0_ & 0x00000080) == 0x00000080)) {
11592         output.writeBytes(8, getNameBytes());
11593       }
11594       if (((bitField0_ & 0x00000100) == 0x00000100)) {
11595         output.writeEnum(9, decodedType_.getNumber());
11596       }
11597       getUnknownFields().writeTo(output);
11598     }
11599
11600     private int memoizedSerializedSize = -1;
11601     public int getSerializedSize() {
11602       int size = memoizedSerializedSize;
11603       if (size != -1) return size;
11604
11605       size = 0;
11606       if (((bitField0_ & 0x00000001) == 0x00000001)) {
11607         size += com.google.protobuf.CodedOutputStream
11608           .computeInt32Size(1, bus_);
11609       }
11610       if (((bitField0_ & 0x00000002) == 0x00000002)) {
11611         size += com.google.protobuf.CodedOutputStream
11612           .computeUInt32Size(2, messageId_);
11613       }
11614       if (((bitField0_ & 0x00000004) == 0x00000004)) {
11615         size += com.google.protobuf.CodedOutputStream
11616           .computeUInt32Size(3, mode_);
11617       }
11618       if (((bitField0_ & 0x00000008) == 0x00000008)) {
11619         size += com.google.protobuf.CodedOutputStream
11620           .computeUInt32Size(4, pid_);
11621       }
11622       if (((bitField0_ & 0x00000010) == 0x00000010)) {
11623         size += com.google.protobuf.CodedOutputStream
11624           .computeBytesSize(5, payload_);
11625       }
11626       if (((bitField0_ & 0x00000020) == 0x00000020)) {
11627         size += com.google.protobuf.CodedOutputStream
11628           .computeBoolSize(6, multipleResponses_);
11629       }
11630       if (((bitField0_ & 0x00000040) == 0x00000040)) {
11631         size += com.google.protobuf.CodedOutputStream
11632           .computeDoubleSize(7, frequency_);
11633       }
11634       if (((bitField0_ & 0x00000080) == 0x00000080)) {
11635         size += com.google.protobuf.CodedOutputStream
11636           .computeBytesSize(8, getNameBytes());
11637       }
11638       if (((bitField0_ & 0x00000100) == 0x00000100)) {
11639         size += com.google.protobuf.CodedOutputStream
11640           .computeEnumSize(9, decodedType_.getNumber());
11641       }
11642       size += getUnknownFields().getSerializedSize();
11643       memoizedSerializedSize = size;
11644       return size;
11645     }
11646
11647     private static final long serialVersionUID = 0L;
11648     @java.lang.Override
11649     protected java.lang.Object writeReplace()
11650         throws java.io.ObjectStreamException {
11651       return super.writeReplace();
11652     }
11653
11654     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
11655         com.google.protobuf.ByteString data)
11656         throws com.google.protobuf.InvalidProtocolBufferException {
11657       return PARSER.parseFrom(data);
11658     }
11659     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
11660         com.google.protobuf.ByteString data,
11661         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11662         throws com.google.protobuf.InvalidProtocolBufferException {
11663       return PARSER.parseFrom(data, extensionRegistry);
11664     }
11665     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
11666         throws com.google.protobuf.InvalidProtocolBufferException {
11667       return PARSER.parseFrom(data);
11668     }
11669     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
11670         byte[] data,
11671         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11672         throws com.google.protobuf.InvalidProtocolBufferException {
11673       return PARSER.parseFrom(data, extensionRegistry);
11674     }
11675     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
11676         throws java.io.IOException {
11677       return PARSER.parseFrom(input);
11678     }
11679     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
11680         java.io.InputStream input,
11681         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11682         throws java.io.IOException {
11683       return PARSER.parseFrom(input, extensionRegistry);
11684     }
11685     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
11686         throws java.io.IOException {
11687       return PARSER.parseDelimitedFrom(input);
11688     }
11689     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
11690         java.io.InputStream input,
11691         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11692         throws java.io.IOException {
11693       return PARSER.parseDelimitedFrom(input, extensionRegistry);
11694     }
11695     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
11696         com.google.protobuf.CodedInputStream input)
11697         throws java.io.IOException {
11698       return PARSER.parseFrom(input);
11699     }
11700     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
11701         com.google.protobuf.CodedInputStream input,
11702         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11703         throws java.io.IOException {
11704       return PARSER.parseFrom(input, extensionRegistry);
11705     }
11706
11707     public static Builder newBuilder() { return Builder.create(); }
11708     public Builder newBuilderForType() { return newBuilder(); }
11709     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
11710       return newBuilder().mergeFrom(prototype);
11711     }
11712     public Builder toBuilder() { return newBuilder(this); }
11713
11714     @java.lang.Override
11715     protected Builder newBuilderForType(
11716         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
11717       Builder builder = new Builder(parent);
11718       return builder;
11719     }
11720     /**
11721      * Protobuf type {@code openxc.DiagnosticRequest}
11722      */
11723     public static final class Builder extends
11724         com.google.protobuf.GeneratedMessage.Builder<Builder>
11725        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
11726       public static final com.google.protobuf.Descriptors.Descriptor
11727           getDescriptor() {
11728         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
11729       }
11730
11731       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
11732           internalGetFieldAccessorTable() {
11733         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
11734             .ensureFieldAccessorsInitialized(
11735                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
11736       }
11737
11738       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
11739       private Builder() {
11740         maybeForceBuilderInitialization();
11741       }
11742
11743       private Builder(
11744           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
11745         super(parent);
11746         maybeForceBuilderInitialization();
11747       }
11748       private void maybeForceBuilderInitialization() {
11749         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
11750         }
11751       }
11752       private static Builder create() {
11753         return new Builder();
11754       }
11755
11756       public Builder clear() {
11757         super.clear();
11758         bus_ = 0;
11759         bitField0_ = (bitField0_ & ~0x00000001);
11760         messageId_ = 0;
11761         bitField0_ = (bitField0_ & ~0x00000002);
11762         mode_ = 0;
11763         bitField0_ = (bitField0_ & ~0x00000004);
11764         pid_ = 0;
11765         bitField0_ = (bitField0_ & ~0x00000008);
11766         payload_ = com.google.protobuf.ByteString.EMPTY;
11767         bitField0_ = (bitField0_ & ~0x00000010);
11768         multipleResponses_ = false;
11769         bitField0_ = (bitField0_ & ~0x00000020);
11770         frequency_ = 0D;
11771         bitField0_ = (bitField0_ & ~0x00000040);
11772         name_ = "";
11773         bitField0_ = (bitField0_ & ~0x00000080);
11774         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
11775         bitField0_ = (bitField0_ & ~0x00000100);
11776         return this;
11777       }
11778
11779       public Builder clone() {
11780         return create().mergeFrom(buildPartial());
11781       }
11782
11783       public com.google.protobuf.Descriptors.Descriptor
11784           getDescriptorForType() {
11785         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
11786       }
11787
11788       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
11789         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
11790       }
11791
11792       public com.openxc.BinaryMessages.DiagnosticRequest build() {
11793         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
11794         if (!result.isInitialized()) {
11795           throw newUninitializedMessageException(result);
11796         }
11797         return result;
11798       }
11799
11800       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
11801         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
11802         int from_bitField0_ = bitField0_;
11803         int to_bitField0_ = 0;
11804         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
11805           to_bitField0_ |= 0x00000001;
11806         }
11807         result.bus_ = bus_;
11808         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
11809           to_bitField0_ |= 0x00000002;
11810         }
11811         result.messageId_ = messageId_;
11812         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
11813           to_bitField0_ |= 0x00000004;
11814         }
11815         result.mode_ = mode_;
11816         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
11817           to_bitField0_ |= 0x00000008;
11818         }
11819         result.pid_ = pid_;
11820         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
11821           to_bitField0_ |= 0x00000010;
11822         }
11823         result.payload_ = payload_;
11824         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
11825           to_bitField0_ |= 0x00000020;
11826         }
11827         result.multipleResponses_ = multipleResponses_;
11828         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
11829           to_bitField0_ |= 0x00000040;
11830         }
11831         result.frequency_ = frequency_;
11832         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
11833           to_bitField0_ |= 0x00000080;
11834         }
11835         result.name_ = name_;
11836         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
11837           to_bitField0_ |= 0x00000100;
11838         }
11839         result.decodedType_ = decodedType_;
11840         result.bitField0_ = to_bitField0_;
11841         onBuilt();
11842         return result;
11843       }
11844
11845       public Builder mergeFrom(com.google.protobuf.Message other) {
11846         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
11847           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
11848         } else {
11849           super.mergeFrom(other);
11850           return this;
11851         }
11852       }
11853
11854       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
11855         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
11856         if (other.hasBus()) {
11857           setBus(other.getBus());
11858         }
11859         if (other.hasMessageId()) {
11860           setMessageId(other.getMessageId());
11861         }
11862         if (other.hasMode()) {
11863           setMode(other.getMode());
11864         }
11865         if (other.hasPid()) {
11866           setPid(other.getPid());
11867         }
11868         if (other.hasPayload()) {
11869           setPayload(other.getPayload());
11870         }
11871         if (other.hasMultipleResponses()) {
11872           setMultipleResponses(other.getMultipleResponses());
11873         }
11874         if (other.hasFrequency()) {
11875           setFrequency(other.getFrequency());
11876         }
11877         if (other.hasName()) {
11878           bitField0_ |= 0x00000080;
11879           name_ = other.name_;
11880           onChanged();
11881         }
11882         if (other.hasDecodedType()) {
11883           setDecodedType(other.getDecodedType());
11884         }
11885         this.mergeUnknownFields(other.getUnknownFields());
11886         return this;
11887       }
11888
11889       public final boolean isInitialized() {
11890         return true;
11891       }
11892
11893       public Builder mergeFrom(
11894           com.google.protobuf.CodedInputStream input,
11895           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11896           throws java.io.IOException {
11897         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
11898         try {
11899           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
11900         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
11901           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
11902           throw e;
11903         } finally {
11904           if (parsedMessage != null) {
11905             mergeFrom(parsedMessage);
11906           }
11907         }
11908         return this;
11909       }
11910       private int bitField0_;
11911
11912       // optional int32 bus = 1;
11913       private int bus_ ;
11914       /**
11915        * <code>optional int32 bus = 1;</code>
11916        */
11917       public boolean hasBus() {
11918         return ((bitField0_ & 0x00000001) == 0x00000001);
11919       }
11920       /**
11921        * <code>optional int32 bus = 1;</code>
11922        */
11923       public int getBus() {
11924         return bus_;
11925       }
11926       /**
11927        * <code>optional int32 bus = 1;</code>
11928        */
11929       public Builder setBus(int value) {
11930         bitField0_ |= 0x00000001;
11931         bus_ = value;
11932         onChanged();
11933         return this;
11934       }
11935       /**
11936        * <code>optional int32 bus = 1;</code>
11937        */
11938       public Builder clearBus() {
11939         bitField0_ = (bitField0_ & ~0x00000001);
11940         bus_ = 0;
11941         onChanged();
11942         return this;
11943       }
11944
11945       // optional uint32 message_id = 2;
11946       private int messageId_ ;
11947       /**
11948        * <code>optional uint32 message_id = 2;</code>
11949        */
11950       public boolean hasMessageId() {
11951         return ((bitField0_ & 0x00000002) == 0x00000002);
11952       }
11953       /**
11954        * <code>optional uint32 message_id = 2;</code>
11955        */
11956       public int getMessageId() {
11957         return messageId_;
11958       }
11959       /**
11960        * <code>optional uint32 message_id = 2;</code>
11961        */
11962       public Builder setMessageId(int value) {
11963         bitField0_ |= 0x00000002;
11964         messageId_ = value;
11965         onChanged();
11966         return this;
11967       }
11968       /**
11969        * <code>optional uint32 message_id = 2;</code>
11970        */
11971       public Builder clearMessageId() {
11972         bitField0_ = (bitField0_ & ~0x00000002);
11973         messageId_ = 0;
11974         onChanged();
11975         return this;
11976       }
11977
11978       // optional uint32 mode = 3;
11979       private int mode_ ;
11980       /**
11981        * <code>optional uint32 mode = 3;</code>
11982        */
11983       public boolean hasMode() {
11984         return ((bitField0_ & 0x00000004) == 0x00000004);
11985       }
11986       /**
11987        * <code>optional uint32 mode = 3;</code>
11988        */
11989       public int getMode() {
11990         return mode_;
11991       }
11992       /**
11993        * <code>optional uint32 mode = 3;</code>
11994        */
11995       public Builder setMode(int value) {
11996         bitField0_ |= 0x00000004;
11997         mode_ = value;
11998         onChanged();
11999         return this;
12000       }
12001       /**
12002        * <code>optional uint32 mode = 3;</code>
12003        */
12004       public Builder clearMode() {
12005         bitField0_ = (bitField0_ & ~0x00000004);
12006         mode_ = 0;
12007         onChanged();
12008         return this;
12009       }
12010
12011       // optional uint32 pid = 4;
12012       private int pid_ ;
12013       /**
12014        * <code>optional uint32 pid = 4;</code>
12015        */
12016       public boolean hasPid() {
12017         return ((bitField0_ & 0x00000008) == 0x00000008);
12018       }
12019       /**
12020        * <code>optional uint32 pid = 4;</code>
12021        */
12022       public int getPid() {
12023         return pid_;
12024       }
12025       /**
12026        * <code>optional uint32 pid = 4;</code>
12027        */
12028       public Builder setPid(int value) {
12029         bitField0_ |= 0x00000008;
12030         pid_ = value;
12031         onChanged();
12032         return this;
12033       }
12034       /**
12035        * <code>optional uint32 pid = 4;</code>
12036        */
12037       public Builder clearPid() {
12038         bitField0_ = (bitField0_ & ~0x00000008);
12039         pid_ = 0;
12040         onChanged();
12041         return this;
12042       }
12043
12044       // optional bytes payload = 5;
12045       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
12046       /**
12047        * <code>optional bytes payload = 5;</code>
12048        *
12049        * <pre>
12050        * TODO we are capping this at 8 bytes for now - need to change when we
12051        * support multi-frame responses
12052        * </pre>
12053        */
12054       public boolean hasPayload() {
12055         return ((bitField0_ & 0x00000010) == 0x00000010);
12056       }
12057       /**
12058        * <code>optional bytes payload = 5;</code>
12059        *
12060        * <pre>
12061        * TODO we are capping this at 8 bytes for now - need to change when we
12062        * support multi-frame responses
12063        * </pre>
12064        */
12065       public com.google.protobuf.ByteString getPayload() {
12066         return payload_;
12067       }
12068       /**
12069        * <code>optional bytes payload = 5;</code>
12070        *
12071        * <pre>
12072        * TODO we are capping this at 8 bytes for now - need to change when we
12073        * support multi-frame responses
12074        * </pre>
12075        */
12076       public Builder setPayload(com.google.protobuf.ByteString value) {
12077         if (value == null) {
12078     throw new NullPointerException();
12079   }
12080   bitField0_ |= 0x00000010;
12081         payload_ = value;
12082         onChanged();
12083         return this;
12084       }
12085       /**
12086        * <code>optional bytes payload = 5;</code>
12087        *
12088        * <pre>
12089        * TODO we are capping this at 8 bytes for now - need to change when we
12090        * support multi-frame responses
12091        * </pre>
12092        */
12093       public Builder clearPayload() {
12094         bitField0_ = (bitField0_ & ~0x00000010);
12095         payload_ = getDefaultInstance().getPayload();
12096         onChanged();
12097         return this;
12098       }
12099
12100       // optional bool multiple_responses = 6;
12101       private boolean multipleResponses_ ;
12102       /**
12103        * <code>optional bool multiple_responses = 6;</code>
12104        */
12105       public boolean hasMultipleResponses() {
12106         return ((bitField0_ & 0x00000020) == 0x00000020);
12107       }
12108       /**
12109        * <code>optional bool multiple_responses = 6;</code>
12110        */
12111       public boolean getMultipleResponses() {
12112         return multipleResponses_;
12113       }
12114       /**
12115        * <code>optional bool multiple_responses = 6;</code>
12116        */
12117       public Builder setMultipleResponses(boolean value) {
12118         bitField0_ |= 0x00000020;
12119         multipleResponses_ = value;
12120         onChanged();
12121         return this;
12122       }
12123       /**
12124        * <code>optional bool multiple_responses = 6;</code>
12125        */
12126       public Builder clearMultipleResponses() {
12127         bitField0_ = (bitField0_ & ~0x00000020);
12128         multipleResponses_ = false;
12129         onChanged();
12130         return this;
12131       }
12132
12133       // optional double frequency = 7;
12134       private double frequency_ ;
12135       /**
12136        * <code>optional double frequency = 7;</code>
12137        */
12138       public boolean hasFrequency() {
12139         return ((bitField0_ & 0x00000040) == 0x00000040);
12140       }
12141       /**
12142        * <code>optional double frequency = 7;</code>
12143        */
12144       public double getFrequency() {
12145         return frequency_;
12146       }
12147       /**
12148        * <code>optional double frequency = 7;</code>
12149        */
12150       public Builder setFrequency(double value) {
12151         bitField0_ |= 0x00000040;
12152         frequency_ = value;
12153         onChanged();
12154         return this;
12155       }
12156       /**
12157        * <code>optional double frequency = 7;</code>
12158        */
12159       public Builder clearFrequency() {
12160         bitField0_ = (bitField0_ & ~0x00000040);
12161         frequency_ = 0D;
12162         onChanged();
12163         return this;
12164       }
12165
12166       // optional string name = 8;
12167       private java.lang.Object name_ = "";
12168       /**
12169        * <code>optional string name = 8;</code>
12170        */
12171       public boolean hasName() {
12172         return ((bitField0_ & 0x00000080) == 0x00000080);
12173       }
12174       /**
12175        * <code>optional string name = 8;</code>
12176        */
12177       public java.lang.String getName() {
12178         java.lang.Object ref = name_;
12179         if (!(ref instanceof java.lang.String)) {
12180           java.lang.String s = ((com.google.protobuf.ByteString) ref)
12181               .toStringUtf8();
12182           name_ = s;
12183           return s;
12184         } else {
12185           return (java.lang.String) ref;
12186         }
12187       }
12188       /**
12189        * <code>optional string name = 8;</code>
12190        */
12191       public com.google.protobuf.ByteString
12192           getNameBytes() {
12193         java.lang.Object ref = name_;
12194         if (ref instanceof String) {
12195           com.google.protobuf.ByteString b =
12196               com.google.protobuf.ByteString.copyFromUtf8(
12197                   (java.lang.String) ref);
12198           name_ = b;
12199           return b;
12200         } else {
12201           return (com.google.protobuf.ByteString) ref;
12202         }
12203       }
12204       /**
12205        * <code>optional string name = 8;</code>
12206        */
12207       public Builder setName(
12208           java.lang.String value) {
12209         if (value == null) {
12210     throw new NullPointerException();
12211   }
12212   bitField0_ |= 0x00000080;
12213         name_ = value;
12214         onChanged();
12215         return this;
12216       }
12217       /**
12218        * <code>optional string name = 8;</code>
12219        */
12220       public Builder clearName() {
12221         bitField0_ = (bitField0_ & ~0x00000080);
12222         name_ = getDefaultInstance().getName();
12223         onChanged();
12224         return this;
12225       }
12226       /**
12227        * <code>optional string name = 8;</code>
12228        */
12229       public Builder setNameBytes(
12230           com.google.protobuf.ByteString value) {
12231         if (value == null) {
12232     throw new NullPointerException();
12233   }
12234   bitField0_ |= 0x00000080;
12235         name_ = value;
12236         onChanged();
12237         return this;
12238       }
12239
12240       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
12241       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
12242       /**
12243        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
12244        */
12245       public boolean hasDecodedType() {
12246         return ((bitField0_ & 0x00000100) == 0x00000100);
12247       }
12248       /**
12249        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
12250        */
12251       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
12252         return decodedType_;
12253       }
12254       /**
12255        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
12256        */
12257       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
12258         if (value == null) {
12259           throw new NullPointerException();
12260         }
12261         bitField0_ |= 0x00000100;
12262         decodedType_ = value;
12263         onChanged();
12264         return this;
12265       }
12266       /**
12267        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
12268        */
12269       public Builder clearDecodedType() {
12270         bitField0_ = (bitField0_ & ~0x00000100);
12271         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
12272         onChanged();
12273         return this;
12274       }
12275
12276       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
12277     }
12278
12279     static {
12280       defaultInstance = new DiagnosticRequest(true);
12281       defaultInstance.initFields();
12282     }
12283
12284     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
12285   }
12286
12287   public interface DiagnosticResponseOrBuilder
12288       extends com.google.protobuf.MessageOrBuilder {
12289
12290     // optional int32 bus = 1;
12291     /**
12292      * <code>optional int32 bus = 1;</code>
12293      */
12294     boolean hasBus();
12295     /**
12296      * <code>optional int32 bus = 1;</code>
12297      */
12298     int getBus();
12299
12300     // optional uint32 message_id = 2;
12301     /**
12302      * <code>optional uint32 message_id = 2;</code>
12303      */
12304     boolean hasMessageId();
12305     /**
12306      * <code>optional uint32 message_id = 2;</code>
12307      */
12308     int getMessageId();
12309
12310     // optional uint32 mode = 3;
12311     /**
12312      * <code>optional uint32 mode = 3;</code>
12313      */
12314     boolean hasMode();
12315     /**
12316      * <code>optional uint32 mode = 3;</code>
12317      */
12318     int getMode();
12319
12320     // optional uint32 pid = 4;
12321     /**
12322      * <code>optional uint32 pid = 4;</code>
12323      */
12324     boolean hasPid();
12325     /**
12326      * <code>optional uint32 pid = 4;</code>
12327      */
12328     int getPid();
12329
12330     // optional bool success = 5;
12331     /**
12332      * <code>optional bool success = 5;</code>
12333      */
12334     boolean hasSuccess();
12335     /**
12336      * <code>optional bool success = 5;</code>
12337      */
12338     boolean getSuccess();
12339
12340     // optional uint32 negative_response_code = 6;
12341     /**
12342      * <code>optional uint32 negative_response_code = 6;</code>
12343      */
12344     boolean hasNegativeResponseCode();
12345     /**
12346      * <code>optional uint32 negative_response_code = 6;</code>
12347      */
12348     int getNegativeResponseCode();
12349
12350     // optional bytes payload = 7;
12351     /**
12352      * <code>optional bytes payload = 7;</code>
12353      *
12354      * <pre>
12355      * TODO we are capping this at 8 bytes for now - need to change when we
12356      * support multi-frame responses
12357      * </pre>
12358      */
12359     boolean hasPayload();
12360     /**
12361      * <code>optional bytes payload = 7;</code>
12362      *
12363      * <pre>
12364      * TODO we are capping this at 8 bytes for now - need to change when we
12365      * support multi-frame responses
12366      * </pre>
12367      */
12368     com.google.protobuf.ByteString getPayload();
12369
12370     // optional double value = 8;
12371     /**
12372      * <code>optional double value = 8;</code>
12373      */
12374     boolean hasValue();
12375     /**
12376      * <code>optional double value = 8;</code>
12377      */
12378     double getValue();
12379   }
12380   /**
12381    * Protobuf type {@code openxc.DiagnosticResponse}
12382    */
12383   public static final class DiagnosticResponse extends
12384       com.google.protobuf.GeneratedMessage
12385       implements DiagnosticResponseOrBuilder {
12386     // Use DiagnosticResponse.newBuilder() to construct.
12387     private DiagnosticResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
12388       super(builder);
12389       this.unknownFields = builder.getUnknownFields();
12390     }
12391     private DiagnosticResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
12392
12393     private static final DiagnosticResponse defaultInstance;
12394     public static DiagnosticResponse getDefaultInstance() {
12395       return defaultInstance;
12396     }
12397
12398     public DiagnosticResponse getDefaultInstanceForType() {
12399       return defaultInstance;
12400     }
12401
12402     private final com.google.protobuf.UnknownFieldSet unknownFields;
12403     @java.lang.Override
12404     public final com.google.protobuf.UnknownFieldSet
12405         getUnknownFields() {
12406       return this.unknownFields;
12407     }
12408     private DiagnosticResponse(
12409         com.google.protobuf.CodedInputStream input,
12410         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12411         throws com.google.protobuf.InvalidProtocolBufferException {
12412       initFields();
12413       int mutable_bitField0_ = 0;
12414       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
12415           com.google.protobuf.UnknownFieldSet.newBuilder();
12416       try {
12417         boolean done = false;
12418         while (!done) {
12419           int tag = input.readTag();
12420           switch (tag) {
12421             case 0:
12422               done = true;
12423               break;
12424             default: {
12425               if (!parseUnknownField(input, unknownFields,
12426                                      extensionRegistry, tag)) {
12427                 done = true;
12428               }
12429               break;
12430             }
12431             case 8: {
12432               bitField0_ |= 0x00000001;
12433               bus_ = input.readInt32();
12434               break;
12435             }
12436             case 16: {
12437               bitField0_ |= 0x00000002;
12438               messageId_ = input.readUInt32();
12439               break;
12440             }
12441             case 24: {
12442               bitField0_ |= 0x00000004;
12443               mode_ = input.readUInt32();
12444               break;
12445             }
12446             case 32: {
12447               bitField0_ |= 0x00000008;
12448               pid_ = input.readUInt32();
12449               break;
12450             }
12451             case 40: {
12452               bitField0_ |= 0x00000010;
12453               success_ = input.readBool();
12454               break;
12455             }
12456             case 48: {
12457               bitField0_ |= 0x00000020;
12458               negativeResponseCode_ = input.readUInt32();
12459               break;
12460             }
12461             case 58: {
12462               bitField0_ |= 0x00000040;
12463               payload_ = input.readBytes();
12464               break;
12465             }
12466             case 65: {
12467               bitField0_ |= 0x00000080;
12468               value_ = input.readDouble();
12469               break;
12470             }
12471           }
12472         }
12473       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
12474         throw e.setUnfinishedMessage(this);
12475       } catch (java.io.IOException e) {
12476         throw new com.google.protobuf.InvalidProtocolBufferException(
12477             e.getMessage()).setUnfinishedMessage(this);
12478       } finally {
12479         this.unknownFields = unknownFields.build();
12480         makeExtensionsImmutable();
12481       }
12482     }
12483     public static final com.google.protobuf.Descriptors.Descriptor
12484         getDescriptor() {
12485       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
12486     }
12487
12488     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
12489         internalGetFieldAccessorTable() {
12490       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
12491           .ensureFieldAccessorsInitialized(
12492               com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
12493     }
12494
12495     public static com.google.protobuf.Parser<DiagnosticResponse> PARSER =
12496         new com.google.protobuf.AbstractParser<DiagnosticResponse>() {
12497       public DiagnosticResponse parsePartialFrom(
12498           com.google.protobuf.CodedInputStream input,
12499           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12500           throws com.google.protobuf.InvalidProtocolBufferException {
12501         return new DiagnosticResponse(input, extensionRegistry);
12502       }
12503     };
12504
12505     @java.lang.Override
12506     public com.google.protobuf.Parser<DiagnosticResponse> getParserForType() {
12507       return PARSER;
12508     }
12509
12510     private int bitField0_;
12511     // optional int32 bus = 1;
12512     public static final int BUS_FIELD_NUMBER = 1;
12513     private int bus_;
12514     /**
12515      * <code>optional int32 bus = 1;</code>
12516      */
12517     public boolean hasBus() {
12518       return ((bitField0_ & 0x00000001) == 0x00000001);
12519     }
12520     /**
12521      * <code>optional int32 bus = 1;</code>
12522      */
12523     public int getBus() {
12524       return bus_;
12525     }
12526
12527     // optional uint32 message_id = 2;
12528     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
12529     private int messageId_;
12530     /**
12531      * <code>optional uint32 message_id = 2;</code>
12532      */
12533     public boolean hasMessageId() {
12534       return ((bitField0_ & 0x00000002) == 0x00000002);
12535     }
12536     /**
12537      * <code>optional uint32 message_id = 2;</code>
12538      */
12539     public int getMessageId() {
12540       return messageId_;
12541     }
12542
12543     // optional uint32 mode = 3;
12544     public static final int MODE_FIELD_NUMBER = 3;
12545     private int mode_;
12546     /**
12547      * <code>optional uint32 mode = 3;</code>
12548      */
12549     public boolean hasMode() {
12550       return ((bitField0_ & 0x00000004) == 0x00000004);
12551     }
12552     /**
12553      * <code>optional uint32 mode = 3;</code>
12554      */
12555     public int getMode() {
12556       return mode_;
12557     }
12558
12559     // optional uint32 pid = 4;
12560     public static final int PID_FIELD_NUMBER = 4;
12561     private int pid_;
12562     /**
12563      * <code>optional uint32 pid = 4;</code>
12564      */
12565     public boolean hasPid() {
12566       return ((bitField0_ & 0x00000008) == 0x00000008);
12567     }
12568     /**
12569      * <code>optional uint32 pid = 4;</code>
12570      */
12571     public int getPid() {
12572       return pid_;
12573     }
12574
12575     // optional bool success = 5;
12576     public static final int SUCCESS_FIELD_NUMBER = 5;
12577     private boolean success_;
12578     /**
12579      * <code>optional bool success = 5;</code>
12580      */
12581     public boolean hasSuccess() {
12582       return ((bitField0_ & 0x00000010) == 0x00000010);
12583     }
12584     /**
12585      * <code>optional bool success = 5;</code>
12586      */
12587     public boolean getSuccess() {
12588       return success_;
12589     }
12590
12591     // optional uint32 negative_response_code = 6;
12592     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
12593     private int negativeResponseCode_;
12594     /**
12595      * <code>optional uint32 negative_response_code = 6;</code>
12596      */
12597     public boolean hasNegativeResponseCode() {
12598       return ((bitField0_ & 0x00000020) == 0x00000020);
12599     }
12600     /**
12601      * <code>optional uint32 negative_response_code = 6;</code>
12602      */
12603     public int getNegativeResponseCode() {
12604       return negativeResponseCode_;
12605     }
12606
12607     // optional bytes payload = 7;
12608     public static final int PAYLOAD_FIELD_NUMBER = 7;
12609     private com.google.protobuf.ByteString payload_;
12610     /**
12611      * <code>optional bytes payload = 7;</code>
12612      *
12613      * <pre>
12614      * TODO we are capping this at 8 bytes for now - need to change when we
12615      * support multi-frame responses
12616      * </pre>
12617      */
12618     public boolean hasPayload() {
12619       return ((bitField0_ & 0x00000040) == 0x00000040);
12620     }
12621     /**
12622      * <code>optional bytes payload = 7;</code>
12623      *
12624      * <pre>
12625      * TODO we are capping this at 8 bytes for now - need to change when we
12626      * support multi-frame responses
12627      * </pre>
12628      */
12629     public com.google.protobuf.ByteString getPayload() {
12630       return payload_;
12631     }
12632
12633     // optional double value = 8;
12634     public static final int VALUE_FIELD_NUMBER = 8;
12635     private double value_;
12636     /**
12637      * <code>optional double value = 8;</code>
12638      */
12639     public boolean hasValue() {
12640       return ((bitField0_ & 0x00000080) == 0x00000080);
12641     }
12642     /**
12643      * <code>optional double value = 8;</code>
12644      */
12645     public double getValue() {
12646       return value_;
12647     }
12648
12649     private void initFields() {
12650       bus_ = 0;
12651       messageId_ = 0;
12652       mode_ = 0;
12653       pid_ = 0;
12654       success_ = false;
12655       negativeResponseCode_ = 0;
12656       payload_ = com.google.protobuf.ByteString.EMPTY;
12657       value_ = 0D;
12658     }
12659     private byte memoizedIsInitialized = -1;
12660     public final boolean isInitialized() {
12661       byte isInitialized = memoizedIsInitialized;
12662       if (isInitialized != -1) return isInitialized == 1;
12663
12664       memoizedIsInitialized = 1;
12665       return true;
12666     }
12667
12668     public void writeTo(com.google.protobuf.CodedOutputStream output)
12669                         throws java.io.IOException {
12670       getSerializedSize();
12671       if (((bitField0_ & 0x00000001) == 0x00000001)) {
12672         output.writeInt32(1, bus_);
12673       }
12674       if (((bitField0_ & 0x00000002) == 0x00000002)) {
12675         output.writeUInt32(2, messageId_);
12676       }
12677       if (((bitField0_ & 0x00000004) == 0x00000004)) {
12678         output.writeUInt32(3, mode_);
12679       }
12680       if (((bitField0_ & 0x00000008) == 0x00000008)) {
12681         output.writeUInt32(4, pid_);
12682       }
12683       if (((bitField0_ & 0x00000010) == 0x00000010)) {
12684         output.writeBool(5, success_);
12685       }
12686       if (((bitField0_ & 0x00000020) == 0x00000020)) {
12687         output.writeUInt32(6, negativeResponseCode_);
12688       }
12689       if (((bitField0_ & 0x00000040) == 0x00000040)) {
12690         output.writeBytes(7, payload_);
12691       }
12692       if (((bitField0_ & 0x00000080) == 0x00000080)) {
12693         output.writeDouble(8, value_);
12694       }
12695       getUnknownFields().writeTo(output);
12696     }
12697
12698     private int memoizedSerializedSize = -1;
12699     public int getSerializedSize() {
12700       int size = memoizedSerializedSize;
12701       if (size != -1) return size;
12702
12703       size = 0;
12704       if (((bitField0_ & 0x00000001) == 0x00000001)) {
12705         size += com.google.protobuf.CodedOutputStream
12706           .computeInt32Size(1, bus_);
12707       }
12708       if (((bitField0_ & 0x00000002) == 0x00000002)) {
12709         size += com.google.protobuf.CodedOutputStream
12710           .computeUInt32Size(2, messageId_);
12711       }
12712       if (((bitField0_ & 0x00000004) == 0x00000004)) {
12713         size += com.google.protobuf.CodedOutputStream
12714           .computeUInt32Size(3, mode_);
12715       }
12716       if (((bitField0_ & 0x00000008) == 0x00000008)) {
12717         size += com.google.protobuf.CodedOutputStream
12718           .computeUInt32Size(4, pid_);
12719       }
12720       if (((bitField0_ & 0x00000010) == 0x00000010)) {
12721         size += com.google.protobuf.CodedOutputStream
12722           .computeBoolSize(5, success_);
12723       }
12724       if (((bitField0_ & 0x00000020) == 0x00000020)) {
12725         size += com.google.protobuf.CodedOutputStream
12726           .computeUInt32Size(6, negativeResponseCode_);
12727       }
12728       if (((bitField0_ & 0x00000040) == 0x00000040)) {
12729         size += com.google.protobuf.CodedOutputStream
12730           .computeBytesSize(7, payload_);
12731       }
12732       if (((bitField0_ & 0x00000080) == 0x00000080)) {
12733         size += com.google.protobuf.CodedOutputStream
12734           .computeDoubleSize(8, value_);
12735       }
12736       size += getUnknownFields().getSerializedSize();
12737       memoizedSerializedSize = size;
12738       return size;
12739     }
12740
12741     private static final long serialVersionUID = 0L;
12742     @java.lang.Override
12743     protected java.lang.Object writeReplace()
12744         throws java.io.ObjectStreamException {
12745       return super.writeReplace();
12746     }
12747
12748     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
12749         com.google.protobuf.ByteString data)
12750         throws com.google.protobuf.InvalidProtocolBufferException {
12751       return PARSER.parseFrom(data);
12752     }
12753     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
12754         com.google.protobuf.ByteString data,
12755         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12756         throws com.google.protobuf.InvalidProtocolBufferException {
12757       return PARSER.parseFrom(data, extensionRegistry);
12758     }
12759     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
12760         throws com.google.protobuf.InvalidProtocolBufferException {
12761       return PARSER.parseFrom(data);
12762     }
12763     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
12764         byte[] data,
12765         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12766         throws com.google.protobuf.InvalidProtocolBufferException {
12767       return PARSER.parseFrom(data, extensionRegistry);
12768     }
12769     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
12770         throws java.io.IOException {
12771       return PARSER.parseFrom(input);
12772     }
12773     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
12774         java.io.InputStream input,
12775         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12776         throws java.io.IOException {
12777       return PARSER.parseFrom(input, extensionRegistry);
12778     }
12779     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
12780         throws java.io.IOException {
12781       return PARSER.parseDelimitedFrom(input);
12782     }
12783     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
12784         java.io.InputStream input,
12785         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12786         throws java.io.IOException {
12787       return PARSER.parseDelimitedFrom(input, extensionRegistry);
12788     }
12789     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
12790         com.google.protobuf.CodedInputStream input)
12791         throws java.io.IOException {
12792       return PARSER.parseFrom(input);
12793     }
12794     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
12795         com.google.protobuf.CodedInputStream input,
12796         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12797         throws java.io.IOException {
12798       return PARSER.parseFrom(input, extensionRegistry);
12799     }
12800
12801     public static Builder newBuilder() { return Builder.create(); }
12802     public Builder newBuilderForType() { return newBuilder(); }
12803     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
12804       return newBuilder().mergeFrom(prototype);
12805     }
12806     public Builder toBuilder() { return newBuilder(this); }
12807
12808     @java.lang.Override
12809     protected Builder newBuilderForType(
12810         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
12811       Builder builder = new Builder(parent);
12812       return builder;
12813     }
12814     /**
12815      * Protobuf type {@code openxc.DiagnosticResponse}
12816      */
12817     public static final class Builder extends
12818         com.google.protobuf.GeneratedMessage.Builder<Builder>
12819        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
12820       public static final com.google.protobuf.Descriptors.Descriptor
12821           getDescriptor() {
12822         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
12823       }
12824
12825       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
12826           internalGetFieldAccessorTable() {
12827         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
12828             .ensureFieldAccessorsInitialized(
12829                 com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
12830       }
12831
12832       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
12833       private Builder() {
12834         maybeForceBuilderInitialization();
12835       }
12836
12837       private Builder(
12838           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
12839         super(parent);
12840         maybeForceBuilderInitialization();
12841       }
12842       private void maybeForceBuilderInitialization() {
12843         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
12844         }
12845       }
12846       private static Builder create() {
12847         return new Builder();
12848       }
12849
12850       public Builder clear() {
12851         super.clear();
12852         bus_ = 0;
12853         bitField0_ = (bitField0_ & ~0x00000001);
12854         messageId_ = 0;
12855         bitField0_ = (bitField0_ & ~0x00000002);
12856         mode_ = 0;
12857         bitField0_ = (bitField0_ & ~0x00000004);
12858         pid_ = 0;
12859         bitField0_ = (bitField0_ & ~0x00000008);
12860         success_ = false;
12861         bitField0_ = (bitField0_ & ~0x00000010);
12862         negativeResponseCode_ = 0;
12863         bitField0_ = (bitField0_ & ~0x00000020);
12864         payload_ = com.google.protobuf.ByteString.EMPTY;
12865         bitField0_ = (bitField0_ & ~0x00000040);
12866         value_ = 0D;
12867         bitField0_ = (bitField0_ & ~0x00000080);
12868         return this;
12869       }
12870
12871       public Builder clone() {
12872         return create().mergeFrom(buildPartial());
12873       }
12874
12875       public com.google.protobuf.Descriptors.Descriptor
12876           getDescriptorForType() {
12877         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
12878       }
12879
12880       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
12881         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
12882       }
12883
12884       public com.openxc.BinaryMessages.DiagnosticResponse build() {
12885         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
12886         if (!result.isInitialized()) {
12887           throw newUninitializedMessageException(result);
12888         }
12889         return result;
12890       }
12891
12892       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
12893         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
12894         int from_bitField0_ = bitField0_;
12895         int to_bitField0_ = 0;
12896         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
12897           to_bitField0_ |= 0x00000001;
12898         }
12899         result.bus_ = bus_;
12900         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
12901           to_bitField0_ |= 0x00000002;
12902         }
12903         result.messageId_ = messageId_;
12904         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
12905           to_bitField0_ |= 0x00000004;
12906         }
12907         result.mode_ = mode_;
12908         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
12909           to_bitField0_ |= 0x00000008;
12910         }
12911         result.pid_ = pid_;
12912         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
12913           to_bitField0_ |= 0x00000010;
12914         }
12915         result.success_ = success_;
12916         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
12917           to_bitField0_ |= 0x00000020;
12918         }
12919         result.negativeResponseCode_ = negativeResponseCode_;
12920         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
12921           to_bitField0_ |= 0x00000040;
12922         }
12923         result.payload_ = payload_;
12924         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
12925           to_bitField0_ |= 0x00000080;
12926         }
12927         result.value_ = value_;
12928         result.bitField0_ = to_bitField0_;
12929         onBuilt();
12930         return result;
12931       }
12932
12933       public Builder mergeFrom(com.google.protobuf.Message other) {
12934         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
12935           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
12936         } else {
12937           super.mergeFrom(other);
12938           return this;
12939         }
12940       }
12941
12942       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
12943         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
12944         if (other.hasBus()) {
12945           setBus(other.getBus());
12946         }
12947         if (other.hasMessageId()) {
12948           setMessageId(other.getMessageId());
12949         }
12950         if (other.hasMode()) {
12951           setMode(other.getMode());
12952         }
12953         if (other.hasPid()) {
12954           setPid(other.getPid());
12955         }
12956         if (other.hasSuccess()) {
12957           setSuccess(other.getSuccess());
12958         }
12959         if (other.hasNegativeResponseCode()) {
12960           setNegativeResponseCode(other.getNegativeResponseCode());
12961         }
12962         if (other.hasPayload()) {
12963           setPayload(other.getPayload());
12964         }
12965         if (other.hasValue()) {
12966           setValue(other.getValue());
12967         }
12968         this.mergeUnknownFields(other.getUnknownFields());
12969         return this;
12970       }
12971
12972       public final boolean isInitialized() {
12973         return true;
12974       }
12975
12976       public Builder mergeFrom(
12977           com.google.protobuf.CodedInputStream input,
12978           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
12979           throws java.io.IOException {
12980         com.openxc.BinaryMessages.DiagnosticResponse parsedMessage = null;
12981         try {
12982           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
12983         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
12984           parsedMessage = (com.openxc.BinaryMessages.DiagnosticResponse) e.getUnfinishedMessage();
12985           throw e;
12986         } finally {
12987           if (parsedMessage != null) {
12988             mergeFrom(parsedMessage);
12989           }
12990         }
12991         return this;
12992       }
12993       private int bitField0_;
12994
12995       // optional int32 bus = 1;
12996       private int bus_ ;
12997       /**
12998        * <code>optional int32 bus = 1;</code>
12999        */
13000       public boolean hasBus() {
13001         return ((bitField0_ & 0x00000001) == 0x00000001);
13002       }
13003       /**
13004        * <code>optional int32 bus = 1;</code>
13005        */
13006       public int getBus() {
13007         return bus_;
13008       }
13009       /**
13010        * <code>optional int32 bus = 1;</code>
13011        */
13012       public Builder setBus(int value) {
13013         bitField0_ |= 0x00000001;
13014         bus_ = value;
13015         onChanged();
13016         return this;
13017       }
13018       /**
13019        * <code>optional int32 bus = 1;</code>
13020        */
13021       public Builder clearBus() {
13022         bitField0_ = (bitField0_ & ~0x00000001);
13023         bus_ = 0;
13024         onChanged();
13025         return this;
13026       }
13027
13028       // optional uint32 message_id = 2;
13029       private int messageId_ ;
13030       /**
13031        * <code>optional uint32 message_id = 2;</code>
13032        */
13033       public boolean hasMessageId() {
13034         return ((bitField0_ & 0x00000002) == 0x00000002);
13035       }
13036       /**
13037        * <code>optional uint32 message_id = 2;</code>
13038        */
13039       public int getMessageId() {
13040         return messageId_;
13041       }
13042       /**
13043        * <code>optional uint32 message_id = 2;</code>
13044        */
13045       public Builder setMessageId(int value) {
13046         bitField0_ |= 0x00000002;
13047         messageId_ = value;
13048         onChanged();
13049         return this;
13050       }
13051       /**
13052        * <code>optional uint32 message_id = 2;</code>
13053        */
13054       public Builder clearMessageId() {
13055         bitField0_ = (bitField0_ & ~0x00000002);
13056         messageId_ = 0;
13057         onChanged();
13058         return this;
13059       }
13060
13061       // optional uint32 mode = 3;
13062       private int mode_ ;
13063       /**
13064        * <code>optional uint32 mode = 3;</code>
13065        */
13066       public boolean hasMode() {
13067         return ((bitField0_ & 0x00000004) == 0x00000004);
13068       }
13069       /**
13070        * <code>optional uint32 mode = 3;</code>
13071        */
13072       public int getMode() {
13073         return mode_;
13074       }
13075       /**
13076        * <code>optional uint32 mode = 3;</code>
13077        */
13078       public Builder setMode(int value) {
13079         bitField0_ |= 0x00000004;
13080         mode_ = value;
13081         onChanged();
13082         return this;
13083       }
13084       /**
13085        * <code>optional uint32 mode = 3;</code>
13086        */
13087       public Builder clearMode() {
13088         bitField0_ = (bitField0_ & ~0x00000004);
13089         mode_ = 0;
13090         onChanged();
13091         return this;
13092       }
13093
13094       // optional uint32 pid = 4;
13095       private int pid_ ;
13096       /**
13097        * <code>optional uint32 pid = 4;</code>
13098        */
13099       public boolean hasPid() {
13100         return ((bitField0_ & 0x00000008) == 0x00000008);
13101       }
13102       /**
13103        * <code>optional uint32 pid = 4;</code>
13104        */
13105       public int getPid() {
13106         return pid_;
13107       }
13108       /**
13109        * <code>optional uint32 pid = 4;</code>
13110        */
13111       public Builder setPid(int value) {
13112         bitField0_ |= 0x00000008;
13113         pid_ = value;
13114         onChanged();
13115         return this;
13116       }
13117       /**
13118        * <code>optional uint32 pid = 4;</code>
13119        */
13120       public Builder clearPid() {
13121         bitField0_ = (bitField0_ & ~0x00000008);
13122         pid_ = 0;
13123         onChanged();
13124         return this;
13125       }
13126
13127       // optional bool success = 5;
13128       private boolean success_ ;
13129       /**
13130        * <code>optional bool success = 5;</code>
13131        */
13132       public boolean hasSuccess() {
13133         return ((bitField0_ & 0x00000010) == 0x00000010);
13134       }
13135       /**
13136        * <code>optional bool success = 5;</code>
13137        */
13138       public boolean getSuccess() {
13139         return success_;
13140       }
13141       /**
13142        * <code>optional bool success = 5;</code>
13143        */
13144       public Builder setSuccess(boolean value) {
13145         bitField0_ |= 0x00000010;
13146         success_ = value;
13147         onChanged();
13148         return this;
13149       }
13150       /**
13151        * <code>optional bool success = 5;</code>
13152        */
13153       public Builder clearSuccess() {
13154         bitField0_ = (bitField0_ & ~0x00000010);
13155         success_ = false;
13156         onChanged();
13157         return this;
13158       }
13159
13160       // optional uint32 negative_response_code = 6;
13161       private int negativeResponseCode_ ;
13162       /**
13163        * <code>optional uint32 negative_response_code = 6;</code>
13164        */
13165       public boolean hasNegativeResponseCode() {
13166         return ((bitField0_ & 0x00000020) == 0x00000020);
13167       }
13168       /**
13169        * <code>optional uint32 negative_response_code = 6;</code>
13170        */
13171       public int getNegativeResponseCode() {
13172         return negativeResponseCode_;
13173       }
13174       /**
13175        * <code>optional uint32 negative_response_code = 6;</code>
13176        */
13177       public Builder setNegativeResponseCode(int value) {
13178         bitField0_ |= 0x00000020;
13179         negativeResponseCode_ = value;
13180         onChanged();
13181         return this;
13182       }
13183       /**
13184        * <code>optional uint32 negative_response_code = 6;</code>
13185        */
13186       public Builder clearNegativeResponseCode() {
13187         bitField0_ = (bitField0_ & ~0x00000020);
13188         negativeResponseCode_ = 0;
13189         onChanged();
13190         return this;
13191       }
13192
13193       // optional bytes payload = 7;
13194       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
13195       /**
13196        * <code>optional bytes payload = 7;</code>
13197        *
13198        * <pre>
13199        * TODO we are capping this at 8 bytes for now - need to change when we
13200        * support multi-frame responses
13201        * </pre>
13202        */
13203       public boolean hasPayload() {
13204         return ((bitField0_ & 0x00000040) == 0x00000040);
13205       }
13206       /**
13207        * <code>optional bytes payload = 7;</code>
13208        *
13209        * <pre>
13210        * TODO we are capping this at 8 bytes for now - need to change when we
13211        * support multi-frame responses
13212        * </pre>
13213        */
13214       public com.google.protobuf.ByteString getPayload() {
13215         return payload_;
13216       }
13217       /**
13218        * <code>optional bytes payload = 7;</code>
13219        *
13220        * <pre>
13221        * TODO we are capping this at 8 bytes for now - need to change when we
13222        * support multi-frame responses
13223        * </pre>
13224        */
13225       public Builder setPayload(com.google.protobuf.ByteString value) {
13226         if (value == null) {
13227     throw new NullPointerException();
13228   }
13229   bitField0_ |= 0x00000040;
13230         payload_ = value;
13231         onChanged();
13232         return this;
13233       }
13234       /**
13235        * <code>optional bytes payload = 7;</code>
13236        *
13237        * <pre>
13238        * TODO we are capping this at 8 bytes for now - need to change when we
13239        * support multi-frame responses
13240        * </pre>
13241        */
13242       public Builder clearPayload() {
13243         bitField0_ = (bitField0_ & ~0x00000040);
13244         payload_ = getDefaultInstance().getPayload();
13245         onChanged();
13246         return this;
13247       }
13248
13249       // optional double value = 8;
13250       private double value_ ;
13251       /**
13252        * <code>optional double value = 8;</code>
13253        */
13254       public boolean hasValue() {
13255         return ((bitField0_ & 0x00000080) == 0x00000080);
13256       }
13257       /**
13258        * <code>optional double value = 8;</code>
13259        */
13260       public double getValue() {
13261         return value_;
13262       }
13263       /**
13264        * <code>optional double value = 8;</code>
13265        */
13266       public Builder setValue(double value) {
13267         bitField0_ |= 0x00000080;
13268         value_ = value;
13269         onChanged();
13270         return this;
13271       }
13272       /**
13273        * <code>optional double value = 8;</code>
13274        */
13275       public Builder clearValue() {
13276         bitField0_ = (bitField0_ & ~0x00000080);
13277         value_ = 0D;
13278         onChanged();
13279         return this;
13280       }
13281
13282       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
13283     }
13284
13285     static {
13286       defaultInstance = new DiagnosticResponse(true);
13287       defaultInstance.initFields();
13288     }
13289
13290     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
13291   }
13292
13293   public interface DynamicFieldOrBuilder
13294       extends com.google.protobuf.MessageOrBuilder {
13295
13296     // optional .openxc.DynamicField.Type type = 1;
13297     /**
13298      * <code>optional .openxc.DynamicField.Type type = 1;</code>
13299      */
13300     boolean hasType();
13301     /**
13302      * <code>optional .openxc.DynamicField.Type type = 1;</code>
13303      */
13304     com.openxc.BinaryMessages.DynamicField.Type getType();
13305
13306     // optional string string_value = 2;
13307     /**
13308      * <code>optional string string_value = 2;</code>
13309      */
13310     boolean hasStringValue();
13311     /**
13312      * <code>optional string string_value = 2;</code>
13313      */
13314     java.lang.String getStringValue();
13315     /**
13316      * <code>optional string string_value = 2;</code>
13317      */
13318     com.google.protobuf.ByteString
13319         getStringValueBytes();
13320
13321     // optional double numeric_value = 3;
13322     /**
13323      * <code>optional double numeric_value = 3;</code>
13324      */
13325     boolean hasNumericValue();
13326     /**
13327      * <code>optional double numeric_value = 3;</code>
13328      */
13329     double getNumericValue();
13330
13331     // optional bool boolean_value = 4;
13332     /**
13333      * <code>optional bool boolean_value = 4;</code>
13334      */
13335     boolean hasBooleanValue();
13336     /**
13337      * <code>optional bool boolean_value = 4;</code>
13338      */
13339     boolean getBooleanValue();
13340   }
13341   /**
13342    * Protobuf type {@code openxc.DynamicField}
13343    */
13344   public static final class DynamicField extends
13345       com.google.protobuf.GeneratedMessage
13346       implements DynamicFieldOrBuilder {
13347     // Use DynamicField.newBuilder() to construct.
13348     private DynamicField(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
13349       super(builder);
13350       this.unknownFields = builder.getUnknownFields();
13351     }
13352     private DynamicField(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
13353
13354     private static final DynamicField defaultInstance;
13355     public static DynamicField getDefaultInstance() {
13356       return defaultInstance;
13357     }
13358
13359     public DynamicField getDefaultInstanceForType() {
13360       return defaultInstance;
13361     }
13362
13363     private final com.google.protobuf.UnknownFieldSet unknownFields;
13364     @java.lang.Override
13365     public final com.google.protobuf.UnknownFieldSet
13366         getUnknownFields() {
13367       return this.unknownFields;
13368     }
13369     private DynamicField(
13370         com.google.protobuf.CodedInputStream input,
13371         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13372         throws com.google.protobuf.InvalidProtocolBufferException {
13373       initFields();
13374       int mutable_bitField0_ = 0;
13375       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
13376           com.google.protobuf.UnknownFieldSet.newBuilder();
13377       try {
13378         boolean done = false;
13379         while (!done) {
13380           int tag = input.readTag();
13381           switch (tag) {
13382             case 0:
13383               done = true;
13384               break;
13385             default: {
13386               if (!parseUnknownField(input, unknownFields,
13387                                      extensionRegistry, tag)) {
13388                 done = true;
13389               }
13390               break;
13391             }
13392             case 8: {
13393               int rawValue = input.readEnum();
13394               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
13395               if (value == null) {
13396                 unknownFields.mergeVarintField(1, rawValue);
13397               } else {
13398                 bitField0_ |= 0x00000001;
13399                 type_ = value;
13400               }
13401               break;
13402             }
13403             case 18: {
13404               bitField0_ |= 0x00000002;
13405               stringValue_ = input.readBytes();
13406               break;
13407             }
13408             case 25: {
13409               bitField0_ |= 0x00000004;
13410               numericValue_ = input.readDouble();
13411               break;
13412             }
13413             case 32: {
13414               bitField0_ |= 0x00000008;
13415               booleanValue_ = input.readBool();
13416               break;
13417             }
13418           }
13419         }
13420       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
13421         throw e.setUnfinishedMessage(this);
13422       } catch (java.io.IOException e) {
13423         throw new com.google.protobuf.InvalidProtocolBufferException(
13424             e.getMessage()).setUnfinishedMessage(this);
13425       } finally {
13426         this.unknownFields = unknownFields.build();
13427         makeExtensionsImmutable();
13428       }
13429     }
13430     public static final com.google.protobuf.Descriptors.Descriptor
13431         getDescriptor() {
13432       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
13433     }
13434
13435     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
13436         internalGetFieldAccessorTable() {
13437       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
13438           .ensureFieldAccessorsInitialized(
13439               com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
13440     }
13441
13442     public static com.google.protobuf.Parser<DynamicField> PARSER =
13443         new com.google.protobuf.AbstractParser<DynamicField>() {
13444       public DynamicField parsePartialFrom(
13445           com.google.protobuf.CodedInputStream input,
13446           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13447           throws com.google.protobuf.InvalidProtocolBufferException {
13448         return new DynamicField(input, extensionRegistry);
13449       }
13450     };
13451
13452     @java.lang.Override
13453     public com.google.protobuf.Parser<DynamicField> getParserForType() {
13454       return PARSER;
13455     }
13456
13457     /**
13458      * Protobuf enum {@code openxc.DynamicField.Type}
13459      */
13460     public enum Type
13461         implements com.google.protobuf.ProtocolMessageEnum {
13462       /**
13463        * <code>STRING = 1;</code>
13464        */
13465       STRING(0, 1),
13466       /**
13467        * <code>NUM = 2;</code>
13468        */
13469       NUM(1, 2),
13470       /**
13471        * <code>BOOL = 3;</code>
13472        */
13473       BOOL(2, 3),
13474       ;
13475
13476       /**
13477        * <code>STRING = 1;</code>
13478        */
13479       public static final int STRING_VALUE = 1;
13480       /**
13481        * <code>NUM = 2;</code>
13482        */
13483       public static final int NUM_VALUE = 2;
13484       /**
13485        * <code>BOOL = 3;</code>
13486        */
13487       public static final int BOOL_VALUE = 3;
13488
13489
13490       public final int getNumber() { return value; }
13491
13492       public static Type valueOf(int value) {
13493         switch (value) {
13494           case 1: return STRING;
13495           case 2: return NUM;
13496           case 3: return BOOL;
13497           default: return null;
13498         }
13499       }
13500
13501       public static com.google.protobuf.Internal.EnumLiteMap<Type>
13502           internalGetValueMap() {
13503         return internalValueMap;
13504       }
13505       private static com.google.protobuf.Internal.EnumLiteMap<Type>
13506           internalValueMap =
13507             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
13508               public Type findValueByNumber(int number) {
13509                 return Type.valueOf(number);
13510               }
13511             };
13512
13513       public final com.google.protobuf.Descriptors.EnumValueDescriptor
13514           getValueDescriptor() {
13515         return getDescriptor().getValues().get(index);
13516       }
13517       public final com.google.protobuf.Descriptors.EnumDescriptor
13518           getDescriptorForType() {
13519         return getDescriptor();
13520       }
13521       public static final com.google.protobuf.Descriptors.EnumDescriptor
13522           getDescriptor() {
13523         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
13524       }
13525
13526       private static final Type[] VALUES = values();
13527
13528       public static Type valueOf(
13529           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
13530         if (desc.getType() != getDescriptor()) {
13531           throw new java.lang.IllegalArgumentException(
13532             "EnumValueDescriptor is not for this type.");
13533         }
13534         return VALUES[desc.getIndex()];
13535       }
13536
13537       private final int index;
13538       private final int value;
13539
13540       private Type(int index, int value) {
13541         this.index = index;
13542         this.value = value;
13543       }
13544
13545       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
13546     }
13547
13548     private int bitField0_;
13549     // optional .openxc.DynamicField.Type type = 1;
13550     public static final int TYPE_FIELD_NUMBER = 1;
13551     private com.openxc.BinaryMessages.DynamicField.Type type_;
13552     /**
13553      * <code>optional .openxc.DynamicField.Type type = 1;</code>
13554      */
13555     public boolean hasType() {
13556       return ((bitField0_ & 0x00000001) == 0x00000001);
13557     }
13558     /**
13559      * <code>optional .openxc.DynamicField.Type type = 1;</code>
13560      */
13561     public com.openxc.BinaryMessages.DynamicField.Type getType() {
13562       return type_;
13563     }
13564
13565     // optional string string_value = 2;
13566     public static final int STRING_VALUE_FIELD_NUMBER = 2;
13567     private java.lang.Object stringValue_;
13568     /**
13569      * <code>optional string string_value = 2;</code>
13570      */
13571     public boolean hasStringValue() {
13572       return ((bitField0_ & 0x00000002) == 0x00000002);
13573     }
13574     /**
13575      * <code>optional string string_value = 2;</code>
13576      */
13577     public java.lang.String getStringValue() {
13578       java.lang.Object ref = stringValue_;
13579       if (ref instanceof java.lang.String) {
13580         return (java.lang.String) ref;
13581       } else {
13582         com.google.protobuf.ByteString bs =
13583             (com.google.protobuf.ByteString) ref;
13584         java.lang.String s = bs.toStringUtf8();
13585         if (bs.isValidUtf8()) {
13586           stringValue_ = s;
13587         }
13588         return s;
13589       }
13590     }
13591     /**
13592      * <code>optional string string_value = 2;</code>
13593      */
13594     public com.google.protobuf.ByteString
13595         getStringValueBytes() {
13596       java.lang.Object ref = stringValue_;
13597       if (ref instanceof java.lang.String) {
13598         com.google.protobuf.ByteString b =
13599             com.google.protobuf.ByteString.copyFromUtf8(
13600                 (java.lang.String) ref);
13601         stringValue_ = b;
13602         return b;
13603       } else {
13604         return (com.google.protobuf.ByteString) ref;
13605       }
13606     }
13607
13608     // optional double numeric_value = 3;
13609     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
13610     private double numericValue_;
13611     /**
13612      * <code>optional double numeric_value = 3;</code>
13613      */
13614     public boolean hasNumericValue() {
13615       return ((bitField0_ & 0x00000004) == 0x00000004);
13616     }
13617     /**
13618      * <code>optional double numeric_value = 3;</code>
13619      */
13620     public double getNumericValue() {
13621       return numericValue_;
13622     }
13623
13624     // optional bool boolean_value = 4;
13625     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
13626     private boolean booleanValue_;
13627     /**
13628      * <code>optional bool boolean_value = 4;</code>
13629      */
13630     public boolean hasBooleanValue() {
13631       return ((bitField0_ & 0x00000008) == 0x00000008);
13632     }
13633     /**
13634      * <code>optional bool boolean_value = 4;</code>
13635      */
13636     public boolean getBooleanValue() {
13637       return booleanValue_;
13638     }
13639
13640     private void initFields() {
13641       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
13642       stringValue_ = "";
13643       numericValue_ = 0D;
13644       booleanValue_ = false;
13645     }
13646     private byte memoizedIsInitialized = -1;
13647     public final boolean isInitialized() {
13648       byte isInitialized = memoizedIsInitialized;
13649       if (isInitialized != -1) return isInitialized == 1;
13650
13651       memoizedIsInitialized = 1;
13652       return true;
13653     }
13654
13655     public void writeTo(com.google.protobuf.CodedOutputStream output)
13656                         throws java.io.IOException {
13657       getSerializedSize();
13658       if (((bitField0_ & 0x00000001) == 0x00000001)) {
13659         output.writeEnum(1, type_.getNumber());
13660       }
13661       if (((bitField0_ & 0x00000002) == 0x00000002)) {
13662         output.writeBytes(2, getStringValueBytes());
13663       }
13664       if (((bitField0_ & 0x00000004) == 0x00000004)) {
13665         output.writeDouble(3, numericValue_);
13666       }
13667       if (((bitField0_ & 0x00000008) == 0x00000008)) {
13668         output.writeBool(4, booleanValue_);
13669       }
13670       getUnknownFields().writeTo(output);
13671     }
13672
13673     private int memoizedSerializedSize = -1;
13674     public int getSerializedSize() {
13675       int size = memoizedSerializedSize;
13676       if (size != -1) return size;
13677
13678       size = 0;
13679       if (((bitField0_ & 0x00000001) == 0x00000001)) {
13680         size += com.google.protobuf.CodedOutputStream
13681           .computeEnumSize(1, type_.getNumber());
13682       }
13683       if (((bitField0_ & 0x00000002) == 0x00000002)) {
13684         size += com.google.protobuf.CodedOutputStream
13685           .computeBytesSize(2, getStringValueBytes());
13686       }
13687       if (((bitField0_ & 0x00000004) == 0x00000004)) {
13688         size += com.google.protobuf.CodedOutputStream
13689           .computeDoubleSize(3, numericValue_);
13690       }
13691       if (((bitField0_ & 0x00000008) == 0x00000008)) {
13692         size += com.google.protobuf.CodedOutputStream
13693           .computeBoolSize(4, booleanValue_);
13694       }
13695       size += getUnknownFields().getSerializedSize();
13696       memoizedSerializedSize = size;
13697       return size;
13698     }
13699
13700     private static final long serialVersionUID = 0L;
13701     @java.lang.Override
13702     protected java.lang.Object writeReplace()
13703         throws java.io.ObjectStreamException {
13704       return super.writeReplace();
13705     }
13706
13707     public static com.openxc.BinaryMessages.DynamicField parseFrom(
13708         com.google.protobuf.ByteString data)
13709         throws com.google.protobuf.InvalidProtocolBufferException {
13710       return PARSER.parseFrom(data);
13711     }
13712     public static com.openxc.BinaryMessages.DynamicField parseFrom(
13713         com.google.protobuf.ByteString data,
13714         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13715         throws com.google.protobuf.InvalidProtocolBufferException {
13716       return PARSER.parseFrom(data, extensionRegistry);
13717     }
13718     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
13719         throws com.google.protobuf.InvalidProtocolBufferException {
13720       return PARSER.parseFrom(data);
13721     }
13722     public static com.openxc.BinaryMessages.DynamicField parseFrom(
13723         byte[] data,
13724         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13725         throws com.google.protobuf.InvalidProtocolBufferException {
13726       return PARSER.parseFrom(data, extensionRegistry);
13727     }
13728     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
13729         throws java.io.IOException {
13730       return PARSER.parseFrom(input);
13731     }
13732     public static com.openxc.BinaryMessages.DynamicField parseFrom(
13733         java.io.InputStream input,
13734         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13735         throws java.io.IOException {
13736       return PARSER.parseFrom(input, extensionRegistry);
13737     }
13738     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
13739         throws java.io.IOException {
13740       return PARSER.parseDelimitedFrom(input);
13741     }
13742     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
13743         java.io.InputStream input,
13744         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13745         throws java.io.IOException {
13746       return PARSER.parseDelimitedFrom(input, extensionRegistry);
13747     }
13748     public static com.openxc.BinaryMessages.DynamicField parseFrom(
13749         com.google.protobuf.CodedInputStream input)
13750         throws java.io.IOException {
13751       return PARSER.parseFrom(input);
13752     }
13753     public static com.openxc.BinaryMessages.DynamicField parseFrom(
13754         com.google.protobuf.CodedInputStream input,
13755         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13756         throws java.io.IOException {
13757       return PARSER.parseFrom(input, extensionRegistry);
13758     }
13759
13760     public static Builder newBuilder() { return Builder.create(); }
13761     public Builder newBuilderForType() { return newBuilder(); }
13762     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
13763       return newBuilder().mergeFrom(prototype);
13764     }
13765     public Builder toBuilder() { return newBuilder(this); }
13766
13767     @java.lang.Override
13768     protected Builder newBuilderForType(
13769         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
13770       Builder builder = new Builder(parent);
13771       return builder;
13772     }
13773     /**
13774      * Protobuf type {@code openxc.DynamicField}
13775      */
13776     public static final class Builder extends
13777         com.google.protobuf.GeneratedMessage.Builder<Builder>
13778        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
13779       public static final com.google.protobuf.Descriptors.Descriptor
13780           getDescriptor() {
13781         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
13782       }
13783
13784       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
13785           internalGetFieldAccessorTable() {
13786         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
13787             .ensureFieldAccessorsInitialized(
13788                 com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
13789       }
13790
13791       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
13792       private Builder() {
13793         maybeForceBuilderInitialization();
13794       }
13795
13796       private Builder(
13797           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
13798         super(parent);
13799         maybeForceBuilderInitialization();
13800       }
13801       private void maybeForceBuilderInitialization() {
13802         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
13803         }
13804       }
13805       private static Builder create() {
13806         return new Builder();
13807       }
13808
13809       public Builder clear() {
13810         super.clear();
13811         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
13812         bitField0_ = (bitField0_ & ~0x00000001);
13813         stringValue_ = "";
13814         bitField0_ = (bitField0_ & ~0x00000002);
13815         numericValue_ = 0D;
13816         bitField0_ = (bitField0_ & ~0x00000004);
13817         booleanValue_ = false;
13818         bitField0_ = (bitField0_ & ~0x00000008);
13819         return this;
13820       }
13821
13822       public Builder clone() {
13823         return create().mergeFrom(buildPartial());
13824       }
13825
13826       public com.google.protobuf.Descriptors.Descriptor
13827           getDescriptorForType() {
13828         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
13829       }
13830
13831       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
13832         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
13833       }
13834
13835       public com.openxc.BinaryMessages.DynamicField build() {
13836         com.openxc.BinaryMessages.DynamicField result = buildPartial();
13837         if (!result.isInitialized()) {
13838           throw newUninitializedMessageException(result);
13839         }
13840         return result;
13841       }
13842
13843       public com.openxc.BinaryMessages.DynamicField buildPartial() {
13844         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
13845         int from_bitField0_ = bitField0_;
13846         int to_bitField0_ = 0;
13847         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
13848           to_bitField0_ |= 0x00000001;
13849         }
13850         result.type_ = type_;
13851         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
13852           to_bitField0_ |= 0x00000002;
13853         }
13854         result.stringValue_ = stringValue_;
13855         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
13856           to_bitField0_ |= 0x00000004;
13857         }
13858         result.numericValue_ = numericValue_;
13859         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
13860           to_bitField0_ |= 0x00000008;
13861         }
13862         result.booleanValue_ = booleanValue_;
13863         result.bitField0_ = to_bitField0_;
13864         onBuilt();
13865         return result;
13866       }
13867
13868       public Builder mergeFrom(com.google.protobuf.Message other) {
13869         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
13870           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
13871         } else {
13872           super.mergeFrom(other);
13873           return this;
13874         }
13875       }
13876
13877       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
13878         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
13879         if (other.hasType()) {
13880           setType(other.getType());
13881         }
13882         if (other.hasStringValue()) {
13883           bitField0_ |= 0x00000002;
13884           stringValue_ = other.stringValue_;
13885           onChanged();
13886         }
13887         if (other.hasNumericValue()) {
13888           setNumericValue(other.getNumericValue());
13889         }
13890         if (other.hasBooleanValue()) {
13891           setBooleanValue(other.getBooleanValue());
13892         }
13893         this.mergeUnknownFields(other.getUnknownFields());
13894         return this;
13895       }
13896
13897       public final boolean isInitialized() {
13898         return true;
13899       }
13900
13901       public Builder mergeFrom(
13902           com.google.protobuf.CodedInputStream input,
13903           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
13904           throws java.io.IOException {
13905         com.openxc.BinaryMessages.DynamicField parsedMessage = null;
13906         try {
13907           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
13908         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
13909           parsedMessage = (com.openxc.BinaryMessages.DynamicField) e.getUnfinishedMessage();
13910           throw e;
13911         } finally {
13912           if (parsedMessage != null) {
13913             mergeFrom(parsedMessage);
13914           }
13915         }
13916         return this;
13917       }
13918       private int bitField0_;
13919
13920       // optional .openxc.DynamicField.Type type = 1;
13921       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
13922       /**
13923        * <code>optional .openxc.DynamicField.Type type = 1;</code>
13924        */
13925       public boolean hasType() {
13926         return ((bitField0_ & 0x00000001) == 0x00000001);
13927       }
13928       /**
13929        * <code>optional .openxc.DynamicField.Type type = 1;</code>
13930        */
13931       public com.openxc.BinaryMessages.DynamicField.Type getType() {
13932         return type_;
13933       }
13934       /**
13935        * <code>optional .openxc.DynamicField.Type type = 1;</code>
13936        */
13937       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
13938         if (value == null) {
13939           throw new NullPointerException();
13940         }
13941         bitField0_ |= 0x00000001;
13942         type_ = value;
13943         onChanged();
13944         return this;
13945       }
13946       /**
13947        * <code>optional .openxc.DynamicField.Type type = 1;</code>
13948        */
13949       public Builder clearType() {
13950         bitField0_ = (bitField0_ & ~0x00000001);
13951         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
13952         onChanged();
13953         return this;
13954       }
13955
13956       // optional string string_value = 2;
13957       private java.lang.Object stringValue_ = "";
13958       /**
13959        * <code>optional string string_value = 2;</code>
13960        */
13961       public boolean hasStringValue() {
13962         return ((bitField0_ & 0x00000002) == 0x00000002);
13963       }
13964       /**
13965        * <code>optional string string_value = 2;</code>
13966        */
13967       public java.lang.String getStringValue() {
13968         java.lang.Object ref = stringValue_;
13969         if (!(ref instanceof java.lang.String)) {
13970           java.lang.String s = ((com.google.protobuf.ByteString) ref)
13971               .toStringUtf8();
13972           stringValue_ = s;
13973           return s;
13974         } else {
13975           return (java.lang.String) ref;
13976         }
13977       }
13978       /**
13979        * <code>optional string string_value = 2;</code>
13980        */
13981       public com.google.protobuf.ByteString
13982           getStringValueBytes() {
13983         java.lang.Object ref = stringValue_;
13984         if (ref instanceof String) {
13985           com.google.protobuf.ByteString b =
13986               com.google.protobuf.ByteString.copyFromUtf8(
13987                   (java.lang.String) ref);
13988           stringValue_ = b;
13989           return b;
13990         } else {
13991           return (com.google.protobuf.ByteString) ref;
13992         }
13993       }
13994       /**
13995        * <code>optional string string_value = 2;</code>
13996        */
13997       public Builder setStringValue(
13998           java.lang.String value) {
13999         if (value == null) {
14000     throw new NullPointerException();
14001   }
14002   bitField0_ |= 0x00000002;
14003         stringValue_ = value;
14004         onChanged();
14005         return this;
14006       }
14007       /**
14008        * <code>optional string string_value = 2;</code>
14009        */
14010       public Builder clearStringValue() {
14011         bitField0_ = (bitField0_ & ~0x00000002);
14012         stringValue_ = getDefaultInstance().getStringValue();
14013         onChanged();
14014         return this;
14015       }
14016       /**
14017        * <code>optional string string_value = 2;</code>
14018        */
14019       public Builder setStringValueBytes(
14020           com.google.protobuf.ByteString value) {
14021         if (value == null) {
14022     throw new NullPointerException();
14023   }
14024   bitField0_ |= 0x00000002;
14025         stringValue_ = value;
14026         onChanged();
14027         return this;
14028       }
14029
14030       // optional double numeric_value = 3;
14031       private double numericValue_ ;
14032       /**
14033        * <code>optional double numeric_value = 3;</code>
14034        */
14035       public boolean hasNumericValue() {
14036         return ((bitField0_ & 0x00000004) == 0x00000004);
14037       }
14038       /**
14039        * <code>optional double numeric_value = 3;</code>
14040        */
14041       public double getNumericValue() {
14042         return numericValue_;
14043       }
14044       /**
14045        * <code>optional double numeric_value = 3;</code>
14046        */
14047       public Builder setNumericValue(double value) {
14048         bitField0_ |= 0x00000004;
14049         numericValue_ = value;
14050         onChanged();
14051         return this;
14052       }
14053       /**
14054        * <code>optional double numeric_value = 3;</code>
14055        */
14056       public Builder clearNumericValue() {
14057         bitField0_ = (bitField0_ & ~0x00000004);
14058         numericValue_ = 0D;
14059         onChanged();
14060         return this;
14061       }
14062
14063       // optional bool boolean_value = 4;
14064       private boolean booleanValue_ ;
14065       /**
14066        * <code>optional bool boolean_value = 4;</code>
14067        */
14068       public boolean hasBooleanValue() {
14069         return ((bitField0_ & 0x00000008) == 0x00000008);
14070       }
14071       /**
14072        * <code>optional bool boolean_value = 4;</code>
14073        */
14074       public boolean getBooleanValue() {
14075         return booleanValue_;
14076       }
14077       /**
14078        * <code>optional bool boolean_value = 4;</code>
14079        */
14080       public Builder setBooleanValue(boolean value) {
14081         bitField0_ |= 0x00000008;
14082         booleanValue_ = value;
14083         onChanged();
14084         return this;
14085       }
14086       /**
14087        * <code>optional bool boolean_value = 4;</code>
14088        */
14089       public Builder clearBooleanValue() {
14090         bitField0_ = (bitField0_ & ~0x00000008);
14091         booleanValue_ = false;
14092         onChanged();
14093         return this;
14094       }
14095
14096       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
14097     }
14098
14099     static {
14100       defaultInstance = new DynamicField(true);
14101       defaultInstance.initFields();
14102     }
14103
14104     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
14105   }
14106
14107   public interface SimpleMessageOrBuilder
14108       extends com.google.protobuf.MessageOrBuilder {
14109
14110     // optional string name = 1;
14111     /**
14112      * <code>optional string name = 1;</code>
14113      */
14114     boolean hasName();
14115     /**
14116      * <code>optional string name = 1;</code>
14117      */
14118     java.lang.String getName();
14119     /**
14120      * <code>optional string name = 1;</code>
14121      */
14122     com.google.protobuf.ByteString
14123         getNameBytes();
14124
14125     // optional .openxc.DynamicField value = 2;
14126     /**
14127      * <code>optional .openxc.DynamicField value = 2;</code>
14128      */
14129     boolean hasValue();
14130     /**
14131      * <code>optional .openxc.DynamicField value = 2;</code>
14132      */
14133     com.openxc.BinaryMessages.DynamicField getValue();
14134     /**
14135      * <code>optional .openxc.DynamicField value = 2;</code>
14136      */
14137     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
14138
14139     // optional .openxc.DynamicField event = 3;
14140     /**
14141      * <code>optional .openxc.DynamicField event = 3;</code>
14142      */
14143     boolean hasEvent();
14144     /**
14145      * <code>optional .openxc.DynamicField event = 3;</code>
14146      */
14147     com.openxc.BinaryMessages.DynamicField getEvent();
14148     /**
14149      * <code>optional .openxc.DynamicField event = 3;</code>
14150      */
14151     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
14152   }
14153   /**
14154    * Protobuf type {@code openxc.SimpleMessage}
14155    */
14156   public static final class SimpleMessage extends
14157       com.google.protobuf.GeneratedMessage
14158       implements SimpleMessageOrBuilder {
14159     // Use SimpleMessage.newBuilder() to construct.
14160     private SimpleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
14161       super(builder);
14162       this.unknownFields = builder.getUnknownFields();
14163     }
14164     private SimpleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
14165
14166     private static final SimpleMessage defaultInstance;
14167     public static SimpleMessage getDefaultInstance() {
14168       return defaultInstance;
14169     }
14170
14171     public SimpleMessage getDefaultInstanceForType() {
14172       return defaultInstance;
14173     }
14174
14175     private final com.google.protobuf.UnknownFieldSet unknownFields;
14176     @java.lang.Override
14177     public final com.google.protobuf.UnknownFieldSet
14178         getUnknownFields() {
14179       return this.unknownFields;
14180     }
14181     private SimpleMessage(
14182         com.google.protobuf.CodedInputStream input,
14183         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14184         throws com.google.protobuf.InvalidProtocolBufferException {
14185       initFields();
14186       int mutable_bitField0_ = 0;
14187       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
14188           com.google.protobuf.UnknownFieldSet.newBuilder();
14189       try {
14190         boolean done = false;
14191         while (!done) {
14192           int tag = input.readTag();
14193           switch (tag) {
14194             case 0:
14195               done = true;
14196               break;
14197             default: {
14198               if (!parseUnknownField(input, unknownFields,
14199                                      extensionRegistry, tag)) {
14200                 done = true;
14201               }
14202               break;
14203             }
14204             case 10: {
14205               bitField0_ |= 0x00000001;
14206               name_ = input.readBytes();
14207               break;
14208             }
14209             case 18: {
14210               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
14211               if (((bitField0_ & 0x00000002) == 0x00000002)) {
14212                 subBuilder = value_.toBuilder();
14213               }
14214               value_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
14215               if (subBuilder != null) {
14216                 subBuilder.mergeFrom(value_);
14217                 value_ = subBuilder.buildPartial();
14218               }
14219               bitField0_ |= 0x00000002;
14220               break;
14221             }
14222             case 26: {
14223               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
14224               if (((bitField0_ & 0x00000004) == 0x00000004)) {
14225                 subBuilder = event_.toBuilder();
14226               }
14227               event_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
14228               if (subBuilder != null) {
14229                 subBuilder.mergeFrom(event_);
14230                 event_ = subBuilder.buildPartial();
14231               }
14232               bitField0_ |= 0x00000004;
14233               break;
14234             }
14235           }
14236         }
14237       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
14238         throw e.setUnfinishedMessage(this);
14239       } catch (java.io.IOException e) {
14240         throw new com.google.protobuf.InvalidProtocolBufferException(
14241             e.getMessage()).setUnfinishedMessage(this);
14242       } finally {
14243         this.unknownFields = unknownFields.build();
14244         makeExtensionsImmutable();
14245       }
14246     }
14247     public static final com.google.protobuf.Descriptors.Descriptor
14248         getDescriptor() {
14249       return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_descriptor;
14250     }
14251
14252     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
14253         internalGetFieldAccessorTable() {
14254       return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_fieldAccessorTable
14255           .ensureFieldAccessorsInitialized(
14256               com.openxc.BinaryMessages.SimpleMessage.class, com.openxc.BinaryMessages.SimpleMessage.Builder.class);
14257     }
14258
14259     public static com.google.protobuf.Parser<SimpleMessage> PARSER =
14260         new com.google.protobuf.AbstractParser<SimpleMessage>() {
14261       public SimpleMessage parsePartialFrom(
14262           com.google.protobuf.CodedInputStream input,
14263           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14264           throws com.google.protobuf.InvalidProtocolBufferException {
14265         return new SimpleMessage(input, extensionRegistry);
14266       }
14267     };
14268
14269     @java.lang.Override
14270     public com.google.protobuf.Parser<SimpleMessage> getParserForType() {
14271       return PARSER;
14272     }
14273
14274     private int bitField0_;
14275     // optional string name = 1;
14276     public static final int NAME_FIELD_NUMBER = 1;
14277     private java.lang.Object name_;
14278     /**
14279      * <code>optional string name = 1;</code>
14280      */
14281     public boolean hasName() {
14282       return ((bitField0_ & 0x00000001) == 0x00000001);
14283     }
14284     /**
14285      * <code>optional string name = 1;</code>
14286      */
14287     public java.lang.String getName() {
14288       java.lang.Object ref = name_;
14289       if (ref instanceof java.lang.String) {
14290         return (java.lang.String) ref;
14291       } else {
14292         com.google.protobuf.ByteString bs =
14293             (com.google.protobuf.ByteString) ref;
14294         java.lang.String s = bs.toStringUtf8();
14295         if (bs.isValidUtf8()) {
14296           name_ = s;
14297         }
14298         return s;
14299       }
14300     }
14301     /**
14302      * <code>optional string name = 1;</code>
14303      */
14304     public com.google.protobuf.ByteString
14305         getNameBytes() {
14306       java.lang.Object ref = name_;
14307       if (ref instanceof java.lang.String) {
14308         com.google.protobuf.ByteString b =
14309             com.google.protobuf.ByteString.copyFromUtf8(
14310                 (java.lang.String) ref);
14311         name_ = b;
14312         return b;
14313       } else {
14314         return (com.google.protobuf.ByteString) ref;
14315       }
14316     }
14317
14318     // optional .openxc.DynamicField value = 2;
14319     public static final int VALUE_FIELD_NUMBER = 2;
14320     private com.openxc.BinaryMessages.DynamicField value_;
14321     /**
14322      * <code>optional .openxc.DynamicField value = 2;</code>
14323      */
14324     public boolean hasValue() {
14325       return ((bitField0_ & 0x00000002) == 0x00000002);
14326     }
14327     /**
14328      * <code>optional .openxc.DynamicField value = 2;</code>
14329      */
14330     public com.openxc.BinaryMessages.DynamicField getValue() {
14331       return value_;
14332     }
14333     /**
14334      * <code>optional .openxc.DynamicField value = 2;</code>
14335      */
14336     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
14337       return value_;
14338     }
14339
14340     // optional .openxc.DynamicField event = 3;
14341     public static final int EVENT_FIELD_NUMBER = 3;
14342     private com.openxc.BinaryMessages.DynamicField event_;
14343     /**
14344      * <code>optional .openxc.DynamicField event = 3;</code>
14345      */
14346     public boolean hasEvent() {
14347       return ((bitField0_ & 0x00000004) == 0x00000004);
14348     }
14349     /**
14350      * <code>optional .openxc.DynamicField event = 3;</code>
14351      */
14352     public com.openxc.BinaryMessages.DynamicField getEvent() {
14353       return event_;
14354     }
14355     /**
14356      * <code>optional .openxc.DynamicField event = 3;</code>
14357      */
14358     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
14359       return event_;
14360     }
14361
14362     private void initFields() {
14363       name_ = "";
14364       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14365       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14366     }
14367     private byte memoizedIsInitialized = -1;
14368     public final boolean isInitialized() {
14369       byte isInitialized = memoizedIsInitialized;
14370       if (isInitialized != -1) return isInitialized == 1;
14371
14372       memoizedIsInitialized = 1;
14373       return true;
14374     }
14375
14376     public void writeTo(com.google.protobuf.CodedOutputStream output)
14377                         throws java.io.IOException {
14378       getSerializedSize();
14379       if (((bitField0_ & 0x00000001) == 0x00000001)) {
14380         output.writeBytes(1, getNameBytes());
14381       }
14382       if (((bitField0_ & 0x00000002) == 0x00000002)) {
14383         output.writeMessage(2, value_);
14384       }
14385       if (((bitField0_ & 0x00000004) == 0x00000004)) {
14386         output.writeMessage(3, event_);
14387       }
14388       getUnknownFields().writeTo(output);
14389     }
14390
14391     private int memoizedSerializedSize = -1;
14392     public int getSerializedSize() {
14393       int size = memoizedSerializedSize;
14394       if (size != -1) return size;
14395
14396       size = 0;
14397       if (((bitField0_ & 0x00000001) == 0x00000001)) {
14398         size += com.google.protobuf.CodedOutputStream
14399           .computeBytesSize(1, getNameBytes());
14400       }
14401       if (((bitField0_ & 0x00000002) == 0x00000002)) {
14402         size += com.google.protobuf.CodedOutputStream
14403           .computeMessageSize(2, value_);
14404       }
14405       if (((bitField0_ & 0x00000004) == 0x00000004)) {
14406         size += com.google.protobuf.CodedOutputStream
14407           .computeMessageSize(3, event_);
14408       }
14409       size += getUnknownFields().getSerializedSize();
14410       memoizedSerializedSize = size;
14411       return size;
14412     }
14413
14414     private static final long serialVersionUID = 0L;
14415     @java.lang.Override
14416     protected java.lang.Object writeReplace()
14417         throws java.io.ObjectStreamException {
14418       return super.writeReplace();
14419     }
14420
14421     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
14422         com.google.protobuf.ByteString data)
14423         throws com.google.protobuf.InvalidProtocolBufferException {
14424       return PARSER.parseFrom(data);
14425     }
14426     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
14427         com.google.protobuf.ByteString data,
14428         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14429         throws com.google.protobuf.InvalidProtocolBufferException {
14430       return PARSER.parseFrom(data, extensionRegistry);
14431     }
14432     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(byte[] data)
14433         throws com.google.protobuf.InvalidProtocolBufferException {
14434       return PARSER.parseFrom(data);
14435     }
14436     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
14437         byte[] data,
14438         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14439         throws com.google.protobuf.InvalidProtocolBufferException {
14440       return PARSER.parseFrom(data, extensionRegistry);
14441     }
14442     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(java.io.InputStream input)
14443         throws java.io.IOException {
14444       return PARSER.parseFrom(input);
14445     }
14446     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
14447         java.io.InputStream input,
14448         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14449         throws java.io.IOException {
14450       return PARSER.parseFrom(input, extensionRegistry);
14451     }
14452     public static com.openxc.BinaryMessages.SimpleMessage parseDelimitedFrom(java.io.InputStream input)
14453         throws java.io.IOException {
14454       return PARSER.parseDelimitedFrom(input);
14455     }
14456     public static com.openxc.BinaryMessages.SimpleMessage parseDelimitedFrom(
14457         java.io.InputStream input,
14458         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14459         throws java.io.IOException {
14460       return PARSER.parseDelimitedFrom(input, extensionRegistry);
14461     }
14462     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
14463         com.google.protobuf.CodedInputStream input)
14464         throws java.io.IOException {
14465       return PARSER.parseFrom(input);
14466     }
14467     public static com.openxc.BinaryMessages.SimpleMessage parseFrom(
14468         com.google.protobuf.CodedInputStream input,
14469         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14470         throws java.io.IOException {
14471       return PARSER.parseFrom(input, extensionRegistry);
14472     }
14473
14474     public static Builder newBuilder() { return Builder.create(); }
14475     public Builder newBuilderForType() { return newBuilder(); }
14476     public static Builder newBuilder(com.openxc.BinaryMessages.SimpleMessage prototype) {
14477       return newBuilder().mergeFrom(prototype);
14478     }
14479     public Builder toBuilder() { return newBuilder(this); }
14480
14481     @java.lang.Override
14482     protected Builder newBuilderForType(
14483         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
14484       Builder builder = new Builder(parent);
14485       return builder;
14486     }
14487     /**
14488      * Protobuf type {@code openxc.SimpleMessage}
14489      */
14490     public static final class Builder extends
14491         com.google.protobuf.GeneratedMessage.Builder<Builder>
14492        implements com.openxc.BinaryMessages.SimpleMessageOrBuilder {
14493       public static final com.google.protobuf.Descriptors.Descriptor
14494           getDescriptor() {
14495         return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_descriptor;
14496       }
14497
14498       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
14499           internalGetFieldAccessorTable() {
14500         return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_fieldAccessorTable
14501             .ensureFieldAccessorsInitialized(
14502                 com.openxc.BinaryMessages.SimpleMessage.class, com.openxc.BinaryMessages.SimpleMessage.Builder.class);
14503       }
14504
14505       // Construct using com.openxc.BinaryMessages.SimpleMessage.newBuilder()
14506       private Builder() {
14507         maybeForceBuilderInitialization();
14508       }
14509
14510       private Builder(
14511           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
14512         super(parent);
14513         maybeForceBuilderInitialization();
14514       }
14515       private void maybeForceBuilderInitialization() {
14516         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
14517           getValueFieldBuilder();
14518           getEventFieldBuilder();
14519         }
14520       }
14521       private static Builder create() {
14522         return new Builder();
14523       }
14524
14525       public Builder clear() {
14526         super.clear();
14527         name_ = "";
14528         bitField0_ = (bitField0_ & ~0x00000001);
14529         if (valueBuilder_ == null) {
14530           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14531         } else {
14532           valueBuilder_.clear();
14533         }
14534         bitField0_ = (bitField0_ & ~0x00000002);
14535         if (eventBuilder_ == null) {
14536           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14537         } else {
14538           eventBuilder_.clear();
14539         }
14540         bitField0_ = (bitField0_ & ~0x00000004);
14541         return this;
14542       }
14543
14544       public Builder clone() {
14545         return create().mergeFrom(buildPartial());
14546       }
14547
14548       public com.google.protobuf.Descriptors.Descriptor
14549           getDescriptorForType() {
14550         return com.openxc.BinaryMessages.internal_static_openxc_SimpleMessage_descriptor;
14551       }
14552
14553       public com.openxc.BinaryMessages.SimpleMessage getDefaultInstanceForType() {
14554         return com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance();
14555       }
14556
14557       public com.openxc.BinaryMessages.SimpleMessage build() {
14558         com.openxc.BinaryMessages.SimpleMessage result = buildPartial();
14559         if (!result.isInitialized()) {
14560           throw newUninitializedMessageException(result);
14561         }
14562         return result;
14563       }
14564
14565       public com.openxc.BinaryMessages.SimpleMessage buildPartial() {
14566         com.openxc.BinaryMessages.SimpleMessage result = new com.openxc.BinaryMessages.SimpleMessage(this);
14567         int from_bitField0_ = bitField0_;
14568         int to_bitField0_ = 0;
14569         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
14570           to_bitField0_ |= 0x00000001;
14571         }
14572         result.name_ = name_;
14573         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
14574           to_bitField0_ |= 0x00000002;
14575         }
14576         if (valueBuilder_ == null) {
14577           result.value_ = value_;
14578         } else {
14579           result.value_ = valueBuilder_.build();
14580         }
14581         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
14582           to_bitField0_ |= 0x00000004;
14583         }
14584         if (eventBuilder_ == null) {
14585           result.event_ = event_;
14586         } else {
14587           result.event_ = eventBuilder_.build();
14588         }
14589         result.bitField0_ = to_bitField0_;
14590         onBuilt();
14591         return result;
14592       }
14593
14594       public Builder mergeFrom(com.google.protobuf.Message other) {
14595         if (other instanceof com.openxc.BinaryMessages.SimpleMessage) {
14596           return mergeFrom((com.openxc.BinaryMessages.SimpleMessage)other);
14597         } else {
14598           super.mergeFrom(other);
14599           return this;
14600         }
14601       }
14602
14603       public Builder mergeFrom(com.openxc.BinaryMessages.SimpleMessage other) {
14604         if (other == com.openxc.BinaryMessages.SimpleMessage.getDefaultInstance()) return this;
14605         if (other.hasName()) {
14606           bitField0_ |= 0x00000001;
14607           name_ = other.name_;
14608           onChanged();
14609         }
14610         if (other.hasValue()) {
14611           mergeValue(other.getValue());
14612         }
14613         if (other.hasEvent()) {
14614           mergeEvent(other.getEvent());
14615         }
14616         this.mergeUnknownFields(other.getUnknownFields());
14617         return this;
14618       }
14619
14620       public final boolean isInitialized() {
14621         return true;
14622       }
14623
14624       public Builder mergeFrom(
14625           com.google.protobuf.CodedInputStream input,
14626           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
14627           throws java.io.IOException {
14628         com.openxc.BinaryMessages.SimpleMessage parsedMessage = null;
14629         try {
14630           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
14631         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
14632           parsedMessage = (com.openxc.BinaryMessages.SimpleMessage) e.getUnfinishedMessage();
14633           throw e;
14634         } finally {
14635           if (parsedMessage != null) {
14636             mergeFrom(parsedMessage);
14637           }
14638         }
14639         return this;
14640       }
14641       private int bitField0_;
14642
14643       // optional string name = 1;
14644       private java.lang.Object name_ = "";
14645       /**
14646        * <code>optional string name = 1;</code>
14647        */
14648       public boolean hasName() {
14649         return ((bitField0_ & 0x00000001) == 0x00000001);
14650       }
14651       /**
14652        * <code>optional string name = 1;</code>
14653        */
14654       public java.lang.String getName() {
14655         java.lang.Object ref = name_;
14656         if (!(ref instanceof java.lang.String)) {
14657           java.lang.String s = ((com.google.protobuf.ByteString) ref)
14658               .toStringUtf8();
14659           name_ = s;
14660           return s;
14661         } else {
14662           return (java.lang.String) ref;
14663         }
14664       }
14665       /**
14666        * <code>optional string name = 1;</code>
14667        */
14668       public com.google.protobuf.ByteString
14669           getNameBytes() {
14670         java.lang.Object ref = name_;
14671         if (ref instanceof String) {
14672           com.google.protobuf.ByteString b =
14673               com.google.protobuf.ByteString.copyFromUtf8(
14674                   (java.lang.String) ref);
14675           name_ = b;
14676           return b;
14677         } else {
14678           return (com.google.protobuf.ByteString) ref;
14679         }
14680       }
14681       /**
14682        * <code>optional string name = 1;</code>
14683        */
14684       public Builder setName(
14685           java.lang.String value) {
14686         if (value == null) {
14687     throw new NullPointerException();
14688   }
14689   bitField0_ |= 0x00000001;
14690         name_ = value;
14691         onChanged();
14692         return this;
14693       }
14694       /**
14695        * <code>optional string name = 1;</code>
14696        */
14697       public Builder clearName() {
14698         bitField0_ = (bitField0_ & ~0x00000001);
14699         name_ = getDefaultInstance().getName();
14700         onChanged();
14701         return this;
14702       }
14703       /**
14704        * <code>optional string name = 1;</code>
14705        */
14706       public Builder setNameBytes(
14707           com.google.protobuf.ByteString value) {
14708         if (value == null) {
14709     throw new NullPointerException();
14710   }
14711   bitField0_ |= 0x00000001;
14712         name_ = value;
14713         onChanged();
14714         return this;
14715       }
14716
14717       // optional .openxc.DynamicField value = 2;
14718       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14719       private com.google.protobuf.SingleFieldBuilder<
14720           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
14721       /**
14722        * <code>optional .openxc.DynamicField value = 2;</code>
14723        */
14724       public boolean hasValue() {
14725         return ((bitField0_ & 0x00000002) == 0x00000002);
14726       }
14727       /**
14728        * <code>optional .openxc.DynamicField value = 2;</code>
14729        */
14730       public com.openxc.BinaryMessages.DynamicField getValue() {
14731         if (valueBuilder_ == null) {
14732           return value_;
14733         } else {
14734           return valueBuilder_.getMessage();
14735         }
14736       }
14737       /**
14738        * <code>optional .openxc.DynamicField value = 2;</code>
14739        */
14740       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
14741         if (valueBuilder_ == null) {
14742           if (value == null) {
14743             throw new NullPointerException();
14744           }
14745           value_ = value;
14746           onChanged();
14747         } else {
14748           valueBuilder_.setMessage(value);
14749         }
14750         bitField0_ |= 0x00000002;
14751         return this;
14752       }
14753       /**
14754        * <code>optional .openxc.DynamicField value = 2;</code>
14755        */
14756       public Builder setValue(
14757           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
14758         if (valueBuilder_ == null) {
14759           value_ = builderForValue.build();
14760           onChanged();
14761         } else {
14762           valueBuilder_.setMessage(builderForValue.build());
14763         }
14764         bitField0_ |= 0x00000002;
14765         return this;
14766       }
14767       /**
14768        * <code>optional .openxc.DynamicField value = 2;</code>
14769        */
14770       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
14771         if (valueBuilder_ == null) {
14772           if (((bitField0_ & 0x00000002) == 0x00000002) &&
14773               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
14774             value_ =
14775               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
14776           } else {
14777             value_ = value;
14778           }
14779           onChanged();
14780         } else {
14781           valueBuilder_.mergeFrom(value);
14782         }
14783         bitField0_ |= 0x00000002;
14784         return this;
14785       }
14786       /**
14787        * <code>optional .openxc.DynamicField value = 2;</code>
14788        */
14789       public Builder clearValue() {
14790         if (valueBuilder_ == null) {
14791           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14792           onChanged();
14793         } else {
14794           valueBuilder_.clear();
14795         }
14796         bitField0_ = (bitField0_ & ~0x00000002);
14797         return this;
14798       }
14799       /**
14800        * <code>optional .openxc.DynamicField value = 2;</code>
14801        */
14802       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
14803         bitField0_ |= 0x00000002;
14804         onChanged();
14805         return getValueFieldBuilder().getBuilder();
14806       }
14807       /**
14808        * <code>optional .openxc.DynamicField value = 2;</code>
14809        */
14810       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
14811         if (valueBuilder_ != null) {
14812           return valueBuilder_.getMessageOrBuilder();
14813         } else {
14814           return value_;
14815         }
14816       }
14817       /**
14818        * <code>optional .openxc.DynamicField value = 2;</code>
14819        */
14820       private com.google.protobuf.SingleFieldBuilder<
14821           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
14822           getValueFieldBuilder() {
14823         if (valueBuilder_ == null) {
14824           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
14825               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
14826                   value_,
14827                   getParentForChildren(),
14828                   isClean());
14829           value_ = null;
14830         }
14831         return valueBuilder_;
14832       }
14833
14834       // optional .openxc.DynamicField event = 3;
14835       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14836       private com.google.protobuf.SingleFieldBuilder<
14837           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
14838       /**
14839        * <code>optional .openxc.DynamicField event = 3;</code>
14840        */
14841       public boolean hasEvent() {
14842         return ((bitField0_ & 0x00000004) == 0x00000004);
14843       }
14844       /**
14845        * <code>optional .openxc.DynamicField event = 3;</code>
14846        */
14847       public com.openxc.BinaryMessages.DynamicField getEvent() {
14848         if (eventBuilder_ == null) {
14849           return event_;
14850         } else {
14851           return eventBuilder_.getMessage();
14852         }
14853       }
14854       /**
14855        * <code>optional .openxc.DynamicField event = 3;</code>
14856        */
14857       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
14858         if (eventBuilder_ == null) {
14859           if (value == null) {
14860             throw new NullPointerException();
14861           }
14862           event_ = value;
14863           onChanged();
14864         } else {
14865           eventBuilder_.setMessage(value);
14866         }
14867         bitField0_ |= 0x00000004;
14868         return this;
14869       }
14870       /**
14871        * <code>optional .openxc.DynamicField event = 3;</code>
14872        */
14873       public Builder setEvent(
14874           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
14875         if (eventBuilder_ == null) {
14876           event_ = builderForValue.build();
14877           onChanged();
14878         } else {
14879           eventBuilder_.setMessage(builderForValue.build());
14880         }
14881         bitField0_ |= 0x00000004;
14882         return this;
14883       }
14884       /**
14885        * <code>optional .openxc.DynamicField event = 3;</code>
14886        */
14887       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
14888         if (eventBuilder_ == null) {
14889           if (((bitField0_ & 0x00000004) == 0x00000004) &&
14890               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
14891             event_ =
14892               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
14893           } else {
14894             event_ = value;
14895           }
14896           onChanged();
14897         } else {
14898           eventBuilder_.mergeFrom(value);
14899         }
14900         bitField0_ |= 0x00000004;
14901         return this;
14902       }
14903       /**
14904        * <code>optional .openxc.DynamicField event = 3;</code>
14905        */
14906       public Builder clearEvent() {
14907         if (eventBuilder_ == null) {
14908           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
14909           onChanged();
14910         } else {
14911           eventBuilder_.clear();
14912         }
14913         bitField0_ = (bitField0_ & ~0x00000004);
14914         return this;
14915       }
14916       /**
14917        * <code>optional .openxc.DynamicField event = 3;</code>
14918        */
14919       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
14920         bitField0_ |= 0x00000004;
14921         onChanged();
14922         return getEventFieldBuilder().getBuilder();
14923       }
14924       /**
14925        * <code>optional .openxc.DynamicField event = 3;</code>
14926        */
14927       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
14928         if (eventBuilder_ != null) {
14929           return eventBuilder_.getMessageOrBuilder();
14930         } else {
14931           return event_;
14932         }
14933       }
14934       /**
14935        * <code>optional .openxc.DynamicField event = 3;</code>
14936        */
14937       private com.google.protobuf.SingleFieldBuilder<
14938           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
14939           getEventFieldBuilder() {
14940         if (eventBuilder_ == null) {
14941           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
14942               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
14943                   event_,
14944                   getParentForChildren(),
14945                   isClean());
14946           event_ = null;
14947         }
14948         return eventBuilder_;
14949       }
14950
14951       // @@protoc_insertion_point(builder_scope:openxc.SimpleMessage)
14952     }
14953
14954     static {
14955       defaultInstance = new SimpleMessage(true);
14956       defaultInstance.initFields();
14957     }
14958
14959     // @@protoc_insertion_point(class_scope:openxc.SimpleMessage)
14960   }
14961
14962   private static com.google.protobuf.Descriptors.Descriptor
14963     internal_static_openxc_VehicleMessage_descriptor;
14964   private static
14965     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14966       internal_static_openxc_VehicleMessage_fieldAccessorTable;
14967   private static com.google.protobuf.Descriptors.Descriptor
14968     internal_static_openxc_CanMessage_descriptor;
14969   private static
14970     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14971       internal_static_openxc_CanMessage_fieldAccessorTable;
14972   private static com.google.protobuf.Descriptors.Descriptor
14973     internal_static_openxc_ControlCommand_descriptor;
14974   private static
14975     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14976       internal_static_openxc_ControlCommand_fieldAccessorTable;
14977   private static com.google.protobuf.Descriptors.Descriptor
14978     internal_static_openxc_DiagnosticControlCommand_descriptor;
14979   private static
14980     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14981       internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable;
14982   private static com.google.protobuf.Descriptors.Descriptor
14983     internal_static_openxc_PassthroughModeControlCommand_descriptor;
14984   private static
14985     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14986       internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable;
14987   private static com.google.protobuf.Descriptors.Descriptor
14988     internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
14989   private static
14990     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14991       internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable;
14992   private static com.google.protobuf.Descriptors.Descriptor
14993     internal_static_openxc_PayloadFormatCommand_descriptor;
14994   private static
14995     com.google.protobuf.GeneratedMessage.FieldAccessorTable
14996       internal_static_openxc_PayloadFormatCommand_fieldAccessorTable;
14997   private static com.google.protobuf.Descriptors.Descriptor
14998     internal_static_openxc_PredefinedObd2RequestsCommand_descriptor;
14999   private static
15000     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15001       internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable;
15002   private static com.google.protobuf.Descriptors.Descriptor
15003     internal_static_openxc_NetworkOperatorSettings_descriptor;
15004   private static
15005     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15006       internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable;
15007   private static com.google.protobuf.Descriptors.Descriptor
15008     internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor;
15009   private static
15010     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15011       internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable;
15012   private static com.google.protobuf.Descriptors.Descriptor
15013     internal_static_openxc_NetworkDataSettings_descriptor;
15014   private static
15015     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15016       internal_static_openxc_NetworkDataSettings_fieldAccessorTable;
15017   private static com.google.protobuf.Descriptors.Descriptor
15018     internal_static_openxc_ServerConnectSettings_descriptor;
15019   private static
15020     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15021       internal_static_openxc_ServerConnectSettings_fieldAccessorTable;
15022   private static com.google.protobuf.Descriptors.Descriptor
15023     internal_static_openxc_ModemConfigurationCommand_descriptor;
15024   private static
15025     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15026       internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable;
15027   private static com.google.protobuf.Descriptors.Descriptor
15028     internal_static_openxc_RTCConfigurationCommand_descriptor;
15029   private static
15030     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15031       internal_static_openxc_RTCConfigurationCommand_fieldAccessorTable;
15032   private static com.google.protobuf.Descriptors.Descriptor
15033     internal_static_openxc_CommandResponse_descriptor;
15034   private static
15035     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15036       internal_static_openxc_CommandResponse_fieldAccessorTable;
15037   private static com.google.protobuf.Descriptors.Descriptor
15038     internal_static_openxc_DiagnosticRequest_descriptor;
15039   private static
15040     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15041       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
15042   private static com.google.protobuf.Descriptors.Descriptor
15043     internal_static_openxc_DiagnosticResponse_descriptor;
15044   private static
15045     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15046       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
15047   private static com.google.protobuf.Descriptors.Descriptor
15048     internal_static_openxc_DynamicField_descriptor;
15049   private static
15050     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15051       internal_static_openxc_DynamicField_fieldAccessorTable;
15052   private static com.google.protobuf.Descriptors.Descriptor
15053     internal_static_openxc_SimpleMessage_descriptor;
15054   private static
15055     com.google.protobuf.GeneratedMessage.FieldAccessorTable
15056       internal_static_openxc_SimpleMessage_fieldAccessorTable;
15057
15058   public static com.google.protobuf.Descriptors.FileDescriptor
15059       getDescriptor() {
15060     return descriptor;
15061   }
15062   private static com.google.protobuf.Descriptors.FileDescriptor
15063       descriptor;
15064   static {
15065     java.lang.String[] descriptorData = {
15066       "\n\014openxc.proto\022\006openxc\"\233\003\n\016VehicleMessag" +
15067       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
15068       "Type\022\'\n\013can_message\030\002 \001(\0132\022.openxc.CanMe" +
15069       "ssage\022-\n\016simple_message\030\003 \001(\0132\025.openxc.S" +
15070       "impleMessage\0227\n\023diagnostic_response\030\004 \001(" +
15071       "\0132\032.openxc.DiagnosticResponse\022/\n\017control" +
15072       "_command\030\005 \001(\0132\026.openxc.ControlCommand\0221" +
15073       "\n\020command_response\030\006 \001(\0132\027.openxc.Comman" +
15074       "dResponse\022\021\n\ttimestamp\030\007 \001(\004\"V\n\004Type\022\007\n\003" +
15075       "CAN\020\001\022\n\n\006SIMPLE\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CON",
15076       "TROL_COMMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\"\224\001\n" +
15077       "\nCanMessage\022\013\n\003bus\030\001 \001(\005\022\n\n\002id\030\002 \001(\r\022\014\n\004" +
15078       "data\030\003 \001(\014\0224\n\014frame_format\030\004 \001(\0162\036.openx" +
15079       "c.CanMessage.FrameFormat\")\n\013FrameFormat\022" +
15080       "\014\n\010STANDARD\020\001\022\014\n\010EXTENDED\020\002\"\211\006\n\016ControlC" +
15081       "ommand\022)\n\004type\030\001 \001(\0162\033.openxc.ControlCom" +
15082       "mand.Type\022<\n\022diagnostic_request\030\002 \001(\0132 ." +
15083       "openxc.DiagnosticControlCommand\022G\n\030passt" +
15084       "hrough_mode_request\030\003 \001(\0132%.openxc.Passt" +
15085       "hroughModeControlCommand\022O\n acceptance_f",
15086       "ilter_bypass_command\030\004 \001(\0132%.openxc.Acce" +
15087       "ptanceFilterBypassCommand\022<\n\026payload_for" +
15088       "mat_command\030\005 \001(\0132\034.openxc.PayloadFormat" +
15089       "Command\022O\n predefined_obd2_requests_comm" +
15090       "and\030\006 \001(\0132%.openxc.PredefinedObd2Request" +
15091       "sCommand\022F\n\033modem_configuration_command\030" +
15092       "\007 \001(\0132!.openxc.ModemConfigurationCommand" +
15093       "\022B\n\031rtc_configuration_command\030\010 \001(\0132\037.op" +
15094       "enxc.RTCConfigurationCommand\"\330\001\n\004Type\022\013\n" +
15095       "\007VERSION\020\001\022\r\n\tDEVICE_ID\020\002\022\016\n\nDIAGNOSTIC\020",
15096       "\003\022\017\n\013PASSTHROUGH\020\004\022\034\n\030ACCEPTANCE_FILTER_" +
15097       "BYPASS\020\005\022\022\n\016PAYLOAD_FORMAT\020\006\022\034\n\030PREDEFIN" +
15098       "ED_OBD2_REQUESTS\020\007\022\027\n\023MODEM_CONFIGURATIO" +
15099       "N\020\010\022\025\n\021RTC_CONFIGURATION\020\t\022\023\n\017SD_MOUNT_S" +
15100       "TATUS\020\n\"\236\001\n\030DiagnosticControlCommand\022*\n\007" +
15101       "request\030\001 \001(\0132\031.openxc.DiagnosticRequest" +
15102       "\0227\n\006action\030\002 \001(\0162\'.openxc.DiagnosticCont" +
15103       "rolCommand.Action\"\035\n\006Action\022\007\n\003ADD\020\001\022\n\n\006" +
15104       "CANCEL\020\002\"=\n\035PassthroughModeControlComman" +
15105       "d\022\013\n\003bus\030\001 \001(\005\022\017\n\007enabled\030\002 \001(\010\"<\n\035Accep",
15106       "tanceFilterBypassCommand\022\013\n\003bus\030\001 \001(\005\022\016\n" +
15107       "\006bypass\030\002 \001(\010\"\214\001\n\024PayloadFormatCommand\022:" +
15108       "\n\006format\030\001 \001(\0162*.openxc.PayloadFormatCom" +
15109       "mand.PayloadFormat\"8\n\rPayloadFormat\022\010\n\004J" +
15110       "SON\020\001\022\014\n\010PROTOBUF\020\002\022\017\n\013MESSAGEPACK\020\003\"0\n\035" +
15111       "PredefinedObd2RequestsCommand\022\017\n\007enabled" +
15112       "\030\001 \001(\010\"\321\003\n\027NetworkOperatorSettings\022\030\n\020al" +
15113       "lowDataRoaming\030\001 \001(\010\022N\n\022operatorSelectMo" +
15114       "de\030\002 \001(\01622.openxc.NetworkOperatorSetting" +
15115       "s.OperatorSelectMode\022L\n\021networkDescripto",
15116       "r\030\003 \001(\01321.openxc.NetworkOperatorSettings" +
15117       ".NetworkDescriptor\032\230\001\n\021NetworkDescriptor" +
15118       "\022\014\n\004PLMN\030\001 \001(\r\022R\n\013networkType\030\002 \001(\0162=.op" +
15119       "enxc.NetworkOperatorSettings.NetworkDesc" +
15120       "riptor.NetworkType\"!\n\013NetworkType\022\007\n\003GSM" +
15121       "\020\000\022\t\n\005UTRAN\020\002\"c\n\022OperatorSelectMode\022\r\n\tA" +
15122       "UTOMATIC\020\000\022\n\n\006MANUAL\020\001\022\016\n\nDEREGISTER\020\002\022\014" +
15123       "\n\010SET_ONLY\020\003\022\024\n\020MANUAL_AUTOMATIC\020\004\"\"\n\023Ne" +
15124       "tworkDataSettings\022\013\n\003APN\030\001 \001(\t\"3\n\025Server" +
15125       "ConnectSettings\022\014\n\004host\030\001 \001(\t\022\014\n\004port\030\002 ",
15126       "\001(\r\"\325\001\n\031ModemConfigurationCommand\022@\n\027net" +
15127       "workOperatorSettings\030\001 \001(\0132\037.openxc.Netw" +
15128       "orkOperatorSettings\0228\n\023networkDataSettin" +
15129       "gs\030\002 \001(\0132\033.openxc.NetworkDataSettings\022<\n" +
15130       "\025serverConnectSettings\030\003 \001(\0132\035.openxc.Se" +
15131       "rverConnectSettings\",\n\027RTCConfigurationC" +
15132       "ommand\022\021\n\tunix_time\030\001 \001(\r\"]\n\017CommandResp" +
15133       "onse\022)\n\004type\030\001 \001(\0162\033.openxc.ControlComma" +
15134       "nd.Type\022\017\n\007message\030\002 \001(\t\022\016\n\006status\030\003 \001(\010" +
15135       "\"\375\001\n\021DiagnosticRequest\022\013\n\003bus\030\001 \001(\005\022\022\n\nm",
15136       "essage_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001" +
15137       "(\r\022\017\n\007payload\030\005 \001(\014\022\032\n\022multiple_response" +
15138       "s\030\006 \001(\010\022\021\n\tfrequency\030\007 \001(\001\022\014\n\004name\030\010 \001(\t" +
15139       "\022;\n\014decoded_type\030\t \001(\0162%.openxc.Diagnost" +
15140       "icRequest.DecodedType\"!\n\013DecodedType\022\010\n\004" +
15141       "NONE\020\001\022\010\n\004OBD2\020\002\"\241\001\n\022DiagnosticResponse\022" +
15142       "\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode" +
15143       "\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005 \001(\010\022\036\n\026" +
15144       "negative_response_code\030\006 \001(\r\022\017\n\007payload\030" +
15145       "\007 \001(\014\022\r\n\005value\030\010 \001(\001\"\242\001\n\014DynamicField\022\'\n",
15146       "\004type\030\001 \001(\0162\031.openxc.DynamicField.Type\022\024" +
15147       "\n\014string_value\030\002 \001(\t\022\025\n\rnumeric_value\030\003 " +
15148       "\001(\001\022\025\n\rboolean_value\030\004 \001(\010\"%\n\004Type\022\n\n\006ST" +
15149       "RING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\"g\n\rSimpleMessa" +
15150       "ge\022\014\n\004name\030\001 \001(\t\022#\n\005value\030\002 \001(\0132\024.openxc" +
15151       ".DynamicField\022#\n\005event\030\003 \001(\0132\024.openxc.Dy" +
15152       "namicFieldB\034\n\ncom.openxcB\016BinaryMessages"
15153     };
15154     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
15155       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
15156         public com.google.protobuf.ExtensionRegistry assignDescriptors(
15157             com.google.protobuf.Descriptors.FileDescriptor root) {
15158           descriptor = root;
15159           internal_static_openxc_VehicleMessage_descriptor =
15160             getDescriptor().getMessageTypes().get(0);
15161           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
15162             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15163               internal_static_openxc_VehicleMessage_descriptor,
15164               new java.lang.String[] { "Type", "CanMessage", "SimpleMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", "Timestamp", });
15165           internal_static_openxc_CanMessage_descriptor =
15166             getDescriptor().getMessageTypes().get(1);
15167           internal_static_openxc_CanMessage_fieldAccessorTable = new
15168             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15169               internal_static_openxc_CanMessage_descriptor,
15170               new java.lang.String[] { "Bus", "Id", "Data", "FrameFormat", });
15171           internal_static_openxc_ControlCommand_descriptor =
15172             getDescriptor().getMessageTypes().get(2);
15173           internal_static_openxc_ControlCommand_fieldAccessorTable = new
15174             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15175               internal_static_openxc_ControlCommand_descriptor,
15176               new java.lang.String[] { "Type", "DiagnosticRequest", "PassthroughModeRequest", "AcceptanceFilterBypassCommand", "PayloadFormatCommand", "PredefinedObd2RequestsCommand", "ModemConfigurationCommand", "RtcConfigurationCommand", });
15177           internal_static_openxc_DiagnosticControlCommand_descriptor =
15178             getDescriptor().getMessageTypes().get(3);
15179           internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable = new
15180             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15181               internal_static_openxc_DiagnosticControlCommand_descriptor,
15182               new java.lang.String[] { "Request", "Action", });
15183           internal_static_openxc_PassthroughModeControlCommand_descriptor =
15184             getDescriptor().getMessageTypes().get(4);
15185           internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable = new
15186             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15187               internal_static_openxc_PassthroughModeControlCommand_descriptor,
15188               new java.lang.String[] { "Bus", "Enabled", });
15189           internal_static_openxc_AcceptanceFilterBypassCommand_descriptor =
15190             getDescriptor().getMessageTypes().get(5);
15191           internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable = new
15192             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15193               internal_static_openxc_AcceptanceFilterBypassCommand_descriptor,
15194               new java.lang.String[] { "Bus", "Bypass", });
15195           internal_static_openxc_PayloadFormatCommand_descriptor =
15196             getDescriptor().getMessageTypes().get(6);
15197           internal_static_openxc_PayloadFormatCommand_fieldAccessorTable = new
15198             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15199               internal_static_openxc_PayloadFormatCommand_descriptor,
15200               new java.lang.String[] { "Format", });
15201           internal_static_openxc_PredefinedObd2RequestsCommand_descriptor =
15202             getDescriptor().getMessageTypes().get(7);
15203           internal_static_openxc_PredefinedObd2RequestsCommand_fieldAccessorTable = new
15204             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15205               internal_static_openxc_PredefinedObd2RequestsCommand_descriptor,
15206               new java.lang.String[] { "Enabled", });
15207           internal_static_openxc_NetworkOperatorSettings_descriptor =
15208             getDescriptor().getMessageTypes().get(8);
15209           internal_static_openxc_NetworkOperatorSettings_fieldAccessorTable = new
15210             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15211               internal_static_openxc_NetworkOperatorSettings_descriptor,
15212               new java.lang.String[] { "AllowDataRoaming", "OperatorSelectMode", "NetworkDescriptor", });
15213           internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor =
15214             internal_static_openxc_NetworkOperatorSettings_descriptor.getNestedTypes().get(0);
15215           internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_fieldAccessorTable = new
15216             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15217               internal_static_openxc_NetworkOperatorSettings_NetworkDescriptor_descriptor,
15218               new java.lang.String[] { "PLMN", "NetworkType", });
15219           internal_static_openxc_NetworkDataSettings_descriptor =
15220             getDescriptor().getMessageTypes().get(9);
15221           internal_static_openxc_NetworkDataSettings_fieldAccessorTable = new
15222             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15223               internal_static_openxc_NetworkDataSettings_descriptor,
15224               new java.lang.String[] { "APN", });
15225           internal_static_openxc_ServerConnectSettings_descriptor =
15226             getDescriptor().getMessageTypes().get(10);
15227           internal_static_openxc_ServerConnectSettings_fieldAccessorTable = new
15228             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15229               internal_static_openxc_ServerConnectSettings_descriptor,
15230               new java.lang.String[] { "Host", "Port", });
15231           internal_static_openxc_ModemConfigurationCommand_descriptor =
15232             getDescriptor().getMessageTypes().get(11);
15233           internal_static_openxc_ModemConfigurationCommand_fieldAccessorTable = new
15234             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15235               internal_static_openxc_ModemConfigurationCommand_descriptor,
15236               new java.lang.String[] { "NetworkOperatorSettings", "NetworkDataSettings", "ServerConnectSettings", });
15237           internal_static_openxc_RTCConfigurationCommand_descriptor =
15238             getDescriptor().getMessageTypes().get(12);
15239           internal_static_openxc_RTCConfigurationCommand_fieldAccessorTable = new
15240             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15241               internal_static_openxc_RTCConfigurationCommand_descriptor,
15242               new java.lang.String[] { "UnixTime", });
15243           internal_static_openxc_CommandResponse_descriptor =
15244             getDescriptor().getMessageTypes().get(13);
15245           internal_static_openxc_CommandResponse_fieldAccessorTable = new
15246             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15247               internal_static_openxc_CommandResponse_descriptor,
15248               new java.lang.String[] { "Type", "Message", "Status", });
15249           internal_static_openxc_DiagnosticRequest_descriptor =
15250             getDescriptor().getMessageTypes().get(14);
15251           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
15252             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15253               internal_static_openxc_DiagnosticRequest_descriptor,
15254               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Frequency", "Name", "DecodedType", });
15255           internal_static_openxc_DiagnosticResponse_descriptor =
15256             getDescriptor().getMessageTypes().get(15);
15257           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
15258             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15259               internal_static_openxc_DiagnosticResponse_descriptor,
15260               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", });
15261           internal_static_openxc_DynamicField_descriptor =
15262             getDescriptor().getMessageTypes().get(16);
15263           internal_static_openxc_DynamicField_fieldAccessorTable = new
15264             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15265               internal_static_openxc_DynamicField_descriptor,
15266               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", });
15267           internal_static_openxc_SimpleMessage_descriptor =
15268             getDescriptor().getMessageTypes().get(17);
15269           internal_static_openxc_SimpleMessage_fieldAccessorTable = new
15270             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
15271               internal_static_openxc_SimpleMessage_descriptor,
15272               new java.lang.String[] { "Name", "Value", "Event", });
15273           return null;
15274         }
15275       };
15276     com.google.protobuf.Descriptors.FileDescriptor
15277       .internalBuildGeneratedFileFrom(descriptorData,
15278         new com.google.protobuf.Descriptors.FileDescriptor[] {
15279         }, assigner);
15280   }
15281
15282   // @@protoc_insertion_point(outer_class_scope)
15283 }