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.RawMessage raw_message = 2;
  25     /**
  26      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  27      */
  28     boolean hasRawMessage();
  29     /**
  30      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  31      */
  32     com.openxc.BinaryMessages.RawMessage getRawMessage();
  33     /**
  34      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  35      */
  36     com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder();
  37
  38     // optional .openxc.TranslatedMessage translated_message = 3;
  39     /**
  40      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  41      */
  42     boolean hasTranslatedMessage();
  43     /**
  44      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  45      */
  46     com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage();
  47     /**
  48      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  49      */
  50     com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder();
  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   /**
  95    * Protobuf type {@code openxc.VehicleMessage}
  96    */
  97   public static final class VehicleMessage extends
  98       com.google.protobuf.GeneratedMessage
  99       implements VehicleMessageOrBuilder {
 100     // Use VehicleMessage.newBuilder() to construct.
 101     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 102       super(builder);
 103       this.unknownFields = builder.getUnknownFields();
 104     }
 105     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 106
 107     private static final VehicleMessage defaultInstance;
 108     public static VehicleMessage getDefaultInstance() {
 109       return defaultInstance;
 110     }
 111
 112     public VehicleMessage getDefaultInstanceForType() {
 113       return defaultInstance;
 114     }
 115
 116     private final com.google.protobuf.UnknownFieldSet unknownFields;
 117     @java.lang.Override
 118     public final com.google.protobuf.UnknownFieldSet
 119         getUnknownFields() {
 120       return this.unknownFields;
 121     }
 122     private VehicleMessage(
 123         com.google.protobuf.CodedInputStream input,
 124         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 125         throws com.google.protobuf.InvalidProtocolBufferException {
 126       initFields();
 127       int mutable_bitField0_ = 0;
 128       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 129           com.google.protobuf.UnknownFieldSet.newBuilder();
 130       try {
 131         boolean done = false;
 132         while (!done) {
 133           int tag = input.readTag();
 134           switch (tag) {
 135             case 0:
 136               done = true;
 137               break;
 138             default: {
 139               if (!parseUnknownField(input, unknownFields,
 140                                      extensionRegistry, tag)) {
 141                 done = true;
 142               }
 143               break;
 144             }
 145             case 8: {
 146               int rawValue = input.readEnum();
 147               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 148               if (value == null) {
 149                 unknownFields.mergeVarintField(1, rawValue);
 150               } else {
 151                 bitField0_ |= 0x00000001;
 152                 type_ = value;
 153               }
 154               break;
 155             }
 156             case 18: {
 157               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
 158               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 159                 subBuilder = rawMessage_.toBuilder();
 160               }
 161               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
 162               if (subBuilder != null) {
 163                 subBuilder.mergeFrom(rawMessage_);
 164                 rawMessage_ = subBuilder.buildPartial();
 165               }
 166               bitField0_ |= 0x00000002;
 167               break;
 168             }
 169             case 26: {
 170               com.openxc.BinaryMessages.TranslatedMessage.Builder subBuilder = null;
 171               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 172                 subBuilder = translatedMessage_.toBuilder();
 173               }
 174               translatedMessage_ = input.readMessage(com.openxc.BinaryMessages.TranslatedMessage.PARSER, extensionRegistry);
 175               if (subBuilder != null) {
 176                 subBuilder.mergeFrom(translatedMessage_);
 177                 translatedMessage_ = subBuilder.buildPartial();
 178               }
 179               bitField0_ |= 0x00000004;
 180               break;
 181             }
 182             case 34: {
 183               com.openxc.BinaryMessages.DiagnosticResponse.Builder subBuilder = null;
 184               if (((bitField0_ & 0x00000008) == 0x00000008)) {
 185                 subBuilder = diagnosticResponse_.toBuilder();
 186               }
 187               diagnosticResponse_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticResponse.PARSER, extensionRegistry);
 188               if (subBuilder != null) {
 189                 subBuilder.mergeFrom(diagnosticResponse_);
 190                 diagnosticResponse_ = subBuilder.buildPartial();
 191               }
 192               bitField0_ |= 0x00000008;
 193               break;
 194             }
 195             case 42: {
 196               com.openxc.BinaryMessages.ControlCommand.Builder subBuilder = null;
 197               if (((bitField0_ & 0x00000010) == 0x00000010)) {
 198                 subBuilder = controlCommand_.toBuilder();
 199               }
 200               controlCommand_ = input.readMessage(com.openxc.BinaryMessages.ControlCommand.PARSER, extensionRegistry);
 201               if (subBuilder != null) {
 202                 subBuilder.mergeFrom(controlCommand_);
 203                 controlCommand_ = subBuilder.buildPartial();
 204               }
 205               bitField0_ |= 0x00000010;
 206               break;
 207             }
 208             case 50: {
 209               com.openxc.BinaryMessages.CommandResponse.Builder subBuilder = null;
 210               if (((bitField0_ & 0x00000020) == 0x00000020)) {
 211                 subBuilder = commandResponse_.toBuilder();
 212               }
 213               commandResponse_ = input.readMessage(com.openxc.BinaryMessages.CommandResponse.PARSER, extensionRegistry);
 214               if (subBuilder != null) {
 215                 subBuilder.mergeFrom(commandResponse_);
 216                 commandResponse_ = subBuilder.buildPartial();
 217               }
 218               bitField0_ |= 0x00000020;
 219               break;
 220             }
 221           }
 222         }
 223       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 224         throw e.setUnfinishedMessage(this);
 225       } catch (java.io.IOException e) {
 226         throw new com.google.protobuf.InvalidProtocolBufferException(
 227             e.getMessage()).setUnfinishedMessage(this);
 228       } finally {
 229         this.unknownFields = unknownFields.build();
 230         makeExtensionsImmutable();
 231       }
 232     }
 233     public static final com.google.protobuf.Descriptors.Descriptor
 234         getDescriptor() {
 235       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 236     }
 237
 238     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 239         internalGetFieldAccessorTable() {
 240       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 241           .ensureFieldAccessorsInitialized(
 242               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 243     }
 244
 245     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 246         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 247       public VehicleMessage parsePartialFrom(
 248           com.google.protobuf.CodedInputStream input,
 249           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 250           throws com.google.protobuf.InvalidProtocolBufferException {
 251         return new VehicleMessage(input, extensionRegistry);
 252       }
 253     };
 254
 255     @java.lang.Override
 256     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 257       return PARSER;
 258     }
 259
 260     /**
 261      * Protobuf enum {@code openxc.VehicleMessage.Type}
 262      */
 263     public enum Type
 264         implements com.google.protobuf.ProtocolMessageEnum {
 265       /**
 266        * <code>RAW = 1;</code>
 267        */
 268       RAW(0, 1),
 269       /**
 270        * <code>TRANSLATED = 2;</code>
 271        */
 272       TRANSLATED(1, 2),
 273       /**
 274        * <code>DIAGNOSTIC = 3;</code>
 275        */
 276       DIAGNOSTIC(2, 3),
 277       /**
 278        * <code>CONTROL_COMMAND = 4;</code>
 279        */
 280       CONTROL_COMMAND(3, 4),
 281       /**
 282        * <code>COMMAND_RESPONSE = 5;</code>
 283        */
 284       COMMAND_RESPONSE(4, 5),
 285       ;
 286
 287       /**
 288        * <code>RAW = 1;</code>
 289        */
 290       public static final int RAW_VALUE = 1;
 291       /**
 292        * <code>TRANSLATED = 2;</code>
 293        */
 294       public static final int TRANSLATED_VALUE = 2;
 295       /**
 296        * <code>DIAGNOSTIC = 3;</code>
 297        */
 298       public static final int DIAGNOSTIC_VALUE = 3;
 299       /**
 300        * <code>CONTROL_COMMAND = 4;</code>
 301        */
 302       public static final int CONTROL_COMMAND_VALUE = 4;
 303       /**
 304        * <code>COMMAND_RESPONSE = 5;</code>
 305        */
 306       public static final int COMMAND_RESPONSE_VALUE = 5;
 307
 308
 309       public final int getNumber() { return value; }
 310
 311       public static Type valueOf(int value) {
 312         switch (value) {
 313           case 1: return RAW;
 314           case 2: return TRANSLATED;
 315           case 3: return DIAGNOSTIC;
 316           case 4: return CONTROL_COMMAND;
 317           case 5: return COMMAND_RESPONSE;
 318           default: return null;
 319         }
 320       }
 321
 322       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 323           internalGetValueMap() {
 324         return internalValueMap;
 325       }
 326       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 327           internalValueMap =
 328             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 329               public Type findValueByNumber(int number) {
 330                 return Type.valueOf(number);
 331               }
 332             };
 333
 334       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 335           getValueDescriptor() {
 336         return getDescriptor().getValues().get(index);
 337       }
 338       public final com.google.protobuf.Descriptors.EnumDescriptor
 339           getDescriptorForType() {
 340         return getDescriptor();
 341       }
 342       public static final com.google.protobuf.Descriptors.EnumDescriptor
 343           getDescriptor() {
 344         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 345       }
 346
 347       private static final Type[] VALUES = values();
 348
 349       public static Type valueOf(
 350           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 351         if (desc.getType() != getDescriptor()) {
 352           throw new java.lang.IllegalArgumentException(
 353             "EnumValueDescriptor is not for this type.");
 354         }
 355         return VALUES[desc.getIndex()];
 356       }
 357
 358       private final int index;
 359       private final int value;
 360
 361       private Type(int index, int value) {
 362         this.index = index;
 363         this.value = value;
 364       }
 365
 366       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 367     }
 368
 369     private int bitField0_;
 370     // optional .openxc.VehicleMessage.Type type = 1;
 371     public static final int TYPE_FIELD_NUMBER = 1;
 372     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 373     /**
 374      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 375      */
 376     public boolean hasType() {
 377       return ((bitField0_ & 0x00000001) == 0x00000001);
 378     }
 379     /**
 380      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 381      */
 382     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 383       return type_;
 384     }
 385
 386     // optional .openxc.RawMessage raw_message = 2;
 387     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
 388     private com.openxc.BinaryMessages.RawMessage rawMessage_;
 389     /**
 390      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 391      */
 392     public boolean hasRawMessage() {
 393       return ((bitField0_ & 0x00000002) == 0x00000002);
 394     }
 395     /**
 396      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 397      */
 398     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 399       return rawMessage_;
 400     }
 401     /**
 402      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 403      */
 404     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 405       return rawMessage_;
 406     }
 407
 408     // optional .openxc.TranslatedMessage translated_message = 3;
 409     public static final int TRANSLATED_MESSAGE_FIELD_NUMBER = 3;
 410     private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_;
 411     /**
 412      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 413      */
 414     public boolean hasTranslatedMessage() {
 415       return ((bitField0_ & 0x00000004) == 0x00000004);
 416     }
 417     /**
 418      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 419      */
 420     public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 421       return translatedMessage_;
 422     }
 423     /**
 424      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 425      */
 426     public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 427       return translatedMessage_;
 428     }
 429
 430     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
 431     public static final int DIAGNOSTIC_RESPONSE_FIELD_NUMBER = 4;
 432     private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_;
 433     /**
 434      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 435      */
 436     public boolean hasDiagnosticResponse() {
 437       return ((bitField0_ & 0x00000008) == 0x00000008);
 438     }
 439     /**
 440      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 441      */
 442     public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
 443       return diagnosticResponse_;
 444     }
 445     /**
 446      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 447      */
 448     public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
 449       return diagnosticResponse_;
 450     }
 451
 452     // optional .openxc.ControlCommand control_command = 5;
 453     public static final int CONTROL_COMMAND_FIELD_NUMBER = 5;
 454     private com.openxc.BinaryMessages.ControlCommand controlCommand_;
 455     /**
 456      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 457      */
 458     public boolean hasControlCommand() {
 459       return ((bitField0_ & 0x00000010) == 0x00000010);
 460     }
 461     /**
 462      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 463      */
 464     public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
 465       return controlCommand_;
 466     }
 467     /**
 468      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 469      */
 470     public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
 471       return controlCommand_;
 472     }
 473
 474     // optional .openxc.CommandResponse command_response = 6;
 475     public static final int COMMAND_RESPONSE_FIELD_NUMBER = 6;
 476     private com.openxc.BinaryMessages.CommandResponse commandResponse_;
 477     /**
 478      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 479      */
 480     public boolean hasCommandResponse() {
 481       return ((bitField0_ & 0x00000020) == 0x00000020);
 482     }
 483     /**
 484      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 485      */
 486     public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
 487       return commandResponse_;
 488     }
 489     /**
 490      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 491      */
 492     public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
 493       return commandResponse_;
 494     }
 495
 496     private void initFields() {
 497       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 498       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 499       translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 500       diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 501       controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 502       commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 503     }
 504     private byte memoizedIsInitialized = -1;
 505     public final boolean isInitialized() {
 506       byte isInitialized = memoizedIsInitialized;
 507       if (isInitialized != -1) return isInitialized == 1;
 508
 509       memoizedIsInitialized = 1;
 510       return true;
 511     }
 512
 513     public void writeTo(com.google.protobuf.CodedOutputStream output)
 514                         throws java.io.IOException {
 515       getSerializedSize();
 516       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 517         output.writeEnum(1, type_.getNumber());
 518       }
 519       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 520         output.writeMessage(2, rawMessage_);
 521       }
 522       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 523         output.writeMessage(3, translatedMessage_);
 524       }
 525       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 526         output.writeMessage(4, diagnosticResponse_);
 527       }
 528       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 529         output.writeMessage(5, controlCommand_);
 530       }
 531       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 532         output.writeMessage(6, commandResponse_);
 533       }
 534       getUnknownFields().writeTo(output);
 535     }
 536
 537     private int memoizedSerializedSize = -1;
 538     public int getSerializedSize() {
 539       int size = memoizedSerializedSize;
 540       if (size != -1) return size;
 541
 542       size = 0;
 543       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 544         size += com.google.protobuf.CodedOutputStream
 545           .computeEnumSize(1, type_.getNumber());
 546       }
 547       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 548         size += com.google.protobuf.CodedOutputStream
 549           .computeMessageSize(2, rawMessage_);
 550       }
 551       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 552         size += com.google.protobuf.CodedOutputStream
 553           .computeMessageSize(3, translatedMessage_);
 554       }
 555       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 556         size += com.google.protobuf.CodedOutputStream
 557           .computeMessageSize(4, diagnosticResponse_);
 558       }
 559       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 560         size += com.google.protobuf.CodedOutputStream
 561           .computeMessageSize(5, controlCommand_);
 562       }
 563       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 564         size += com.google.protobuf.CodedOutputStream
 565           .computeMessageSize(6, commandResponse_);
 566       }
 567       size += getUnknownFields().getSerializedSize();
 568       memoizedSerializedSize = size;
 569       return size;
 570     }
 571
 572     private static final long serialVersionUID = 0L;
 573     @java.lang.Override
 574     protected java.lang.Object writeReplace()
 575         throws java.io.ObjectStreamException {
 576       return super.writeReplace();
 577     }
 578
 579     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 580         com.google.protobuf.ByteString data)
 581         throws com.google.protobuf.InvalidProtocolBufferException {
 582       return PARSER.parseFrom(data);
 583     }
 584     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 585         com.google.protobuf.ByteString data,
 586         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 587         throws com.google.protobuf.InvalidProtocolBufferException {
 588       return PARSER.parseFrom(data, extensionRegistry);
 589     }
 590     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 591         throws com.google.protobuf.InvalidProtocolBufferException {
 592       return PARSER.parseFrom(data);
 593     }
 594     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 595         byte[] data,
 596         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 597         throws com.google.protobuf.InvalidProtocolBufferException {
 598       return PARSER.parseFrom(data, extensionRegistry);
 599     }
 600     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 601         throws java.io.IOException {
 602       return PARSER.parseFrom(input);
 603     }
 604     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 605         java.io.InputStream input,
 606         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 607         throws java.io.IOException {
 608       return PARSER.parseFrom(input, extensionRegistry);
 609     }
 610     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 611         throws java.io.IOException {
 612       return PARSER.parseDelimitedFrom(input);
 613     }
 614     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 615         java.io.InputStream input,
 616         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 617         throws java.io.IOException {
 618       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 619     }
 620     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 621         com.google.protobuf.CodedInputStream input)
 622         throws java.io.IOException {
 623       return PARSER.parseFrom(input);
 624     }
 625     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 626         com.google.protobuf.CodedInputStream input,
 627         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 628         throws java.io.IOException {
 629       return PARSER.parseFrom(input, extensionRegistry);
 630     }
 631
 632     public static Builder newBuilder() { return Builder.create(); }
 633     public Builder newBuilderForType() { return newBuilder(); }
 634     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 635       return newBuilder().mergeFrom(prototype);
 636     }
 637     public Builder toBuilder() { return newBuilder(this); }
 638
 639     @java.lang.Override
 640     protected Builder newBuilderForType(
 641         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 642       Builder builder = new Builder(parent);
 643       return builder;
 644     }
 645     /**
 646      * Protobuf type {@code openxc.VehicleMessage}
 647      */
 648     public static final class Builder extends
 649         com.google.protobuf.GeneratedMessage.Builder<Builder>
 650        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 651       public static final com.google.protobuf.Descriptors.Descriptor
 652           getDescriptor() {
 653         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 654       }
 655
 656       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 657           internalGetFieldAccessorTable() {
 658         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 659             .ensureFieldAccessorsInitialized(
 660                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 661       }
 662
 663       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 664       private Builder() {
 665         maybeForceBuilderInitialization();
 666       }
 667
 668       private Builder(
 669           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 670         super(parent);
 671         maybeForceBuilderInitialization();
 672       }
 673       private void maybeForceBuilderInitialization() {
 674         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 675           getRawMessageFieldBuilder();
 676           getTranslatedMessageFieldBuilder();
 677           getDiagnosticResponseFieldBuilder();
 678           getControlCommandFieldBuilder();
 679           getCommandResponseFieldBuilder();
 680         }
 681       }
 682       private static Builder create() {
 683         return new Builder();
 684       }
 685
 686       public Builder clear() {
 687         super.clear();
 688         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 689         bitField0_ = (bitField0_ & ~0x00000001);
 690         if (rawMessageBuilder_ == null) {
 691           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 692         } else {
 693           rawMessageBuilder_.clear();
 694         }
 695         bitField0_ = (bitField0_ & ~0x00000002);
 696         if (translatedMessageBuilder_ == null) {
 697           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 698         } else {
 699           translatedMessageBuilder_.clear();
 700         }
 701         bitField0_ = (bitField0_ & ~0x00000004);
 702         if (diagnosticResponseBuilder_ == null) {
 703           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 704         } else {
 705           diagnosticResponseBuilder_.clear();
 706         }
 707         bitField0_ = (bitField0_ & ~0x00000008);
 708         if (controlCommandBuilder_ == null) {
 709           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 710         } else {
 711           controlCommandBuilder_.clear();
 712         }
 713         bitField0_ = (bitField0_ & ~0x00000010);
 714         if (commandResponseBuilder_ == null) {
 715           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 716         } else {
 717           commandResponseBuilder_.clear();
 718         }
 719         bitField0_ = (bitField0_ & ~0x00000020);
 720         return this;
 721       }
 722
 723       public Builder clone() {
 724         return create().mergeFrom(buildPartial());
 725       }
 726
 727       public com.google.protobuf.Descriptors.Descriptor
 728           getDescriptorForType() {
 729         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 730       }
 731
 732       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 733         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 734       }
 735
 736       public com.openxc.BinaryMessages.VehicleMessage build() {
 737         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 738         if (!result.isInitialized()) {
 739           throw newUninitializedMessageException(result);
 740         }
 741         return result;
 742       }
 743
 744       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 745         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 746         int from_bitField0_ = bitField0_;
 747         int to_bitField0_ = 0;
 748         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 749           to_bitField0_ |= 0x00000001;
 750         }
 751         result.type_ = type_;
 752         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 753           to_bitField0_ |= 0x00000002;
 754         }
 755         if (rawMessageBuilder_ == null) {
 756           result.rawMessage_ = rawMessage_;
 757         } else {
 758           result.rawMessage_ = rawMessageBuilder_.build();
 759         }
 760         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 761           to_bitField0_ |= 0x00000004;
 762         }
 763         if (translatedMessageBuilder_ == null) {
 764           result.translatedMessage_ = translatedMessage_;
 765         } else {
 766           result.translatedMessage_ = translatedMessageBuilder_.build();
 767         }
 768         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 769           to_bitField0_ |= 0x00000008;
 770         }
 771         if (diagnosticResponseBuilder_ == null) {
 772           result.diagnosticResponse_ = diagnosticResponse_;
 773         } else {
 774           result.diagnosticResponse_ = diagnosticResponseBuilder_.build();
 775         }
 776         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
 777           to_bitField0_ |= 0x00000010;
 778         }
 779         if (controlCommandBuilder_ == null) {
 780           result.controlCommand_ = controlCommand_;
 781         } else {
 782           result.controlCommand_ = controlCommandBuilder_.build();
 783         }
 784         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
 785           to_bitField0_ |= 0x00000020;
 786         }
 787         if (commandResponseBuilder_ == null) {
 788           result.commandResponse_ = commandResponse_;
 789         } else {
 790           result.commandResponse_ = commandResponseBuilder_.build();
 791         }
 792         result.bitField0_ = to_bitField0_;
 793         onBuilt();
 794         return result;
 795       }
 796
 797       public Builder mergeFrom(com.google.protobuf.Message other) {
 798         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 799           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 800         } else {
 801           super.mergeFrom(other);
 802           return this;
 803         }
 804       }
 805
 806       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 807         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 808         if (other.hasType()) {
 809           setType(other.getType());
 810         }
 811         if (other.hasRawMessage()) {
 812           mergeRawMessage(other.getRawMessage());
 813         }
 814         if (other.hasTranslatedMessage()) {
 815           mergeTranslatedMessage(other.getTranslatedMessage());
 816         }
 817         if (other.hasDiagnosticResponse()) {
 818           mergeDiagnosticResponse(other.getDiagnosticResponse());
 819         }
 820         if (other.hasControlCommand()) {
 821           mergeControlCommand(other.getControlCommand());
 822         }
 823         if (other.hasCommandResponse()) {
 824           mergeCommandResponse(other.getCommandResponse());
 825         }
 826         this.mergeUnknownFields(other.getUnknownFields());
 827         return this;
 828       }
 829
 830       public final boolean isInitialized() {
 831         return true;
 832       }
 833
 834       public Builder mergeFrom(
 835           com.google.protobuf.CodedInputStream input,
 836           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 837           throws java.io.IOException {
 838         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
 839         try {
 840           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 841         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 842           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
 843           throw e;
 844         } finally {
 845           if (parsedMessage != null) {
 846             mergeFrom(parsedMessage);
 847           }
 848         }
 849         return this;
 850       }
 851       private int bitField0_;
 852
 853       // optional .openxc.VehicleMessage.Type type = 1;
 854       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 855       /**
 856        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 857        */
 858       public boolean hasType() {
 859         return ((bitField0_ & 0x00000001) == 0x00000001);
 860       }
 861       /**
 862        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 863        */
 864       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 865         return type_;
 866       }
 867       /**
 868        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 869        */
 870       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 871         if (value == null) {
 872           throw new NullPointerException();
 873         }
 874         bitField0_ |= 0x00000001;
 875         type_ = value;
 876         onChanged();
 877         return this;
 878       }
 879       /**
 880        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 881        */
 882       public Builder clearType() {
 883         bitField0_ = (bitField0_ & ~0x00000001);
 884         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 885         onChanged();
 886         return this;
 887       }
 888
 889       // optional .openxc.RawMessage raw_message = 2;
 890       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 891       private com.google.protobuf.SingleFieldBuilder<
 892           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
 893       /**
 894        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 895        */
 896       public boolean hasRawMessage() {
 897         return ((bitField0_ & 0x00000002) == 0x00000002);
 898       }
 899       /**
 900        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 901        */
 902       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 903         if (rawMessageBuilder_ == null) {
 904           return rawMessage_;
 905         } else {
 906           return rawMessageBuilder_.getMessage();
 907         }
 908       }
 909       /**
 910        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 911        */
 912       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 913         if (rawMessageBuilder_ == null) {
 914           if (value == null) {
 915             throw new NullPointerException();
 916           }
 917           rawMessage_ = value;
 918           onChanged();
 919         } else {
 920           rawMessageBuilder_.setMessage(value);
 921         }
 922         bitField0_ |= 0x00000002;
 923         return this;
 924       }
 925       /**
 926        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 927        */
 928       public Builder setRawMessage(
 929           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
 930         if (rawMessageBuilder_ == null) {
 931           rawMessage_ = builderForValue.build();
 932           onChanged();
 933         } else {
 934           rawMessageBuilder_.setMessage(builderForValue.build());
 935         }
 936         bitField0_ |= 0x00000002;
 937         return this;
 938       }
 939       /**
 940        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 941        */
 942       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 943         if (rawMessageBuilder_ == null) {
 944           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 945               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
 946             rawMessage_ =
 947               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
 948           } else {
 949             rawMessage_ = value;
 950           }
 951           onChanged();
 952         } else {
 953           rawMessageBuilder_.mergeFrom(value);
 954         }
 955         bitField0_ |= 0x00000002;
 956         return this;
 957       }
 958       /**
 959        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 960        */
 961       public Builder clearRawMessage() {
 962         if (rawMessageBuilder_ == null) {
 963           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 964           onChanged();
 965         } else {
 966           rawMessageBuilder_.clear();
 967         }
 968         bitField0_ = (bitField0_ & ~0x00000002);
 969         return this;
 970       }
 971       /**
 972        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 973        */
 974       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
 975         bitField0_ |= 0x00000002;
 976         onChanged();
 977         return getRawMessageFieldBuilder().getBuilder();
 978       }
 979       /**
 980        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 981        */
 982       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 983         if (rawMessageBuilder_ != null) {
 984           return rawMessageBuilder_.getMessageOrBuilder();
 985         } else {
 986           return rawMessage_;
 987         }
 988       }
 989       /**
 990        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 991        */
 992       private com.google.protobuf.SingleFieldBuilder<
 993           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>
 994           getRawMessageFieldBuilder() {
 995         if (rawMessageBuilder_ == null) {
 996           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 997               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
 998                   rawMessage_,
 999                   getParentForChildren(),
1000                   isClean());
1001           rawMessage_ = null;
1002         }
1003         return rawMessageBuilder_;
1004       }
1005
1006       // optional .openxc.TranslatedMessage translated_message = 3;
1007       private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1008       private com.google.protobuf.SingleFieldBuilder<
1009           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> translatedMessageBuilder_;
1010       /**
1011        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1012        */
1013       public boolean hasTranslatedMessage() {
1014         return ((bitField0_ & 0x00000004) == 0x00000004);
1015       }
1016       /**
1017        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1018        */
1019       public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
1020         if (translatedMessageBuilder_ == null) {
1021           return translatedMessage_;
1022         } else {
1023           return translatedMessageBuilder_.getMessage();
1024         }
1025       }
1026       /**
1027        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1028        */
1029       public Builder setTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1030         if (translatedMessageBuilder_ == null) {
1031           if (value == null) {
1032             throw new NullPointerException();
1033           }
1034           translatedMessage_ = value;
1035           onChanged();
1036         } else {
1037           translatedMessageBuilder_.setMessage(value);
1038         }
1039         bitField0_ |= 0x00000004;
1040         return this;
1041       }
1042       /**
1043        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1044        */
1045       public Builder setTranslatedMessage(
1046           com.openxc.BinaryMessages.TranslatedMessage.Builder builderForValue) {
1047         if (translatedMessageBuilder_ == null) {
1048           translatedMessage_ = builderForValue.build();
1049           onChanged();
1050         } else {
1051           translatedMessageBuilder_.setMessage(builderForValue.build());
1052         }
1053         bitField0_ |= 0x00000004;
1054         return this;
1055       }
1056       /**
1057        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1058        */
1059       public Builder mergeTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1060         if (translatedMessageBuilder_ == null) {
1061           if (((bitField0_ & 0x00000004) == 0x00000004) &&
1062               translatedMessage_ != com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) {
1063             translatedMessage_ =
1064               com.openxc.BinaryMessages.TranslatedMessage.newBuilder(translatedMessage_).mergeFrom(value).buildPartial();
1065           } else {
1066             translatedMessage_ = value;
1067           }
1068           onChanged();
1069         } else {
1070           translatedMessageBuilder_.mergeFrom(value);
1071         }
1072         bitField0_ |= 0x00000004;
1073         return this;
1074       }
1075       /**
1076        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1077        */
1078       public Builder clearTranslatedMessage() {
1079         if (translatedMessageBuilder_ == null) {
1080           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1081           onChanged();
1082         } else {
1083           translatedMessageBuilder_.clear();
1084         }
1085         bitField0_ = (bitField0_ & ~0x00000004);
1086         return this;
1087       }
1088       /**
1089        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1090        */
1091       public com.openxc.BinaryMessages.TranslatedMessage.Builder getTranslatedMessageBuilder() {
1092         bitField0_ |= 0x00000004;
1093         onChanged();
1094         return getTranslatedMessageFieldBuilder().getBuilder();
1095       }
1096       /**
1097        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1098        */
1099       public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
1100         if (translatedMessageBuilder_ != null) {
1101           return translatedMessageBuilder_.getMessageOrBuilder();
1102         } else {
1103           return translatedMessage_;
1104         }
1105       }
1106       /**
1107        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1108        */
1109       private com.google.protobuf.SingleFieldBuilder<
1110           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>
1111           getTranslatedMessageFieldBuilder() {
1112         if (translatedMessageBuilder_ == null) {
1113           translatedMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1114               com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>(
1115                   translatedMessage_,
1116                   getParentForChildren(),
1117                   isClean());
1118           translatedMessage_ = null;
1119         }
1120         return translatedMessageBuilder_;
1121       }
1122
1123       // optional .openxc.DiagnosticResponse diagnostic_response = 4;
1124       private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1125       private com.google.protobuf.SingleFieldBuilder<
1126           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> diagnosticResponseBuilder_;
1127       /**
1128        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1129        */
1130       public boolean hasDiagnosticResponse() {
1131         return ((bitField0_ & 0x00000008) == 0x00000008);
1132       }
1133       /**
1134        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1135        */
1136       public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
1137         if (diagnosticResponseBuilder_ == null) {
1138           return diagnosticResponse_;
1139         } else {
1140           return diagnosticResponseBuilder_.getMessage();
1141         }
1142       }
1143       /**
1144        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1145        */
1146       public Builder setDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1147         if (diagnosticResponseBuilder_ == null) {
1148           if (value == null) {
1149             throw new NullPointerException();
1150           }
1151           diagnosticResponse_ = value;
1152           onChanged();
1153         } else {
1154           diagnosticResponseBuilder_.setMessage(value);
1155         }
1156         bitField0_ |= 0x00000008;
1157         return this;
1158       }
1159       /**
1160        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1161        */
1162       public Builder setDiagnosticResponse(
1163           com.openxc.BinaryMessages.DiagnosticResponse.Builder builderForValue) {
1164         if (diagnosticResponseBuilder_ == null) {
1165           diagnosticResponse_ = builderForValue.build();
1166           onChanged();
1167         } else {
1168           diagnosticResponseBuilder_.setMessage(builderForValue.build());
1169         }
1170         bitField0_ |= 0x00000008;
1171         return this;
1172       }
1173       /**
1174        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1175        */
1176       public Builder mergeDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1177         if (diagnosticResponseBuilder_ == null) {
1178           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1179               diagnosticResponse_ != com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) {
1180             diagnosticResponse_ =
1181               com.openxc.BinaryMessages.DiagnosticResponse.newBuilder(diagnosticResponse_).mergeFrom(value).buildPartial();
1182           } else {
1183             diagnosticResponse_ = value;
1184           }
1185           onChanged();
1186         } else {
1187           diagnosticResponseBuilder_.mergeFrom(value);
1188         }
1189         bitField0_ |= 0x00000008;
1190         return this;
1191       }
1192       /**
1193        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1194        */
1195       public Builder clearDiagnosticResponse() {
1196         if (diagnosticResponseBuilder_ == null) {
1197           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1198           onChanged();
1199         } else {
1200           diagnosticResponseBuilder_.clear();
1201         }
1202         bitField0_ = (bitField0_ & ~0x00000008);
1203         return this;
1204       }
1205       /**
1206        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1207        */
1208       public com.openxc.BinaryMessages.DiagnosticResponse.Builder getDiagnosticResponseBuilder() {
1209         bitField0_ |= 0x00000008;
1210         onChanged();
1211         return getDiagnosticResponseFieldBuilder().getBuilder();
1212       }
1213       /**
1214        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1215        */
1216       public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
1217         if (diagnosticResponseBuilder_ != null) {
1218           return diagnosticResponseBuilder_.getMessageOrBuilder();
1219         } else {
1220           return diagnosticResponse_;
1221         }
1222       }
1223       /**
1224        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1225        */
1226       private com.google.protobuf.SingleFieldBuilder<
1227           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>
1228           getDiagnosticResponseFieldBuilder() {
1229         if (diagnosticResponseBuilder_ == null) {
1230           diagnosticResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1231               com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>(
1232                   diagnosticResponse_,
1233                   getParentForChildren(),
1234                   isClean());
1235           diagnosticResponse_ = null;
1236         }
1237         return diagnosticResponseBuilder_;
1238       }
1239
1240       // optional .openxc.ControlCommand control_command = 5;
1241       private com.openxc.BinaryMessages.ControlCommand controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1242       private com.google.protobuf.SingleFieldBuilder<
1243           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> controlCommandBuilder_;
1244       /**
1245        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1246        */
1247       public boolean hasControlCommand() {
1248         return ((bitField0_ & 0x00000010) == 0x00000010);
1249       }
1250       /**
1251        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1252        */
1253       public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
1254         if (controlCommandBuilder_ == null) {
1255           return controlCommand_;
1256         } else {
1257           return controlCommandBuilder_.getMessage();
1258         }
1259       }
1260       /**
1261        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1262        */
1263       public Builder setControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1264         if (controlCommandBuilder_ == null) {
1265           if (value == null) {
1266             throw new NullPointerException();
1267           }
1268           controlCommand_ = value;
1269           onChanged();
1270         } else {
1271           controlCommandBuilder_.setMessage(value);
1272         }
1273         bitField0_ |= 0x00000010;
1274         return this;
1275       }
1276       /**
1277        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1278        */
1279       public Builder setControlCommand(
1280           com.openxc.BinaryMessages.ControlCommand.Builder builderForValue) {
1281         if (controlCommandBuilder_ == null) {
1282           controlCommand_ = builderForValue.build();
1283           onChanged();
1284         } else {
1285           controlCommandBuilder_.setMessage(builderForValue.build());
1286         }
1287         bitField0_ |= 0x00000010;
1288         return this;
1289       }
1290       /**
1291        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1292        */
1293       public Builder mergeControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1294         if (controlCommandBuilder_ == null) {
1295           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1296               controlCommand_ != com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) {
1297             controlCommand_ =
1298               com.openxc.BinaryMessages.ControlCommand.newBuilder(controlCommand_).mergeFrom(value).buildPartial();
1299           } else {
1300             controlCommand_ = value;
1301           }
1302           onChanged();
1303         } else {
1304           controlCommandBuilder_.mergeFrom(value);
1305         }
1306         bitField0_ |= 0x00000010;
1307         return this;
1308       }
1309       /**
1310        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1311        */
1312       public Builder clearControlCommand() {
1313         if (controlCommandBuilder_ == null) {
1314           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1315           onChanged();
1316         } else {
1317           controlCommandBuilder_.clear();
1318         }
1319         bitField0_ = (bitField0_ & ~0x00000010);
1320         return this;
1321       }
1322       /**
1323        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1324        */
1325       public com.openxc.BinaryMessages.ControlCommand.Builder getControlCommandBuilder() {
1326         bitField0_ |= 0x00000010;
1327         onChanged();
1328         return getControlCommandFieldBuilder().getBuilder();
1329       }
1330       /**
1331        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1332        */
1333       public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
1334         if (controlCommandBuilder_ != null) {
1335           return controlCommandBuilder_.getMessageOrBuilder();
1336         } else {
1337           return controlCommand_;
1338         }
1339       }
1340       /**
1341        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1342        */
1343       private com.google.protobuf.SingleFieldBuilder<
1344           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>
1345           getControlCommandFieldBuilder() {
1346         if (controlCommandBuilder_ == null) {
1347           controlCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1348               com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>(
1349                   controlCommand_,
1350                   getParentForChildren(),
1351                   isClean());
1352           controlCommand_ = null;
1353         }
1354         return controlCommandBuilder_;
1355       }
1356
1357       // optional .openxc.CommandResponse command_response = 6;
1358       private com.openxc.BinaryMessages.CommandResponse commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1359       private com.google.protobuf.SingleFieldBuilder<
1360           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> commandResponseBuilder_;
1361       /**
1362        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1363        */
1364       public boolean hasCommandResponse() {
1365         return ((bitField0_ & 0x00000020) == 0x00000020);
1366       }
1367       /**
1368        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1369        */
1370       public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
1371         if (commandResponseBuilder_ == null) {
1372           return commandResponse_;
1373         } else {
1374           return commandResponseBuilder_.getMessage();
1375         }
1376       }
1377       /**
1378        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1379        */
1380       public Builder setCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1381         if (commandResponseBuilder_ == null) {
1382           if (value == null) {
1383             throw new NullPointerException();
1384           }
1385           commandResponse_ = value;
1386           onChanged();
1387         } else {
1388           commandResponseBuilder_.setMessage(value);
1389         }
1390         bitField0_ |= 0x00000020;
1391         return this;
1392       }
1393       /**
1394        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1395        */
1396       public Builder setCommandResponse(
1397           com.openxc.BinaryMessages.CommandResponse.Builder builderForValue) {
1398         if (commandResponseBuilder_ == null) {
1399           commandResponse_ = builderForValue.build();
1400           onChanged();
1401         } else {
1402           commandResponseBuilder_.setMessage(builderForValue.build());
1403         }
1404         bitField0_ |= 0x00000020;
1405         return this;
1406       }
1407       /**
1408        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1409        */
1410       public Builder mergeCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1411         if (commandResponseBuilder_ == null) {
1412           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1413               commandResponse_ != com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) {
1414             commandResponse_ =
1415               com.openxc.BinaryMessages.CommandResponse.newBuilder(commandResponse_).mergeFrom(value).buildPartial();
1416           } else {
1417             commandResponse_ = value;
1418           }
1419           onChanged();
1420         } else {
1421           commandResponseBuilder_.mergeFrom(value);
1422         }
1423         bitField0_ |= 0x00000020;
1424         return this;
1425       }
1426       /**
1427        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1428        */
1429       public Builder clearCommandResponse() {
1430         if (commandResponseBuilder_ == null) {
1431           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1432           onChanged();
1433         } else {
1434           commandResponseBuilder_.clear();
1435         }
1436         bitField0_ = (bitField0_ & ~0x00000020);
1437         return this;
1438       }
1439       /**
1440        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1441        */
1442       public com.openxc.BinaryMessages.CommandResponse.Builder getCommandResponseBuilder() {
1443         bitField0_ |= 0x00000020;
1444         onChanged();
1445         return getCommandResponseFieldBuilder().getBuilder();
1446       }
1447       /**
1448        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1449        */
1450       public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
1451         if (commandResponseBuilder_ != null) {
1452           return commandResponseBuilder_.getMessageOrBuilder();
1453         } else {
1454           return commandResponse_;
1455         }
1456       }
1457       /**
1458        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1459        */
1460       private com.google.protobuf.SingleFieldBuilder<
1461           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>
1462           getCommandResponseFieldBuilder() {
1463         if (commandResponseBuilder_ == null) {
1464           commandResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1465               com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>(
1466                   commandResponse_,
1467                   getParentForChildren(),
1468                   isClean());
1469           commandResponse_ = null;
1470         }
1471         return commandResponseBuilder_;
1472       }
1473
1474       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1475     }
1476
1477     static {
1478       defaultInstance = new VehicleMessage(true);
1479       defaultInstance.initFields();
1480     }
1481
1482     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1483   }
1484
1485   public interface RawMessageOrBuilder
1486       extends com.google.protobuf.MessageOrBuilder {
1487
1488     // optional int32 bus = 1;
1489     /**
1490      * <code>optional int32 bus = 1;</code>
1491      */
1492     boolean hasBus();
1493     /**
1494      * <code>optional int32 bus = 1;</code>
1495      */
1496     int getBus();
1497
1498     // optional uint32 message_id = 2;
1499     /**
1500      * <code>optional uint32 message_id = 2;</code>
1501      */
1502     boolean hasMessageId();
1503     /**
1504      * <code>optional uint32 message_id = 2;</code>
1505      */
1506     int getMessageId();
1507
1508     // optional bytes data = 3;
1509     /**
1510      * <code>optional bytes data = 3;</code>
1511      */
1512     boolean hasData();
1513     /**
1514      * <code>optional bytes data = 3;</code>
1515      */
1516     com.google.protobuf.ByteString getData();
1517   }
1518   /**
1519    * Protobuf type {@code openxc.RawMessage}
1520    */
1521   public static final class RawMessage extends
1522       com.google.protobuf.GeneratedMessage
1523       implements RawMessageOrBuilder {
1524     // Use RawMessage.newBuilder() to construct.
1525     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1526       super(builder);
1527       this.unknownFields = builder.getUnknownFields();
1528     }
1529     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1530
1531     private static final RawMessage defaultInstance;
1532     public static RawMessage getDefaultInstance() {
1533       return defaultInstance;
1534     }
1535
1536     public RawMessage getDefaultInstanceForType() {
1537       return defaultInstance;
1538     }
1539
1540     private final com.google.protobuf.UnknownFieldSet unknownFields;
1541     @java.lang.Override
1542     public final com.google.protobuf.UnknownFieldSet
1543         getUnknownFields() {
1544       return this.unknownFields;
1545     }
1546     private RawMessage(
1547         com.google.protobuf.CodedInputStream input,
1548         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1549         throws com.google.protobuf.InvalidProtocolBufferException {
1550       initFields();
1551       int mutable_bitField0_ = 0;
1552       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1553           com.google.protobuf.UnknownFieldSet.newBuilder();
1554       try {
1555         boolean done = false;
1556         while (!done) {
1557           int tag = input.readTag();
1558           switch (tag) {
1559             case 0:
1560               done = true;
1561               break;
1562             default: {
1563               if (!parseUnknownField(input, unknownFields,
1564                                      extensionRegistry, tag)) {
1565                 done = true;
1566               }
1567               break;
1568             }
1569             case 8: {
1570               bitField0_ |= 0x00000001;
1571               bus_ = input.readInt32();
1572               break;
1573             }
1574             case 16: {
1575               bitField0_ |= 0x00000002;
1576               messageId_ = input.readUInt32();
1577               break;
1578             }
1579             case 26: {
1580               bitField0_ |= 0x00000004;
1581               data_ = input.readBytes();
1582               break;
1583             }
1584           }
1585         }
1586       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1587         throw e.setUnfinishedMessage(this);
1588       } catch (java.io.IOException e) {
1589         throw new com.google.protobuf.InvalidProtocolBufferException(
1590             e.getMessage()).setUnfinishedMessage(this);
1591       } finally {
1592         this.unknownFields = unknownFields.build();
1593         makeExtensionsImmutable();
1594       }
1595     }
1596     public static final com.google.protobuf.Descriptors.Descriptor
1597         getDescriptor() {
1598       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1599     }
1600
1601     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1602         internalGetFieldAccessorTable() {
1603       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1604           .ensureFieldAccessorsInitialized(
1605               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1606     }
1607
1608     public static com.google.protobuf.Parser<RawMessage> PARSER =
1609         new com.google.protobuf.AbstractParser<RawMessage>() {
1610       public RawMessage parsePartialFrom(
1611           com.google.protobuf.CodedInputStream input,
1612           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1613           throws com.google.protobuf.InvalidProtocolBufferException {
1614         return new RawMessage(input, extensionRegistry);
1615       }
1616     };
1617
1618     @java.lang.Override
1619     public com.google.protobuf.Parser<RawMessage> getParserForType() {
1620       return PARSER;
1621     }
1622
1623     private int bitField0_;
1624     // optional int32 bus = 1;
1625     public static final int BUS_FIELD_NUMBER = 1;
1626     private int bus_;
1627     /**
1628      * <code>optional int32 bus = 1;</code>
1629      */
1630     public boolean hasBus() {
1631       return ((bitField0_ & 0x00000001) == 0x00000001);
1632     }
1633     /**
1634      * <code>optional int32 bus = 1;</code>
1635      */
1636     public int getBus() {
1637       return bus_;
1638     }
1639
1640     // optional uint32 message_id = 2;
1641     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1642     private int messageId_;
1643     /**
1644      * <code>optional uint32 message_id = 2;</code>
1645      */
1646     public boolean hasMessageId() {
1647       return ((bitField0_ & 0x00000002) == 0x00000002);
1648     }
1649     /**
1650      * <code>optional uint32 message_id = 2;</code>
1651      */
1652     public int getMessageId() {
1653       return messageId_;
1654     }
1655
1656     // optional bytes data = 3;
1657     public static final int DATA_FIELD_NUMBER = 3;
1658     private com.google.protobuf.ByteString data_;
1659     /**
1660      * <code>optional bytes data = 3;</code>
1661      */
1662     public boolean hasData() {
1663       return ((bitField0_ & 0x00000004) == 0x00000004);
1664     }
1665     /**
1666      * <code>optional bytes data = 3;</code>
1667      */
1668     public com.google.protobuf.ByteString getData() {
1669       return data_;
1670     }
1671
1672     private void initFields() {
1673       bus_ = 0;
1674       messageId_ = 0;
1675       data_ = com.google.protobuf.ByteString.EMPTY;
1676     }
1677     private byte memoizedIsInitialized = -1;
1678     public final boolean isInitialized() {
1679       byte isInitialized = memoizedIsInitialized;
1680       if (isInitialized != -1) return isInitialized == 1;
1681
1682       memoizedIsInitialized = 1;
1683       return true;
1684     }
1685
1686     public void writeTo(com.google.protobuf.CodedOutputStream output)
1687                         throws java.io.IOException {
1688       getSerializedSize();
1689       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1690         output.writeInt32(1, bus_);
1691       }
1692       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1693         output.writeUInt32(2, messageId_);
1694       }
1695       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1696         output.writeBytes(3, data_);
1697       }
1698       getUnknownFields().writeTo(output);
1699     }
1700
1701     private int memoizedSerializedSize = -1;
1702     public int getSerializedSize() {
1703       int size = memoizedSerializedSize;
1704       if (size != -1) return size;
1705
1706       size = 0;
1707       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1708         size += com.google.protobuf.CodedOutputStream
1709           .computeInt32Size(1, bus_);
1710       }
1711       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1712         size += com.google.protobuf.CodedOutputStream
1713           .computeUInt32Size(2, messageId_);
1714       }
1715       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1716         size += com.google.protobuf.CodedOutputStream
1717           .computeBytesSize(3, data_);
1718       }
1719       size += getUnknownFields().getSerializedSize();
1720       memoizedSerializedSize = size;
1721       return size;
1722     }
1723
1724     private static final long serialVersionUID = 0L;
1725     @java.lang.Override
1726     protected java.lang.Object writeReplace()
1727         throws java.io.ObjectStreamException {
1728       return super.writeReplace();
1729     }
1730
1731     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1732         com.google.protobuf.ByteString data)
1733         throws com.google.protobuf.InvalidProtocolBufferException {
1734       return PARSER.parseFrom(data);
1735     }
1736     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1737         com.google.protobuf.ByteString data,
1738         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1739         throws com.google.protobuf.InvalidProtocolBufferException {
1740       return PARSER.parseFrom(data, extensionRegistry);
1741     }
1742     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
1743         throws com.google.protobuf.InvalidProtocolBufferException {
1744       return PARSER.parseFrom(data);
1745     }
1746     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1747         byte[] data,
1748         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1749         throws com.google.protobuf.InvalidProtocolBufferException {
1750       return PARSER.parseFrom(data, extensionRegistry);
1751     }
1752     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
1753         throws java.io.IOException {
1754       return PARSER.parseFrom(input);
1755     }
1756     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1757         java.io.InputStream input,
1758         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1759         throws java.io.IOException {
1760       return PARSER.parseFrom(input, extensionRegistry);
1761     }
1762     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
1763         throws java.io.IOException {
1764       return PARSER.parseDelimitedFrom(input);
1765     }
1766     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
1767         java.io.InputStream input,
1768         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1769         throws java.io.IOException {
1770       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1771     }
1772     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1773         com.google.protobuf.CodedInputStream input)
1774         throws java.io.IOException {
1775       return PARSER.parseFrom(input);
1776     }
1777     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1778         com.google.protobuf.CodedInputStream input,
1779         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1780         throws java.io.IOException {
1781       return PARSER.parseFrom(input, extensionRegistry);
1782     }
1783
1784     public static Builder newBuilder() { return Builder.create(); }
1785     public Builder newBuilderForType() { return newBuilder(); }
1786     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
1787       return newBuilder().mergeFrom(prototype);
1788     }
1789     public Builder toBuilder() { return newBuilder(this); }
1790
1791     @java.lang.Override
1792     protected Builder newBuilderForType(
1793         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1794       Builder builder = new Builder(parent);
1795       return builder;
1796     }
1797     /**
1798      * Protobuf type {@code openxc.RawMessage}
1799      */
1800     public static final class Builder extends
1801         com.google.protobuf.GeneratedMessage.Builder<Builder>
1802        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
1803       public static final com.google.protobuf.Descriptors.Descriptor
1804           getDescriptor() {
1805         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1806       }
1807
1808       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1809           internalGetFieldAccessorTable() {
1810         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1811             .ensureFieldAccessorsInitialized(
1812                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1813       }
1814
1815       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
1816       private Builder() {
1817         maybeForceBuilderInitialization();
1818       }
1819
1820       private Builder(
1821           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1822         super(parent);
1823         maybeForceBuilderInitialization();
1824       }
1825       private void maybeForceBuilderInitialization() {
1826         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1827         }
1828       }
1829       private static Builder create() {
1830         return new Builder();
1831       }
1832
1833       public Builder clear() {
1834         super.clear();
1835         bus_ = 0;
1836         bitField0_ = (bitField0_ & ~0x00000001);
1837         messageId_ = 0;
1838         bitField0_ = (bitField0_ & ~0x00000002);
1839         data_ = com.google.protobuf.ByteString.EMPTY;
1840         bitField0_ = (bitField0_ & ~0x00000004);
1841         return this;
1842       }
1843
1844       public Builder clone() {
1845         return create().mergeFrom(buildPartial());
1846       }
1847
1848       public com.google.protobuf.Descriptors.Descriptor
1849           getDescriptorForType() {
1850         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1851       }
1852
1853       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
1854         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1855       }
1856
1857       public com.openxc.BinaryMessages.RawMessage build() {
1858         com.openxc.BinaryMessages.RawMessage result = buildPartial();
1859         if (!result.isInitialized()) {
1860           throw newUninitializedMessageException(result);
1861         }
1862         return result;
1863       }
1864
1865       public com.openxc.BinaryMessages.RawMessage buildPartial() {
1866         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
1867         int from_bitField0_ = bitField0_;
1868         int to_bitField0_ = 0;
1869         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1870           to_bitField0_ |= 0x00000001;
1871         }
1872         result.bus_ = bus_;
1873         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1874           to_bitField0_ |= 0x00000002;
1875         }
1876         result.messageId_ = messageId_;
1877         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1878           to_bitField0_ |= 0x00000004;
1879         }
1880         result.data_ = data_;
1881         result.bitField0_ = to_bitField0_;
1882         onBuilt();
1883         return result;
1884       }
1885
1886       public Builder mergeFrom(com.google.protobuf.Message other) {
1887         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
1888           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
1889         } else {
1890           super.mergeFrom(other);
1891           return this;
1892         }
1893       }
1894
1895       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
1896         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
1897         if (other.hasBus()) {
1898           setBus(other.getBus());
1899         }
1900         if (other.hasMessageId()) {
1901           setMessageId(other.getMessageId());
1902         }
1903         if (other.hasData()) {
1904           setData(other.getData());
1905         }
1906         this.mergeUnknownFields(other.getUnknownFields());
1907         return this;
1908       }
1909
1910       public final boolean isInitialized() {
1911         return true;
1912       }
1913
1914       public Builder mergeFrom(
1915           com.google.protobuf.CodedInputStream input,
1916           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1917           throws java.io.IOException {
1918         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
1919         try {
1920           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1921         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1922           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
1923           throw e;
1924         } finally {
1925           if (parsedMessage != null) {
1926             mergeFrom(parsedMessage);
1927           }
1928         }
1929         return this;
1930       }
1931       private int bitField0_;
1932
1933       // optional int32 bus = 1;
1934       private int bus_ ;
1935       /**
1936        * <code>optional int32 bus = 1;</code>
1937        */
1938       public boolean hasBus() {
1939         return ((bitField0_ & 0x00000001) == 0x00000001);
1940       }
1941       /**
1942        * <code>optional int32 bus = 1;</code>
1943        */
1944       public int getBus() {
1945         return bus_;
1946       }
1947       /**
1948        * <code>optional int32 bus = 1;</code>
1949        */
1950       public Builder setBus(int value) {
1951         bitField0_ |= 0x00000001;
1952         bus_ = value;
1953         onChanged();
1954         return this;
1955       }
1956       /**
1957        * <code>optional int32 bus = 1;</code>
1958        */
1959       public Builder clearBus() {
1960         bitField0_ = (bitField0_ & ~0x00000001);
1961         bus_ = 0;
1962         onChanged();
1963         return this;
1964       }
1965
1966       // optional uint32 message_id = 2;
1967       private int messageId_ ;
1968       /**
1969        * <code>optional uint32 message_id = 2;</code>
1970        */
1971       public boolean hasMessageId() {
1972         return ((bitField0_ & 0x00000002) == 0x00000002);
1973       }
1974       /**
1975        * <code>optional uint32 message_id = 2;</code>
1976        */
1977       public int getMessageId() {
1978         return messageId_;
1979       }
1980       /**
1981        * <code>optional uint32 message_id = 2;</code>
1982        */
1983       public Builder setMessageId(int value) {
1984         bitField0_ |= 0x00000002;
1985         messageId_ = value;
1986         onChanged();
1987         return this;
1988       }
1989       /**
1990        * <code>optional uint32 message_id = 2;</code>
1991        */
1992       public Builder clearMessageId() {
1993         bitField0_ = (bitField0_ & ~0x00000002);
1994         messageId_ = 0;
1995         onChanged();
1996         return this;
1997       }
1998
1999       // optional bytes data = 3;
2000       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
2001       /**
2002        * <code>optional bytes data = 3;</code>
2003        */
2004       public boolean hasData() {
2005         return ((bitField0_ & 0x00000004) == 0x00000004);
2006       }
2007       /**
2008        * <code>optional bytes data = 3;</code>
2009        */
2010       public com.google.protobuf.ByteString getData() {
2011         return data_;
2012       }
2013       /**
2014        * <code>optional bytes data = 3;</code>
2015        */
2016       public Builder setData(com.google.protobuf.ByteString value) {
2017         if (value == null) {
2018     throw new NullPointerException();
2019   }
2020   bitField0_ |= 0x00000004;
2021         data_ = value;
2022         onChanged();
2023         return this;
2024       }
2025       /**
2026        * <code>optional bytes data = 3;</code>
2027        */
2028       public Builder clearData() {
2029         bitField0_ = (bitField0_ & ~0x00000004);
2030         data_ = getDefaultInstance().getData();
2031         onChanged();
2032         return this;
2033       }
2034
2035       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
2036     }
2037
2038     static {
2039       defaultInstance = new RawMessage(true);
2040       defaultInstance.initFields();
2041     }
2042
2043     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
2044   }
2045
2046   public interface ControlCommandOrBuilder
2047       extends com.google.protobuf.MessageOrBuilder {
2048
2049     // optional .openxc.ControlCommand.Type type = 1;
2050     /**
2051      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2052      */
2053     boolean hasType();
2054     /**
2055      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2056      */
2057     com.openxc.BinaryMessages.ControlCommand.Type getType();
2058
2059     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2060     /**
2061      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2062      */
2063     boolean hasDiagnosticRequest();
2064     /**
2065      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2066      */
2067     com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest();
2068     /**
2069      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2070      */
2071     com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder();
2072
2073     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2074     /**
2075      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2076      */
2077     boolean hasPassthroughModeRequest();
2078     /**
2079      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2080      */
2081     com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest();
2082     /**
2083      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2084      */
2085     com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder();
2086   }
2087   /**
2088    * Protobuf type {@code openxc.ControlCommand}
2089    */
2090   public static final class ControlCommand extends
2091       com.google.protobuf.GeneratedMessage
2092       implements ControlCommandOrBuilder {
2093     // Use ControlCommand.newBuilder() to construct.
2094     private ControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2095       super(builder);
2096       this.unknownFields = builder.getUnknownFields();
2097     }
2098     private ControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2099
2100     private static final ControlCommand defaultInstance;
2101     public static ControlCommand getDefaultInstance() {
2102       return defaultInstance;
2103     }
2104
2105     public ControlCommand getDefaultInstanceForType() {
2106       return defaultInstance;
2107     }
2108
2109     private final com.google.protobuf.UnknownFieldSet unknownFields;
2110     @java.lang.Override
2111     public final com.google.protobuf.UnknownFieldSet
2112         getUnknownFields() {
2113       return this.unknownFields;
2114     }
2115     private ControlCommand(
2116         com.google.protobuf.CodedInputStream input,
2117         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2118         throws com.google.protobuf.InvalidProtocolBufferException {
2119       initFields();
2120       int mutable_bitField0_ = 0;
2121       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2122           com.google.protobuf.UnknownFieldSet.newBuilder();
2123       try {
2124         boolean done = false;
2125         while (!done) {
2126           int tag = input.readTag();
2127           switch (tag) {
2128             case 0:
2129               done = true;
2130               break;
2131             default: {
2132               if (!parseUnknownField(input, unknownFields,
2133                                      extensionRegistry, tag)) {
2134                 done = true;
2135               }
2136               break;
2137             }
2138             case 8: {
2139               int rawValue = input.readEnum();
2140               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2141               if (value == null) {
2142                 unknownFields.mergeVarintField(1, rawValue);
2143               } else {
2144                 bitField0_ |= 0x00000001;
2145                 type_ = value;
2146               }
2147               break;
2148             }
2149             case 18: {
2150               com.openxc.BinaryMessages.DiagnosticControlCommand.Builder subBuilder = null;
2151               if (((bitField0_ & 0x00000002) == 0x00000002)) {
2152                 subBuilder = diagnosticRequest_.toBuilder();
2153               }
2154               diagnosticRequest_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticControlCommand.PARSER, extensionRegistry);
2155               if (subBuilder != null) {
2156                 subBuilder.mergeFrom(diagnosticRequest_);
2157                 diagnosticRequest_ = subBuilder.buildPartial();
2158               }
2159               bitField0_ |= 0x00000002;
2160               break;
2161             }
2162             case 26: {
2163               com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder subBuilder = null;
2164               if (((bitField0_ & 0x00000004) == 0x00000004)) {
2165                 subBuilder = passthroughModeRequest_.toBuilder();
2166               }
2167               passthroughModeRequest_ = input.readMessage(com.openxc.BinaryMessages.PassthroughModeControlCommand.PARSER, extensionRegistry);
2168               if (subBuilder != null) {
2169                 subBuilder.mergeFrom(passthroughModeRequest_);
2170                 passthroughModeRequest_ = subBuilder.buildPartial();
2171               }
2172               bitField0_ |= 0x00000004;
2173               break;
2174             }
2175           }
2176         }
2177       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2178         throw e.setUnfinishedMessage(this);
2179       } catch (java.io.IOException e) {
2180         throw new com.google.protobuf.InvalidProtocolBufferException(
2181             e.getMessage()).setUnfinishedMessage(this);
2182       } finally {
2183         this.unknownFields = unknownFields.build();
2184         makeExtensionsImmutable();
2185       }
2186     }
2187     public static final com.google.protobuf.Descriptors.Descriptor
2188         getDescriptor() {
2189       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2190     }
2191
2192     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2193         internalGetFieldAccessorTable() {
2194       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2195           .ensureFieldAccessorsInitialized(
2196               com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2197     }
2198
2199     public static com.google.protobuf.Parser<ControlCommand> PARSER =
2200         new com.google.protobuf.AbstractParser<ControlCommand>() {
2201       public ControlCommand parsePartialFrom(
2202           com.google.protobuf.CodedInputStream input,
2203           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2204           throws com.google.protobuf.InvalidProtocolBufferException {
2205         return new ControlCommand(input, extensionRegistry);
2206       }
2207     };
2208
2209     @java.lang.Override
2210     public com.google.protobuf.Parser<ControlCommand> getParserForType() {
2211       return PARSER;
2212     }
2213
2214     /**
2215      * Protobuf enum {@code openxc.ControlCommand.Type}
2216      */
2217     public enum Type
2218         implements com.google.protobuf.ProtocolMessageEnum {
2219       /**
2220        * <code>VERSION = 1;</code>
2221        */
2222       VERSION(0, 1),
2223       /**
2224        * <code>DEVICE_ID = 2;</code>
2225        */
2226       DEVICE_ID(1, 2),
2227       /**
2228        * <code>DIAGNOSTIC = 3;</code>
2229        */
2230       DIAGNOSTIC(2, 3),
2231       /**
2232        * <code>PASSTHROUGH = 4;</code>
2233        */
2234       PASSTHROUGH(3, 4),
2235       ;
2236
2237       /**
2238        * <code>VERSION = 1;</code>
2239        */
2240       public static final int VERSION_VALUE = 1;
2241       /**
2242        * <code>DEVICE_ID = 2;</code>
2243        */
2244       public static final int DEVICE_ID_VALUE = 2;
2245       /**
2246        * <code>DIAGNOSTIC = 3;</code>
2247        */
2248       public static final int DIAGNOSTIC_VALUE = 3;
2249       /**
2250        * <code>PASSTHROUGH = 4;</code>
2251        */
2252       public static final int PASSTHROUGH_VALUE = 4;
2253
2254
2255       public final int getNumber() { return value; }
2256
2257       public static Type valueOf(int value) {
2258         switch (value) {
2259           case 1: return VERSION;
2260           case 2: return DEVICE_ID;
2261           case 3: return DIAGNOSTIC;
2262           case 4: return PASSTHROUGH;
2263           default: return null;
2264         }
2265       }
2266
2267       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2268           internalGetValueMap() {
2269         return internalValueMap;
2270       }
2271       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2272           internalValueMap =
2273             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2274               public Type findValueByNumber(int number) {
2275                 return Type.valueOf(number);
2276               }
2277             };
2278
2279       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2280           getValueDescriptor() {
2281         return getDescriptor().getValues().get(index);
2282       }
2283       public final com.google.protobuf.Descriptors.EnumDescriptor
2284           getDescriptorForType() {
2285         return getDescriptor();
2286       }
2287       public static final com.google.protobuf.Descriptors.EnumDescriptor
2288           getDescriptor() {
2289         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
2290       }
2291
2292       private static final Type[] VALUES = values();
2293
2294       public static Type valueOf(
2295           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2296         if (desc.getType() != getDescriptor()) {
2297           throw new java.lang.IllegalArgumentException(
2298             "EnumValueDescriptor is not for this type.");
2299         }
2300         return VALUES[desc.getIndex()];
2301       }
2302
2303       private final int index;
2304       private final int value;
2305
2306       private Type(int index, int value) {
2307         this.index = index;
2308         this.value = value;
2309       }
2310
2311       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
2312     }
2313
2314     private int bitField0_;
2315     // optional .openxc.ControlCommand.Type type = 1;
2316     public static final int TYPE_FIELD_NUMBER = 1;
2317     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2318     /**
2319      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2320      */
2321     public boolean hasType() {
2322       return ((bitField0_ & 0x00000001) == 0x00000001);
2323     }
2324     /**
2325      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2326      */
2327     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2328       return type_;
2329     }
2330
2331     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2332     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
2333     private com.openxc.BinaryMessages.DiagnosticControlCommand diagnosticRequest_;
2334     /**
2335      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2336      */
2337     public boolean hasDiagnosticRequest() {
2338       return ((bitField0_ & 0x00000002) == 0x00000002);
2339     }
2340     /**
2341      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2342      */
2343     public com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest() {
2344       return diagnosticRequest_;
2345     }
2346     /**
2347      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2348      */
2349     public com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder() {
2350       return diagnosticRequest_;
2351     }
2352
2353     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2354     public static final int PASSTHROUGH_MODE_REQUEST_FIELD_NUMBER = 3;
2355     private com.openxc.BinaryMessages.PassthroughModeControlCommand passthroughModeRequest_;
2356     /**
2357      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2358      */
2359     public boolean hasPassthroughModeRequest() {
2360       return ((bitField0_ & 0x00000004) == 0x00000004);
2361     }
2362     /**
2363      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2364      */
2365     public com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest() {
2366       return passthroughModeRequest_;
2367     }
2368     /**
2369      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2370      */
2371     public com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder() {
2372       return passthroughModeRequest_;
2373     }
2374
2375     private void initFields() {
2376       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2377       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2378       passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2379     }
2380     private byte memoizedIsInitialized = -1;
2381     public final boolean isInitialized() {
2382       byte isInitialized = memoizedIsInitialized;
2383       if (isInitialized != -1) return isInitialized == 1;
2384
2385       memoizedIsInitialized = 1;
2386       return true;
2387     }
2388
2389     public void writeTo(com.google.protobuf.CodedOutputStream output)
2390                         throws java.io.IOException {
2391       getSerializedSize();
2392       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2393         output.writeEnum(1, type_.getNumber());
2394       }
2395       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2396         output.writeMessage(2, diagnosticRequest_);
2397       }
2398       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2399         output.writeMessage(3, passthroughModeRequest_);
2400       }
2401       getUnknownFields().writeTo(output);
2402     }
2403
2404     private int memoizedSerializedSize = -1;
2405     public int getSerializedSize() {
2406       int size = memoizedSerializedSize;
2407       if (size != -1) return size;
2408
2409       size = 0;
2410       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2411         size += com.google.protobuf.CodedOutputStream
2412           .computeEnumSize(1, type_.getNumber());
2413       }
2414       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2415         size += com.google.protobuf.CodedOutputStream
2416           .computeMessageSize(2, diagnosticRequest_);
2417       }
2418       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2419         size += com.google.protobuf.CodedOutputStream
2420           .computeMessageSize(3, passthroughModeRequest_);
2421       }
2422       size += getUnknownFields().getSerializedSize();
2423       memoizedSerializedSize = size;
2424       return size;
2425     }
2426
2427     private static final long serialVersionUID = 0L;
2428     @java.lang.Override
2429     protected java.lang.Object writeReplace()
2430         throws java.io.ObjectStreamException {
2431       return super.writeReplace();
2432     }
2433
2434     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2435         com.google.protobuf.ByteString data)
2436         throws com.google.protobuf.InvalidProtocolBufferException {
2437       return PARSER.parseFrom(data);
2438     }
2439     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2440         com.google.protobuf.ByteString data,
2441         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2442         throws com.google.protobuf.InvalidProtocolBufferException {
2443       return PARSER.parseFrom(data, extensionRegistry);
2444     }
2445     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
2446         throws com.google.protobuf.InvalidProtocolBufferException {
2447       return PARSER.parseFrom(data);
2448     }
2449     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2450         byte[] data,
2451         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2452         throws com.google.protobuf.InvalidProtocolBufferException {
2453       return PARSER.parseFrom(data, extensionRegistry);
2454     }
2455     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
2456         throws java.io.IOException {
2457       return PARSER.parseFrom(input);
2458     }
2459     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2460         java.io.InputStream input,
2461         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2462         throws java.io.IOException {
2463       return PARSER.parseFrom(input, extensionRegistry);
2464     }
2465     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
2466         throws java.io.IOException {
2467       return PARSER.parseDelimitedFrom(input);
2468     }
2469     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
2470         java.io.InputStream input,
2471         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2472         throws java.io.IOException {
2473       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2474     }
2475     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2476         com.google.protobuf.CodedInputStream input)
2477         throws java.io.IOException {
2478       return PARSER.parseFrom(input);
2479     }
2480     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2481         com.google.protobuf.CodedInputStream input,
2482         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2483         throws java.io.IOException {
2484       return PARSER.parseFrom(input, extensionRegistry);
2485     }
2486
2487     public static Builder newBuilder() { return Builder.create(); }
2488     public Builder newBuilderForType() { return newBuilder(); }
2489     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
2490       return newBuilder().mergeFrom(prototype);
2491     }
2492     public Builder toBuilder() { return newBuilder(this); }
2493
2494     @java.lang.Override
2495     protected Builder newBuilderForType(
2496         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2497       Builder builder = new Builder(parent);
2498       return builder;
2499     }
2500     /**
2501      * Protobuf type {@code openxc.ControlCommand}
2502      */
2503     public static final class Builder extends
2504         com.google.protobuf.GeneratedMessage.Builder<Builder>
2505        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
2506       public static final com.google.protobuf.Descriptors.Descriptor
2507           getDescriptor() {
2508         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2509       }
2510
2511       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2512           internalGetFieldAccessorTable() {
2513         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2514             .ensureFieldAccessorsInitialized(
2515                 com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2516       }
2517
2518       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
2519       private Builder() {
2520         maybeForceBuilderInitialization();
2521       }
2522
2523       private Builder(
2524           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2525         super(parent);
2526         maybeForceBuilderInitialization();
2527       }
2528       private void maybeForceBuilderInitialization() {
2529         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2530           getDiagnosticRequestFieldBuilder();
2531           getPassthroughModeRequestFieldBuilder();
2532         }
2533       }
2534       private static Builder create() {
2535         return new Builder();
2536       }
2537
2538       public Builder clear() {
2539         super.clear();
2540         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2541         bitField0_ = (bitField0_ & ~0x00000001);
2542         if (diagnosticRequestBuilder_ == null) {
2543           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2544         } else {
2545           diagnosticRequestBuilder_.clear();
2546         }
2547         bitField0_ = (bitField0_ & ~0x00000002);
2548         if (passthroughModeRequestBuilder_ == null) {
2549           passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2550         } else {
2551           passthroughModeRequestBuilder_.clear();
2552         }
2553         bitField0_ = (bitField0_ & ~0x00000004);
2554         return this;
2555       }
2556
2557       public Builder clone() {
2558         return create().mergeFrom(buildPartial());
2559       }
2560
2561       public com.google.protobuf.Descriptors.Descriptor
2562           getDescriptorForType() {
2563         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2564       }
2565
2566       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
2567         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
2568       }
2569
2570       public com.openxc.BinaryMessages.ControlCommand build() {
2571         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2572         if (!result.isInitialized()) {
2573           throw newUninitializedMessageException(result);
2574         }
2575         return result;
2576       }
2577
2578       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
2579         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
2580         int from_bitField0_ = bitField0_;
2581         int to_bitField0_ = 0;
2582         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2583           to_bitField0_ |= 0x00000001;
2584         }
2585         result.type_ = type_;
2586         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2587           to_bitField0_ |= 0x00000002;
2588         }
2589         if (diagnosticRequestBuilder_ == null) {
2590           result.diagnosticRequest_ = diagnosticRequest_;
2591         } else {
2592           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
2593         }
2594         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2595           to_bitField0_ |= 0x00000004;
2596         }
2597         if (passthroughModeRequestBuilder_ == null) {
2598           result.passthroughModeRequest_ = passthroughModeRequest_;
2599         } else {
2600           result.passthroughModeRequest_ = passthroughModeRequestBuilder_.build();
2601         }
2602         result.bitField0_ = to_bitField0_;
2603         onBuilt();
2604         return result;
2605       }
2606
2607       public Builder mergeFrom(com.google.protobuf.Message other) {
2608         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
2609           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
2610         } else {
2611           super.mergeFrom(other);
2612           return this;
2613         }
2614       }
2615
2616       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
2617         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
2618         if (other.hasType()) {
2619           setType(other.getType());
2620         }
2621         if (other.hasDiagnosticRequest()) {
2622           mergeDiagnosticRequest(other.getDiagnosticRequest());
2623         }
2624         if (other.hasPassthroughModeRequest()) {
2625           mergePassthroughModeRequest(other.getPassthroughModeRequest());
2626         }
2627         this.mergeUnknownFields(other.getUnknownFields());
2628         return this;
2629       }
2630
2631       public final boolean isInitialized() {
2632         return true;
2633       }
2634
2635       public Builder mergeFrom(
2636           com.google.protobuf.CodedInputStream input,
2637           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2638           throws java.io.IOException {
2639         com.openxc.BinaryMessages.ControlCommand parsedMessage = null;
2640         try {
2641           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2642         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2643           parsedMessage = (com.openxc.BinaryMessages.ControlCommand) e.getUnfinishedMessage();
2644           throw e;
2645         } finally {
2646           if (parsedMessage != null) {
2647             mergeFrom(parsedMessage);
2648           }
2649         }
2650         return this;
2651       }
2652       private int bitField0_;
2653
2654       // optional .openxc.ControlCommand.Type type = 1;
2655       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2656       /**
2657        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2658        */
2659       public boolean hasType() {
2660         return ((bitField0_ & 0x00000001) == 0x00000001);
2661       }
2662       /**
2663        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2664        */
2665       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2666         return type_;
2667       }
2668       /**
2669        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2670        */
2671       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
2672         if (value == null) {
2673           throw new NullPointerException();
2674         }
2675         bitField0_ |= 0x00000001;
2676         type_ = value;
2677         onChanged();
2678         return this;
2679       }
2680       /**
2681        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2682        */
2683       public Builder clearType() {
2684         bitField0_ = (bitField0_ & ~0x00000001);
2685         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2686         onChanged();
2687         return this;
2688       }
2689
2690       // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2691       private com.openxc.BinaryMessages.DiagnosticControlCommand diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2692       private com.google.protobuf.SingleFieldBuilder<
2693           com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder> diagnosticRequestBuilder_;
2694       /**
2695        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2696        */
2697       public boolean hasDiagnosticRequest() {
2698         return ((bitField0_ & 0x00000002) == 0x00000002);
2699       }
2700       /**
2701        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2702        */
2703       public com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest() {
2704         if (diagnosticRequestBuilder_ == null) {
2705           return diagnosticRequest_;
2706         } else {
2707           return diagnosticRequestBuilder_.getMessage();
2708         }
2709       }
2710       /**
2711        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2712        */
2713       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticControlCommand value) {
2714         if (diagnosticRequestBuilder_ == null) {
2715           if (value == null) {
2716             throw new NullPointerException();
2717           }
2718           diagnosticRequest_ = value;
2719           onChanged();
2720         } else {
2721           diagnosticRequestBuilder_.setMessage(value);
2722         }
2723         bitField0_ |= 0x00000002;
2724         return this;
2725       }
2726       /**
2727        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2728        */
2729       public Builder setDiagnosticRequest(
2730           com.openxc.BinaryMessages.DiagnosticControlCommand.Builder builderForValue) {
2731         if (diagnosticRequestBuilder_ == null) {
2732           diagnosticRequest_ = builderForValue.build();
2733           onChanged();
2734         } else {
2735           diagnosticRequestBuilder_.setMessage(builderForValue.build());
2736         }
2737         bitField0_ |= 0x00000002;
2738         return this;
2739       }
2740       /**
2741        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2742        */
2743       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticControlCommand value) {
2744         if (diagnosticRequestBuilder_ == null) {
2745           if (((bitField0_ & 0x00000002) == 0x00000002) &&
2746               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance()) {
2747             diagnosticRequest_ =
2748               com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
2749           } else {
2750             diagnosticRequest_ = value;
2751           }
2752           onChanged();
2753         } else {
2754           diagnosticRequestBuilder_.mergeFrom(value);
2755         }
2756         bitField0_ |= 0x00000002;
2757         return this;
2758       }
2759       /**
2760        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2761        */
2762       public Builder clearDiagnosticRequest() {
2763         if (diagnosticRequestBuilder_ == null) {
2764           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
2765           onChanged();
2766         } else {
2767           diagnosticRequestBuilder_.clear();
2768         }
2769         bitField0_ = (bitField0_ & ~0x00000002);
2770         return this;
2771       }
2772       /**
2773        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2774        */
2775       public com.openxc.BinaryMessages.DiagnosticControlCommand.Builder getDiagnosticRequestBuilder() {
2776         bitField0_ |= 0x00000002;
2777         onChanged();
2778         return getDiagnosticRequestFieldBuilder().getBuilder();
2779       }
2780       /**
2781        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2782        */
2783       public com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder() {
2784         if (diagnosticRequestBuilder_ != null) {
2785           return diagnosticRequestBuilder_.getMessageOrBuilder();
2786         } else {
2787           return diagnosticRequest_;
2788         }
2789       }
2790       /**
2791        * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2792        */
2793       private com.google.protobuf.SingleFieldBuilder<
2794           com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder>
2795           getDiagnosticRequestFieldBuilder() {
2796         if (diagnosticRequestBuilder_ == null) {
2797           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2798               com.openxc.BinaryMessages.DiagnosticControlCommand, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder, com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder>(
2799                   diagnosticRequest_,
2800                   getParentForChildren(),
2801                   isClean());
2802           diagnosticRequest_ = null;
2803         }
2804         return diagnosticRequestBuilder_;
2805       }
2806
2807       // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2808       private com.openxc.BinaryMessages.PassthroughModeControlCommand passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2809       private com.google.protobuf.SingleFieldBuilder<
2810           com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder> passthroughModeRequestBuilder_;
2811       /**
2812        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2813        */
2814       public boolean hasPassthroughModeRequest() {
2815         return ((bitField0_ & 0x00000004) == 0x00000004);
2816       }
2817       /**
2818        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2819        */
2820       public com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest() {
2821         if (passthroughModeRequestBuilder_ == null) {
2822           return passthroughModeRequest_;
2823         } else {
2824           return passthroughModeRequestBuilder_.getMessage();
2825         }
2826       }
2827       /**
2828        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2829        */
2830       public Builder setPassthroughModeRequest(com.openxc.BinaryMessages.PassthroughModeControlCommand value) {
2831         if (passthroughModeRequestBuilder_ == null) {
2832           if (value == null) {
2833             throw new NullPointerException();
2834           }
2835           passthroughModeRequest_ = value;
2836           onChanged();
2837         } else {
2838           passthroughModeRequestBuilder_.setMessage(value);
2839         }
2840         bitField0_ |= 0x00000004;
2841         return this;
2842       }
2843       /**
2844        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2845        */
2846       public Builder setPassthroughModeRequest(
2847           com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder builderForValue) {
2848         if (passthroughModeRequestBuilder_ == null) {
2849           passthroughModeRequest_ = builderForValue.build();
2850           onChanged();
2851         } else {
2852           passthroughModeRequestBuilder_.setMessage(builderForValue.build());
2853         }
2854         bitField0_ |= 0x00000004;
2855         return this;
2856       }
2857       /**
2858        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2859        */
2860       public Builder mergePassthroughModeRequest(com.openxc.BinaryMessages.PassthroughModeControlCommand value) {
2861         if (passthroughModeRequestBuilder_ == null) {
2862           if (((bitField0_ & 0x00000004) == 0x00000004) &&
2863               passthroughModeRequest_ != com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance()) {
2864             passthroughModeRequest_ =
2865               com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder(passthroughModeRequest_).mergeFrom(value).buildPartial();
2866           } else {
2867             passthroughModeRequest_ = value;
2868           }
2869           onChanged();
2870         } else {
2871           passthroughModeRequestBuilder_.mergeFrom(value);
2872         }
2873         bitField0_ |= 0x00000004;
2874         return this;
2875       }
2876       /**
2877        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2878        */
2879       public Builder clearPassthroughModeRequest() {
2880         if (passthroughModeRequestBuilder_ == null) {
2881           passthroughModeRequest_ = com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
2882           onChanged();
2883         } else {
2884           passthroughModeRequestBuilder_.clear();
2885         }
2886         bitField0_ = (bitField0_ & ~0x00000004);
2887         return this;
2888       }
2889       /**
2890        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2891        */
2892       public com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder getPassthroughModeRequestBuilder() {
2893         bitField0_ |= 0x00000004;
2894         onChanged();
2895         return getPassthroughModeRequestFieldBuilder().getBuilder();
2896       }
2897       /**
2898        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2899        */
2900       public com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder() {
2901         if (passthroughModeRequestBuilder_ != null) {
2902           return passthroughModeRequestBuilder_.getMessageOrBuilder();
2903         } else {
2904           return passthroughModeRequest_;
2905         }
2906       }
2907       /**
2908        * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2909        */
2910       private com.google.protobuf.SingleFieldBuilder<
2911           com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder>
2912           getPassthroughModeRequestFieldBuilder() {
2913         if (passthroughModeRequestBuilder_ == null) {
2914           passthroughModeRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2915               com.openxc.BinaryMessages.PassthroughModeControlCommand, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder, com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder>(
2916                   passthroughModeRequest_,
2917                   getParentForChildren(),
2918                   isClean());
2919           passthroughModeRequest_ = null;
2920         }
2921         return passthroughModeRequestBuilder_;
2922       }
2923
2924       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
2925     }
2926
2927     static {
2928       defaultInstance = new ControlCommand(true);
2929       defaultInstance.initFields();
2930     }
2931
2932     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
2933   }
2934
2935   public interface DiagnosticControlCommandOrBuilder
2936       extends com.google.protobuf.MessageOrBuilder {
2937
2938     // optional .openxc.DiagnosticRequest request = 1;
2939     /**
2940      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
2941      */
2942     boolean hasRequest();
2943     /**
2944      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
2945      */
2946     com.openxc.BinaryMessages.DiagnosticRequest getRequest();
2947     /**
2948      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
2949      */
2950     com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder();
2951
2952     // optional .openxc.DiagnosticControlCommand.Action action = 2;
2953     /**
2954      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
2955      */
2956     boolean hasAction();
2957     /**
2958      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
2959      */
2960     com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction();
2961   }
2962   /**
2963    * Protobuf type {@code openxc.DiagnosticControlCommand}
2964    */
2965   public static final class DiagnosticControlCommand extends
2966       com.google.protobuf.GeneratedMessage
2967       implements DiagnosticControlCommandOrBuilder {
2968     // Use DiagnosticControlCommand.newBuilder() to construct.
2969     private DiagnosticControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2970       super(builder);
2971       this.unknownFields = builder.getUnknownFields();
2972     }
2973     private DiagnosticControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2974
2975     private static final DiagnosticControlCommand defaultInstance;
2976     public static DiagnosticControlCommand getDefaultInstance() {
2977       return defaultInstance;
2978     }
2979
2980     public DiagnosticControlCommand getDefaultInstanceForType() {
2981       return defaultInstance;
2982     }
2983
2984     private final com.google.protobuf.UnknownFieldSet unknownFields;
2985     @java.lang.Override
2986     public final com.google.protobuf.UnknownFieldSet
2987         getUnknownFields() {
2988       return this.unknownFields;
2989     }
2990     private DiagnosticControlCommand(
2991         com.google.protobuf.CodedInputStream input,
2992         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2993         throws com.google.protobuf.InvalidProtocolBufferException {
2994       initFields();
2995       int mutable_bitField0_ = 0;
2996       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2997           com.google.protobuf.UnknownFieldSet.newBuilder();
2998       try {
2999         boolean done = false;
3000         while (!done) {
3001           int tag = input.readTag();
3002           switch (tag) {
3003             case 0:
3004               done = true;
3005               break;
3006             default: {
3007               if (!parseUnknownField(input, unknownFields,
3008                                      extensionRegistry, tag)) {
3009                 done = true;
3010               }
3011               break;
3012             }
3013             case 10: {
3014               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = null;
3015               if (((bitField0_ & 0x00000001) == 0x00000001)) {
3016                 subBuilder = request_.toBuilder();
3017               }
3018               request_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticRequest.PARSER, extensionRegistry);
3019               if (subBuilder != null) {
3020                 subBuilder.mergeFrom(request_);
3021                 request_ = subBuilder.buildPartial();
3022               }
3023               bitField0_ |= 0x00000001;
3024               break;
3025             }
3026             case 16: {
3027               int rawValue = input.readEnum();
3028               com.openxc.BinaryMessages.DiagnosticControlCommand.Action value = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.valueOf(rawValue);
3029               if (value == null) {
3030                 unknownFields.mergeVarintField(2, rawValue);
3031               } else {
3032                 bitField0_ |= 0x00000002;
3033                 action_ = value;
3034               }
3035               break;
3036             }
3037           }
3038         }
3039       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3040         throw e.setUnfinishedMessage(this);
3041       } catch (java.io.IOException e) {
3042         throw new com.google.protobuf.InvalidProtocolBufferException(
3043             e.getMessage()).setUnfinishedMessage(this);
3044       } finally {
3045         this.unknownFields = unknownFields.build();
3046         makeExtensionsImmutable();
3047       }
3048     }
3049     public static final com.google.protobuf.Descriptors.Descriptor
3050         getDescriptor() {
3051       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
3052     }
3053
3054     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3055         internalGetFieldAccessorTable() {
3056       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable
3057           .ensureFieldAccessorsInitialized(
3058               com.openxc.BinaryMessages.DiagnosticControlCommand.class, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder.class);
3059     }
3060
3061     public static com.google.protobuf.Parser<DiagnosticControlCommand> PARSER =
3062         new com.google.protobuf.AbstractParser<DiagnosticControlCommand>() {
3063       public DiagnosticControlCommand parsePartialFrom(
3064           com.google.protobuf.CodedInputStream input,
3065           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3066           throws com.google.protobuf.InvalidProtocolBufferException {
3067         return new DiagnosticControlCommand(input, extensionRegistry);
3068       }
3069     };
3070
3071     @java.lang.Override
3072     public com.google.protobuf.Parser<DiagnosticControlCommand> getParserForType() {
3073       return PARSER;
3074     }
3075
3076     /**
3077      * Protobuf enum {@code openxc.DiagnosticControlCommand.Action}
3078      */
3079     public enum Action
3080         implements com.google.protobuf.ProtocolMessageEnum {
3081       /**
3082        * <code>ADD = 1;</code>
3083        */
3084       ADD(0, 1),
3085       /**
3086        * <code>CANCEL = 2;</code>
3087        */
3088       CANCEL(1, 2),
3089       ;
3090
3091       /**
3092        * <code>ADD = 1;</code>
3093        */
3094       public static final int ADD_VALUE = 1;
3095       /**
3096        * <code>CANCEL = 2;</code>
3097        */
3098       public static final int CANCEL_VALUE = 2;
3099
3100
3101       public final int getNumber() { return value; }
3102
3103       public static Action valueOf(int value) {
3104         switch (value) {
3105           case 1: return ADD;
3106           case 2: return CANCEL;
3107           default: return null;
3108         }
3109       }
3110
3111       public static com.google.protobuf.Internal.EnumLiteMap<Action>
3112           internalGetValueMap() {
3113         return internalValueMap;
3114       }
3115       private static com.google.protobuf.Internal.EnumLiteMap<Action>
3116           internalValueMap =
3117             new com.google.protobuf.Internal.EnumLiteMap<Action>() {
3118               public Action findValueByNumber(int number) {
3119                 return Action.valueOf(number);
3120               }
3121             };
3122
3123       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3124           getValueDescriptor() {
3125         return getDescriptor().getValues().get(index);
3126       }
3127       public final com.google.protobuf.Descriptors.EnumDescriptor
3128           getDescriptorForType() {
3129         return getDescriptor();
3130       }
3131       public static final com.google.protobuf.Descriptors.EnumDescriptor
3132           getDescriptor() {
3133         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDescriptor().getEnumTypes().get(0);
3134       }
3135
3136       private static final Action[] VALUES = values();
3137
3138       public static Action valueOf(
3139           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3140         if (desc.getType() != getDescriptor()) {
3141           throw new java.lang.IllegalArgumentException(
3142             "EnumValueDescriptor is not for this type.");
3143         }
3144         return VALUES[desc.getIndex()];
3145       }
3146
3147       private final int index;
3148       private final int value;
3149
3150       private Action(int index, int value) {
3151         this.index = index;
3152         this.value = value;
3153       }
3154
3155       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticControlCommand.Action)
3156     }
3157
3158     private int bitField0_;
3159     // optional .openxc.DiagnosticRequest request = 1;
3160     public static final int REQUEST_FIELD_NUMBER = 1;
3161     private com.openxc.BinaryMessages.DiagnosticRequest request_;
3162     /**
3163      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3164      */
3165     public boolean hasRequest() {
3166       return ((bitField0_ & 0x00000001) == 0x00000001);
3167     }
3168     /**
3169      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3170      */
3171     public com.openxc.BinaryMessages.DiagnosticRequest getRequest() {
3172       return request_;
3173     }
3174     /**
3175      * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3176      */
3177     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder() {
3178       return request_;
3179     }
3180
3181     // optional .openxc.DiagnosticControlCommand.Action action = 2;
3182     public static final int ACTION_FIELD_NUMBER = 2;
3183     private com.openxc.BinaryMessages.DiagnosticControlCommand.Action action_;
3184     /**
3185      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
3186      */
3187     public boolean hasAction() {
3188       return ((bitField0_ & 0x00000002) == 0x00000002);
3189     }
3190     /**
3191      * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
3192      */
3193     public com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction() {
3194       return action_;
3195     }
3196
3197     private void initFields() {
3198       request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3199       action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3200     }
3201     private byte memoizedIsInitialized = -1;
3202     public final boolean isInitialized() {
3203       byte isInitialized = memoizedIsInitialized;
3204       if (isInitialized != -1) return isInitialized == 1;
3205
3206       memoizedIsInitialized = 1;
3207       return true;
3208     }
3209
3210     public void writeTo(com.google.protobuf.CodedOutputStream output)
3211                         throws java.io.IOException {
3212       getSerializedSize();
3213       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3214         output.writeMessage(1, request_);
3215       }
3216       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3217         output.writeEnum(2, action_.getNumber());
3218       }
3219       getUnknownFields().writeTo(output);
3220     }
3221
3222     private int memoizedSerializedSize = -1;
3223     public int getSerializedSize() {
3224       int size = memoizedSerializedSize;
3225       if (size != -1) return size;
3226
3227       size = 0;
3228       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3229         size += com.google.protobuf.CodedOutputStream
3230           .computeMessageSize(1, request_);
3231       }
3232       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3233         size += com.google.protobuf.CodedOutputStream
3234           .computeEnumSize(2, action_.getNumber());
3235       }
3236       size += getUnknownFields().getSerializedSize();
3237       memoizedSerializedSize = size;
3238       return size;
3239     }
3240
3241     private static final long serialVersionUID = 0L;
3242     @java.lang.Override
3243     protected java.lang.Object writeReplace()
3244         throws java.io.ObjectStreamException {
3245       return super.writeReplace();
3246     }
3247
3248     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3249         com.google.protobuf.ByteString data)
3250         throws com.google.protobuf.InvalidProtocolBufferException {
3251       return PARSER.parseFrom(data);
3252     }
3253     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3254         com.google.protobuf.ByteString data,
3255         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3256         throws com.google.protobuf.InvalidProtocolBufferException {
3257       return PARSER.parseFrom(data, extensionRegistry);
3258     }
3259     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(byte[] data)
3260         throws com.google.protobuf.InvalidProtocolBufferException {
3261       return PARSER.parseFrom(data);
3262     }
3263     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3264         byte[] data,
3265         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3266         throws com.google.protobuf.InvalidProtocolBufferException {
3267       return PARSER.parseFrom(data, extensionRegistry);
3268     }
3269     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(java.io.InputStream input)
3270         throws java.io.IOException {
3271       return PARSER.parseFrom(input);
3272     }
3273     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3274         java.io.InputStream input,
3275         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3276         throws java.io.IOException {
3277       return PARSER.parseFrom(input, extensionRegistry);
3278     }
3279     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseDelimitedFrom(java.io.InputStream input)
3280         throws java.io.IOException {
3281       return PARSER.parseDelimitedFrom(input);
3282     }
3283     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseDelimitedFrom(
3284         java.io.InputStream input,
3285         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3286         throws java.io.IOException {
3287       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3288     }
3289     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3290         com.google.protobuf.CodedInputStream input)
3291         throws java.io.IOException {
3292       return PARSER.parseFrom(input);
3293     }
3294     public static com.openxc.BinaryMessages.DiagnosticControlCommand parseFrom(
3295         com.google.protobuf.CodedInputStream input,
3296         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3297         throws java.io.IOException {
3298       return PARSER.parseFrom(input, extensionRegistry);
3299     }
3300
3301     public static Builder newBuilder() { return Builder.create(); }
3302     public Builder newBuilderForType() { return newBuilder(); }
3303     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticControlCommand prototype) {
3304       return newBuilder().mergeFrom(prototype);
3305     }
3306     public Builder toBuilder() { return newBuilder(this); }
3307
3308     @java.lang.Override
3309     protected Builder newBuilderForType(
3310         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3311       Builder builder = new Builder(parent);
3312       return builder;
3313     }
3314     /**
3315      * Protobuf type {@code openxc.DiagnosticControlCommand}
3316      */
3317     public static final class Builder extends
3318         com.google.protobuf.GeneratedMessage.Builder<Builder>
3319        implements com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder {
3320       public static final com.google.protobuf.Descriptors.Descriptor
3321           getDescriptor() {
3322         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
3323       }
3324
3325       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3326           internalGetFieldAccessorTable() {
3327         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable
3328             .ensureFieldAccessorsInitialized(
3329                 com.openxc.BinaryMessages.DiagnosticControlCommand.class, com.openxc.BinaryMessages.DiagnosticControlCommand.Builder.class);
3330       }
3331
3332       // Construct using com.openxc.BinaryMessages.DiagnosticControlCommand.newBuilder()
3333       private Builder() {
3334         maybeForceBuilderInitialization();
3335       }
3336
3337       private Builder(
3338           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3339         super(parent);
3340         maybeForceBuilderInitialization();
3341       }
3342       private void maybeForceBuilderInitialization() {
3343         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3344           getRequestFieldBuilder();
3345         }
3346       }
3347       private static Builder create() {
3348         return new Builder();
3349       }
3350
3351       public Builder clear() {
3352         super.clear();
3353         if (requestBuilder_ == null) {
3354           request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3355         } else {
3356           requestBuilder_.clear();
3357         }
3358         bitField0_ = (bitField0_ & ~0x00000001);
3359         action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3360         bitField0_ = (bitField0_ & ~0x00000002);
3361         return this;
3362       }
3363
3364       public Builder clone() {
3365         return create().mergeFrom(buildPartial());
3366       }
3367
3368       public com.google.protobuf.Descriptors.Descriptor
3369           getDescriptorForType() {
3370         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticControlCommand_descriptor;
3371       }
3372
3373       public com.openxc.BinaryMessages.DiagnosticControlCommand getDefaultInstanceForType() {
3374         return com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance();
3375       }
3376
3377       public com.openxc.BinaryMessages.DiagnosticControlCommand build() {
3378         com.openxc.BinaryMessages.DiagnosticControlCommand result = buildPartial();
3379         if (!result.isInitialized()) {
3380           throw newUninitializedMessageException(result);
3381         }
3382         return result;
3383       }
3384
3385       public com.openxc.BinaryMessages.DiagnosticControlCommand buildPartial() {
3386         com.openxc.BinaryMessages.DiagnosticControlCommand result = new com.openxc.BinaryMessages.DiagnosticControlCommand(this);
3387         int from_bitField0_ = bitField0_;
3388         int to_bitField0_ = 0;
3389         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3390           to_bitField0_ |= 0x00000001;
3391         }
3392         if (requestBuilder_ == null) {
3393           result.request_ = request_;
3394         } else {
3395           result.request_ = requestBuilder_.build();
3396         }
3397         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3398           to_bitField0_ |= 0x00000002;
3399         }
3400         result.action_ = action_;
3401         result.bitField0_ = to_bitField0_;
3402         onBuilt();
3403         return result;
3404       }
3405
3406       public Builder mergeFrom(com.google.protobuf.Message other) {
3407         if (other instanceof com.openxc.BinaryMessages.DiagnosticControlCommand) {
3408           return mergeFrom((com.openxc.BinaryMessages.DiagnosticControlCommand)other);
3409         } else {
3410           super.mergeFrom(other);
3411           return this;
3412         }
3413       }
3414
3415       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticControlCommand other) {
3416         if (other == com.openxc.BinaryMessages.DiagnosticControlCommand.getDefaultInstance()) return this;
3417         if (other.hasRequest()) {
3418           mergeRequest(other.getRequest());
3419         }
3420         if (other.hasAction()) {
3421           setAction(other.getAction());
3422         }
3423         this.mergeUnknownFields(other.getUnknownFields());
3424         return this;
3425       }
3426
3427       public final boolean isInitialized() {
3428         return true;
3429       }
3430
3431       public Builder mergeFrom(
3432           com.google.protobuf.CodedInputStream input,
3433           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3434           throws java.io.IOException {
3435         com.openxc.BinaryMessages.DiagnosticControlCommand parsedMessage = null;
3436         try {
3437           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3438         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3439           parsedMessage = (com.openxc.BinaryMessages.DiagnosticControlCommand) e.getUnfinishedMessage();
3440           throw e;
3441         } finally {
3442           if (parsedMessage != null) {
3443             mergeFrom(parsedMessage);
3444           }
3445         }
3446         return this;
3447       }
3448       private int bitField0_;
3449
3450       // optional .openxc.DiagnosticRequest request = 1;
3451       private com.openxc.BinaryMessages.DiagnosticRequest request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3452       private com.google.protobuf.SingleFieldBuilder<
3453           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> requestBuilder_;
3454       /**
3455        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3456        */
3457       public boolean hasRequest() {
3458         return ((bitField0_ & 0x00000001) == 0x00000001);
3459       }
3460       /**
3461        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3462        */
3463       public com.openxc.BinaryMessages.DiagnosticRequest getRequest() {
3464         if (requestBuilder_ == null) {
3465           return request_;
3466         } else {
3467           return requestBuilder_.getMessage();
3468         }
3469       }
3470       /**
3471        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3472        */
3473       public Builder setRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
3474         if (requestBuilder_ == null) {
3475           if (value == null) {
3476             throw new NullPointerException();
3477           }
3478           request_ = value;
3479           onChanged();
3480         } else {
3481           requestBuilder_.setMessage(value);
3482         }
3483         bitField0_ |= 0x00000001;
3484         return this;
3485       }
3486       /**
3487        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3488        */
3489       public Builder setRequest(
3490           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
3491         if (requestBuilder_ == null) {
3492           request_ = builderForValue.build();
3493           onChanged();
3494         } else {
3495           requestBuilder_.setMessage(builderForValue.build());
3496         }
3497         bitField0_ |= 0x00000001;
3498         return this;
3499       }
3500       /**
3501        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3502        */
3503       public Builder mergeRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
3504         if (requestBuilder_ == null) {
3505           if (((bitField0_ & 0x00000001) == 0x00000001) &&
3506               request_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
3507             request_ =
3508               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(request_).mergeFrom(value).buildPartial();
3509           } else {
3510             request_ = value;
3511           }
3512           onChanged();
3513         } else {
3514           requestBuilder_.mergeFrom(value);
3515         }
3516         bitField0_ |= 0x00000001;
3517         return this;
3518       }
3519       /**
3520        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3521        */
3522       public Builder clearRequest() {
3523         if (requestBuilder_ == null) {
3524           request_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
3525           onChanged();
3526         } else {
3527           requestBuilder_.clear();
3528         }
3529         bitField0_ = (bitField0_ & ~0x00000001);
3530         return this;
3531       }
3532       /**
3533        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3534        */
3535       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getRequestBuilder() {
3536         bitField0_ |= 0x00000001;
3537         onChanged();
3538         return getRequestFieldBuilder().getBuilder();
3539       }
3540       /**
3541        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3542        */
3543       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getRequestOrBuilder() {
3544         if (requestBuilder_ != null) {
3545           return requestBuilder_.getMessageOrBuilder();
3546         } else {
3547           return request_;
3548         }
3549       }
3550       /**
3551        * <code>optional .openxc.DiagnosticRequest request = 1;</code>
3552        */
3553       private com.google.protobuf.SingleFieldBuilder<
3554           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>
3555           getRequestFieldBuilder() {
3556         if (requestBuilder_ == null) {
3557           requestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3558               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
3559                   request_,
3560                   getParentForChildren(),
3561                   isClean());
3562           request_ = null;
3563         }
3564         return requestBuilder_;
3565       }
3566
3567       // optional .openxc.DiagnosticControlCommand.Action action = 2;
3568       private com.openxc.BinaryMessages.DiagnosticControlCommand.Action action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3569       /**
3570        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
3571        */
3572       public boolean hasAction() {
3573         return ((bitField0_ & 0x00000002) == 0x00000002);
3574       }
3575       /**
3576        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
3577        */
3578       public com.openxc.BinaryMessages.DiagnosticControlCommand.Action getAction() {
3579         return action_;
3580       }
3581       /**
3582        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
3583        */
3584       public Builder setAction(com.openxc.BinaryMessages.DiagnosticControlCommand.Action value) {
3585         if (value == null) {
3586           throw new NullPointerException();
3587         }
3588         bitField0_ |= 0x00000002;
3589         action_ = value;
3590         onChanged();
3591         return this;
3592       }
3593       /**
3594        * <code>optional .openxc.DiagnosticControlCommand.Action action = 2;</code>
3595        */
3596       public Builder clearAction() {
3597         bitField0_ = (bitField0_ & ~0x00000002);
3598         action_ = com.openxc.BinaryMessages.DiagnosticControlCommand.Action.ADD;
3599         onChanged();
3600         return this;
3601       }
3602
3603       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticControlCommand)
3604     }
3605
3606     static {
3607       defaultInstance = new DiagnosticControlCommand(true);
3608       defaultInstance.initFields();
3609     }
3610
3611     // @@protoc_insertion_point(class_scope:openxc.DiagnosticControlCommand)
3612   }
3613
3614   public interface PassthroughModeControlCommandOrBuilder
3615       extends com.google.protobuf.MessageOrBuilder {
3616
3617     // optional int32 bus = 1;
3618     /**
3619      * <code>optional int32 bus = 1;</code>
3620      */
3621     boolean hasBus();
3622     /**
3623      * <code>optional int32 bus = 1;</code>
3624      */
3625     int getBus();
3626
3627     // optional bool enabled = 2;
3628     /**
3629      * <code>optional bool enabled = 2;</code>
3630      */
3631     boolean hasEnabled();
3632     /**
3633      * <code>optional bool enabled = 2;</code>
3634      */
3635     boolean getEnabled();
3636   }
3637   /**
3638    * Protobuf type {@code openxc.PassthroughModeControlCommand}
3639    */
3640   public static final class PassthroughModeControlCommand extends
3641       com.google.protobuf.GeneratedMessage
3642       implements PassthroughModeControlCommandOrBuilder {
3643     // Use PassthroughModeControlCommand.newBuilder() to construct.
3644     private PassthroughModeControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3645       super(builder);
3646       this.unknownFields = builder.getUnknownFields();
3647     }
3648     private PassthroughModeControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3649
3650     private static final PassthroughModeControlCommand defaultInstance;
3651     public static PassthroughModeControlCommand getDefaultInstance() {
3652       return defaultInstance;
3653     }
3654
3655     public PassthroughModeControlCommand getDefaultInstanceForType() {
3656       return defaultInstance;
3657     }
3658
3659     private final com.google.protobuf.UnknownFieldSet unknownFields;
3660     @java.lang.Override
3661     public final com.google.protobuf.UnknownFieldSet
3662         getUnknownFields() {
3663       return this.unknownFields;
3664     }
3665     private PassthroughModeControlCommand(
3666         com.google.protobuf.CodedInputStream input,
3667         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3668         throws com.google.protobuf.InvalidProtocolBufferException {
3669       initFields();
3670       int mutable_bitField0_ = 0;
3671       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3672           com.google.protobuf.UnknownFieldSet.newBuilder();
3673       try {
3674         boolean done = false;
3675         while (!done) {
3676           int tag = input.readTag();
3677           switch (tag) {
3678             case 0:
3679               done = true;
3680               break;
3681             default: {
3682               if (!parseUnknownField(input, unknownFields,
3683                                      extensionRegistry, tag)) {
3684                 done = true;
3685               }
3686               break;
3687             }
3688             case 8: {
3689               bitField0_ |= 0x00000001;
3690               bus_ = input.readInt32();
3691               break;
3692             }
3693             case 16: {
3694               bitField0_ |= 0x00000002;
3695               enabled_ = input.readBool();
3696               break;
3697             }
3698           }
3699         }
3700       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3701         throw e.setUnfinishedMessage(this);
3702       } catch (java.io.IOException e) {
3703         throw new com.google.protobuf.InvalidProtocolBufferException(
3704             e.getMessage()).setUnfinishedMessage(this);
3705       } finally {
3706         this.unknownFields = unknownFields.build();
3707         makeExtensionsImmutable();
3708       }
3709     }
3710     public static final com.google.protobuf.Descriptors.Descriptor
3711         getDescriptor() {
3712       return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
3713     }
3714
3715     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3716         internalGetFieldAccessorTable() {
3717       return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable
3718           .ensureFieldAccessorsInitialized(
3719               com.openxc.BinaryMessages.PassthroughModeControlCommand.class, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder.class);
3720     }
3721
3722     public static com.google.protobuf.Parser<PassthroughModeControlCommand> PARSER =
3723         new com.google.protobuf.AbstractParser<PassthroughModeControlCommand>() {
3724       public PassthroughModeControlCommand parsePartialFrom(
3725           com.google.protobuf.CodedInputStream input,
3726           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3727           throws com.google.protobuf.InvalidProtocolBufferException {
3728         return new PassthroughModeControlCommand(input, extensionRegistry);
3729       }
3730     };
3731
3732     @java.lang.Override
3733     public com.google.protobuf.Parser<PassthroughModeControlCommand> getParserForType() {
3734       return PARSER;
3735     }
3736
3737     private int bitField0_;
3738     // optional int32 bus = 1;
3739     public static final int BUS_FIELD_NUMBER = 1;
3740     private int bus_;
3741     /**
3742      * <code>optional int32 bus = 1;</code>
3743      */
3744     public boolean hasBus() {
3745       return ((bitField0_ & 0x00000001) == 0x00000001);
3746     }
3747     /**
3748      * <code>optional int32 bus = 1;</code>
3749      */
3750     public int getBus() {
3751       return bus_;
3752     }
3753
3754     // optional bool enabled = 2;
3755     public static final int ENABLED_FIELD_NUMBER = 2;
3756     private boolean enabled_;
3757     /**
3758      * <code>optional bool enabled = 2;</code>
3759      */
3760     public boolean hasEnabled() {
3761       return ((bitField0_ & 0x00000002) == 0x00000002);
3762     }
3763     /**
3764      * <code>optional bool enabled = 2;</code>
3765      */
3766     public boolean getEnabled() {
3767       return enabled_;
3768     }
3769
3770     private void initFields() {
3771       bus_ = 0;
3772       enabled_ = false;
3773     }
3774     private byte memoizedIsInitialized = -1;
3775     public final boolean isInitialized() {
3776       byte isInitialized = memoizedIsInitialized;
3777       if (isInitialized != -1) return isInitialized == 1;
3778
3779       memoizedIsInitialized = 1;
3780       return true;
3781     }
3782
3783     public void writeTo(com.google.protobuf.CodedOutputStream output)
3784                         throws java.io.IOException {
3785       getSerializedSize();
3786       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3787         output.writeInt32(1, bus_);
3788       }
3789       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3790         output.writeBool(2, enabled_);
3791       }
3792       getUnknownFields().writeTo(output);
3793     }
3794
3795     private int memoizedSerializedSize = -1;
3796     public int getSerializedSize() {
3797       int size = memoizedSerializedSize;
3798       if (size != -1) return size;
3799
3800       size = 0;
3801       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3802         size += com.google.protobuf.CodedOutputStream
3803           .computeInt32Size(1, bus_);
3804       }
3805       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3806         size += com.google.protobuf.CodedOutputStream
3807           .computeBoolSize(2, enabled_);
3808       }
3809       size += getUnknownFields().getSerializedSize();
3810       memoizedSerializedSize = size;
3811       return size;
3812     }
3813
3814     private static final long serialVersionUID = 0L;
3815     @java.lang.Override
3816     protected java.lang.Object writeReplace()
3817         throws java.io.ObjectStreamException {
3818       return super.writeReplace();
3819     }
3820
3821     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3822         com.google.protobuf.ByteString data)
3823         throws com.google.protobuf.InvalidProtocolBufferException {
3824       return PARSER.parseFrom(data);
3825     }
3826     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3827         com.google.protobuf.ByteString data,
3828         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3829         throws com.google.protobuf.InvalidProtocolBufferException {
3830       return PARSER.parseFrom(data, extensionRegistry);
3831     }
3832     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(byte[] data)
3833         throws com.google.protobuf.InvalidProtocolBufferException {
3834       return PARSER.parseFrom(data);
3835     }
3836     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3837         byte[] data,
3838         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3839         throws com.google.protobuf.InvalidProtocolBufferException {
3840       return PARSER.parseFrom(data, extensionRegistry);
3841     }
3842     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(java.io.InputStream input)
3843         throws java.io.IOException {
3844       return PARSER.parseFrom(input);
3845     }
3846     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3847         java.io.InputStream input,
3848         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3849         throws java.io.IOException {
3850       return PARSER.parseFrom(input, extensionRegistry);
3851     }
3852     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseDelimitedFrom(java.io.InputStream input)
3853         throws java.io.IOException {
3854       return PARSER.parseDelimitedFrom(input);
3855     }
3856     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseDelimitedFrom(
3857         java.io.InputStream input,
3858         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3859         throws java.io.IOException {
3860       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3861     }
3862     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3863         com.google.protobuf.CodedInputStream input)
3864         throws java.io.IOException {
3865       return PARSER.parseFrom(input);
3866     }
3867     public static com.openxc.BinaryMessages.PassthroughModeControlCommand parseFrom(
3868         com.google.protobuf.CodedInputStream input,
3869         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3870         throws java.io.IOException {
3871       return PARSER.parseFrom(input, extensionRegistry);
3872     }
3873
3874     public static Builder newBuilder() { return Builder.create(); }
3875     public Builder newBuilderForType() { return newBuilder(); }
3876     public static Builder newBuilder(com.openxc.BinaryMessages.PassthroughModeControlCommand prototype) {
3877       return newBuilder().mergeFrom(prototype);
3878     }
3879     public Builder toBuilder() { return newBuilder(this); }
3880
3881     @java.lang.Override
3882     protected Builder newBuilderForType(
3883         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3884       Builder builder = new Builder(parent);
3885       return builder;
3886     }
3887     /**
3888      * Protobuf type {@code openxc.PassthroughModeControlCommand}
3889      */
3890     public static final class Builder extends
3891         com.google.protobuf.GeneratedMessage.Builder<Builder>
3892        implements com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder {
3893       public static final com.google.protobuf.Descriptors.Descriptor
3894           getDescriptor() {
3895         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
3896       }
3897
3898       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3899           internalGetFieldAccessorTable() {
3900         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable
3901             .ensureFieldAccessorsInitialized(
3902                 com.openxc.BinaryMessages.PassthroughModeControlCommand.class, com.openxc.BinaryMessages.PassthroughModeControlCommand.Builder.class);
3903       }
3904
3905       // Construct using com.openxc.BinaryMessages.PassthroughModeControlCommand.newBuilder()
3906       private Builder() {
3907         maybeForceBuilderInitialization();
3908       }
3909
3910       private Builder(
3911           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3912         super(parent);
3913         maybeForceBuilderInitialization();
3914       }
3915       private void maybeForceBuilderInitialization() {
3916         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3917         }
3918       }
3919       private static Builder create() {
3920         return new Builder();
3921       }
3922
3923       public Builder clear() {
3924         super.clear();
3925         bus_ = 0;
3926         bitField0_ = (bitField0_ & ~0x00000001);
3927         enabled_ = false;
3928         bitField0_ = (bitField0_ & ~0x00000002);
3929         return this;
3930       }
3931
3932       public Builder clone() {
3933         return create().mergeFrom(buildPartial());
3934       }
3935
3936       public com.google.protobuf.Descriptors.Descriptor
3937           getDescriptorForType() {
3938         return com.openxc.BinaryMessages.internal_static_openxc_PassthroughModeControlCommand_descriptor;
3939       }
3940
3941       public com.openxc.BinaryMessages.PassthroughModeControlCommand getDefaultInstanceForType() {
3942         return com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance();
3943       }
3944
3945       public com.openxc.BinaryMessages.PassthroughModeControlCommand build() {
3946         com.openxc.BinaryMessages.PassthroughModeControlCommand result = buildPartial();
3947         if (!result.isInitialized()) {
3948           throw newUninitializedMessageException(result);
3949         }
3950         return result;
3951       }
3952
3953       public com.openxc.BinaryMessages.PassthroughModeControlCommand buildPartial() {
3954         com.openxc.BinaryMessages.PassthroughModeControlCommand result = new com.openxc.BinaryMessages.PassthroughModeControlCommand(this);
3955         int from_bitField0_ = bitField0_;
3956         int to_bitField0_ = 0;
3957         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3958           to_bitField0_ |= 0x00000001;
3959         }
3960         result.bus_ = bus_;
3961         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3962           to_bitField0_ |= 0x00000002;
3963         }
3964         result.enabled_ = enabled_;
3965         result.bitField0_ = to_bitField0_;
3966         onBuilt();
3967         return result;
3968       }
3969
3970       public Builder mergeFrom(com.google.protobuf.Message other) {
3971         if (other instanceof com.openxc.BinaryMessages.PassthroughModeControlCommand) {
3972           return mergeFrom((com.openxc.BinaryMessages.PassthroughModeControlCommand)other);
3973         } else {
3974           super.mergeFrom(other);
3975           return this;
3976         }
3977       }
3978
3979       public Builder mergeFrom(com.openxc.BinaryMessages.PassthroughModeControlCommand other) {
3980         if (other == com.openxc.BinaryMessages.PassthroughModeControlCommand.getDefaultInstance()) return this;
3981         if (other.hasBus()) {
3982           setBus(other.getBus());
3983         }
3984         if (other.hasEnabled()) {
3985           setEnabled(other.getEnabled());
3986         }
3987         this.mergeUnknownFields(other.getUnknownFields());
3988         return this;
3989       }
3990
3991       public final boolean isInitialized() {
3992         return true;
3993       }
3994
3995       public Builder mergeFrom(
3996           com.google.protobuf.CodedInputStream input,
3997           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3998           throws java.io.IOException {
3999         com.openxc.BinaryMessages.PassthroughModeControlCommand parsedMessage = null;
4000         try {
4001           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4002         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4003           parsedMessage = (com.openxc.BinaryMessages.PassthroughModeControlCommand) e.getUnfinishedMessage();
4004           throw e;
4005         } finally {
4006           if (parsedMessage != null) {
4007             mergeFrom(parsedMessage);
4008           }
4009         }
4010         return this;
4011       }
4012       private int bitField0_;
4013
4014       // optional int32 bus = 1;
4015       private int bus_ ;
4016       /**
4017        * <code>optional int32 bus = 1;</code>
4018        */
4019       public boolean hasBus() {
4020         return ((bitField0_ & 0x00000001) == 0x00000001);
4021       }
4022       /**
4023        * <code>optional int32 bus = 1;</code>
4024        */
4025       public int getBus() {
4026         return bus_;
4027       }
4028       /**
4029        * <code>optional int32 bus = 1;</code>
4030        */
4031       public Builder setBus(int value) {
4032         bitField0_ |= 0x00000001;
4033         bus_ = value;
4034         onChanged();
4035         return this;
4036       }
4037       /**
4038        * <code>optional int32 bus = 1;</code>
4039        */
4040       public Builder clearBus() {
4041         bitField0_ = (bitField0_ & ~0x00000001);
4042         bus_ = 0;
4043         onChanged();
4044         return this;
4045       }
4046
4047       // optional bool enabled = 2;
4048       private boolean enabled_ ;
4049       /**
4050        * <code>optional bool enabled = 2;</code>
4051        */
4052       public boolean hasEnabled() {
4053         return ((bitField0_ & 0x00000002) == 0x00000002);
4054       }
4055       /**
4056        * <code>optional bool enabled = 2;</code>
4057        */
4058       public boolean getEnabled() {
4059         return enabled_;
4060       }
4061       /**
4062        * <code>optional bool enabled = 2;</code>
4063        */
4064       public Builder setEnabled(boolean value) {
4065         bitField0_ |= 0x00000002;
4066         enabled_ = value;
4067         onChanged();
4068         return this;
4069       }
4070       /**
4071        * <code>optional bool enabled = 2;</code>
4072        */
4073       public Builder clearEnabled() {
4074         bitField0_ = (bitField0_ & ~0x00000002);
4075         enabled_ = false;
4076         onChanged();
4077         return this;
4078       }
4079
4080       // @@protoc_insertion_point(builder_scope:openxc.PassthroughModeControlCommand)
4081     }
4082
4083     static {
4084       defaultInstance = new PassthroughModeControlCommand(true);
4085       defaultInstance.initFields();
4086     }
4087
4088     // @@protoc_insertion_point(class_scope:openxc.PassthroughModeControlCommand)
4089   }
4090
4091   public interface CommandResponseOrBuilder
4092       extends com.google.protobuf.MessageOrBuilder {
4093
4094     // optional .openxc.ControlCommand.Type type = 1;
4095     /**
4096      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4097      */
4098     boolean hasType();
4099     /**
4100      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4101      */
4102     com.openxc.BinaryMessages.ControlCommand.Type getType();
4103
4104     // optional string message = 2;
4105     /**
4106      * <code>optional string message = 2;</code>
4107      */
4108     boolean hasMessage();
4109     /**
4110      * <code>optional string message = 2;</code>
4111      */
4112     java.lang.String getMessage();
4113     /**
4114      * <code>optional string message = 2;</code>
4115      */
4116     com.google.protobuf.ByteString
4117         getMessageBytes();
4118
4119     // optional bool status = 3;
4120     /**
4121      * <code>optional bool status = 3;</code>
4122      */
4123     boolean hasStatus();
4124     /**
4125      * <code>optional bool status = 3;</code>
4126      */
4127     boolean getStatus();
4128   }
4129   /**
4130    * Protobuf type {@code openxc.CommandResponse}
4131    */
4132   public static final class CommandResponse extends
4133       com.google.protobuf.GeneratedMessage
4134       implements CommandResponseOrBuilder {
4135     // Use CommandResponse.newBuilder() to construct.
4136     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4137       super(builder);
4138       this.unknownFields = builder.getUnknownFields();
4139     }
4140     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4141
4142     private static final CommandResponse defaultInstance;
4143     public static CommandResponse getDefaultInstance() {
4144       return defaultInstance;
4145     }
4146
4147     public CommandResponse getDefaultInstanceForType() {
4148       return defaultInstance;
4149     }
4150
4151     private final com.google.protobuf.UnknownFieldSet unknownFields;
4152     @java.lang.Override
4153     public final com.google.protobuf.UnknownFieldSet
4154         getUnknownFields() {
4155       return this.unknownFields;
4156     }
4157     private CommandResponse(
4158         com.google.protobuf.CodedInputStream input,
4159         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4160         throws com.google.protobuf.InvalidProtocolBufferException {
4161       initFields();
4162       int mutable_bitField0_ = 0;
4163       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4164           com.google.protobuf.UnknownFieldSet.newBuilder();
4165       try {
4166         boolean done = false;
4167         while (!done) {
4168           int tag = input.readTag();
4169           switch (tag) {
4170             case 0:
4171               done = true;
4172               break;
4173             default: {
4174               if (!parseUnknownField(input, unknownFields,
4175                                      extensionRegistry, tag)) {
4176                 done = true;
4177               }
4178               break;
4179             }
4180             case 8: {
4181               int rawValue = input.readEnum();
4182               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
4183               if (value == null) {
4184                 unknownFields.mergeVarintField(1, rawValue);
4185               } else {
4186                 bitField0_ |= 0x00000001;
4187                 type_ = value;
4188               }
4189               break;
4190             }
4191             case 18: {
4192               bitField0_ |= 0x00000002;
4193               message_ = input.readBytes();
4194               break;
4195             }
4196             case 24: {
4197               bitField0_ |= 0x00000004;
4198               status_ = input.readBool();
4199               break;
4200             }
4201           }
4202         }
4203       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4204         throw e.setUnfinishedMessage(this);
4205       } catch (java.io.IOException e) {
4206         throw new com.google.protobuf.InvalidProtocolBufferException(
4207             e.getMessage()).setUnfinishedMessage(this);
4208       } finally {
4209         this.unknownFields = unknownFields.build();
4210         makeExtensionsImmutable();
4211       }
4212     }
4213     public static final com.google.protobuf.Descriptors.Descriptor
4214         getDescriptor() {
4215       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
4216     }
4217
4218     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4219         internalGetFieldAccessorTable() {
4220       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
4221           .ensureFieldAccessorsInitialized(
4222               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
4223     }
4224
4225     public static com.google.protobuf.Parser<CommandResponse> PARSER =
4226         new com.google.protobuf.AbstractParser<CommandResponse>() {
4227       public CommandResponse parsePartialFrom(
4228           com.google.protobuf.CodedInputStream input,
4229           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4230           throws com.google.protobuf.InvalidProtocolBufferException {
4231         return new CommandResponse(input, extensionRegistry);
4232       }
4233     };
4234
4235     @java.lang.Override
4236     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
4237       return PARSER;
4238     }
4239
4240     private int bitField0_;
4241     // optional .openxc.ControlCommand.Type type = 1;
4242     public static final int TYPE_FIELD_NUMBER = 1;
4243     private com.openxc.BinaryMessages.ControlCommand.Type type_;
4244     /**
4245      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4246      */
4247     public boolean hasType() {
4248       return ((bitField0_ & 0x00000001) == 0x00000001);
4249     }
4250     /**
4251      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4252      */
4253     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
4254       return type_;
4255     }
4256
4257     // optional string message = 2;
4258     public static final int MESSAGE_FIELD_NUMBER = 2;
4259     private java.lang.Object message_;
4260     /**
4261      * <code>optional string message = 2;</code>
4262      */
4263     public boolean hasMessage() {
4264       return ((bitField0_ & 0x00000002) == 0x00000002);
4265     }
4266     /**
4267      * <code>optional string message = 2;</code>
4268      */
4269     public java.lang.String getMessage() {
4270       java.lang.Object ref = message_;
4271       if (ref instanceof java.lang.String) {
4272         return (java.lang.String) ref;
4273       } else {
4274         com.google.protobuf.ByteString bs =
4275             (com.google.protobuf.ByteString) ref;
4276         java.lang.String s = bs.toStringUtf8();
4277         if (bs.isValidUtf8()) {
4278           message_ = s;
4279         }
4280         return s;
4281       }
4282     }
4283     /**
4284      * <code>optional string message = 2;</code>
4285      */
4286     public com.google.protobuf.ByteString
4287         getMessageBytes() {
4288       java.lang.Object ref = message_;
4289       if (ref instanceof java.lang.String) {
4290         com.google.protobuf.ByteString b =
4291             com.google.protobuf.ByteString.copyFromUtf8(
4292                 (java.lang.String) ref);
4293         message_ = b;
4294         return b;
4295       } else {
4296         return (com.google.protobuf.ByteString) ref;
4297       }
4298     }
4299
4300     // optional bool status = 3;
4301     public static final int STATUS_FIELD_NUMBER = 3;
4302     private boolean status_;
4303     /**
4304      * <code>optional bool status = 3;</code>
4305      */
4306     public boolean hasStatus() {
4307       return ((bitField0_ & 0x00000004) == 0x00000004);
4308     }
4309     /**
4310      * <code>optional bool status = 3;</code>
4311      */
4312     public boolean getStatus() {
4313       return status_;
4314     }
4315
4316     private void initFields() {
4317       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
4318       message_ = "";
4319       status_ = false;
4320     }
4321     private byte memoizedIsInitialized = -1;
4322     public final boolean isInitialized() {
4323       byte isInitialized = memoizedIsInitialized;
4324       if (isInitialized != -1) return isInitialized == 1;
4325
4326       memoizedIsInitialized = 1;
4327       return true;
4328     }
4329
4330     public void writeTo(com.google.protobuf.CodedOutputStream output)
4331                         throws java.io.IOException {
4332       getSerializedSize();
4333       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4334         output.writeEnum(1, type_.getNumber());
4335       }
4336       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4337         output.writeBytes(2, getMessageBytes());
4338       }
4339       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4340         output.writeBool(3, status_);
4341       }
4342       getUnknownFields().writeTo(output);
4343     }
4344
4345     private int memoizedSerializedSize = -1;
4346     public int getSerializedSize() {
4347       int size = memoizedSerializedSize;
4348       if (size != -1) return size;
4349
4350       size = 0;
4351       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4352         size += com.google.protobuf.CodedOutputStream
4353           .computeEnumSize(1, type_.getNumber());
4354       }
4355       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4356         size += com.google.protobuf.CodedOutputStream
4357           .computeBytesSize(2, getMessageBytes());
4358       }
4359       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4360         size += com.google.protobuf.CodedOutputStream
4361           .computeBoolSize(3, status_);
4362       }
4363       size += getUnknownFields().getSerializedSize();
4364       memoizedSerializedSize = size;
4365       return size;
4366     }
4367
4368     private static final long serialVersionUID = 0L;
4369     @java.lang.Override
4370     protected java.lang.Object writeReplace()
4371         throws java.io.ObjectStreamException {
4372       return super.writeReplace();
4373     }
4374
4375     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
4376         com.google.protobuf.ByteString data)
4377         throws com.google.protobuf.InvalidProtocolBufferException {
4378       return PARSER.parseFrom(data);
4379     }
4380     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
4381         com.google.protobuf.ByteString data,
4382         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4383         throws com.google.protobuf.InvalidProtocolBufferException {
4384       return PARSER.parseFrom(data, extensionRegistry);
4385     }
4386     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
4387         throws com.google.protobuf.InvalidProtocolBufferException {
4388       return PARSER.parseFrom(data);
4389     }
4390     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
4391         byte[] data,
4392         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4393         throws com.google.protobuf.InvalidProtocolBufferException {
4394       return PARSER.parseFrom(data, extensionRegistry);
4395     }
4396     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
4397         throws java.io.IOException {
4398       return PARSER.parseFrom(input);
4399     }
4400     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
4401         java.io.InputStream input,
4402         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4403         throws java.io.IOException {
4404       return PARSER.parseFrom(input, extensionRegistry);
4405     }
4406     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
4407         throws java.io.IOException {
4408       return PARSER.parseDelimitedFrom(input);
4409     }
4410     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
4411         java.io.InputStream input,
4412         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4413         throws java.io.IOException {
4414       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4415     }
4416     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
4417         com.google.protobuf.CodedInputStream input)
4418         throws java.io.IOException {
4419       return PARSER.parseFrom(input);
4420     }
4421     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
4422         com.google.protobuf.CodedInputStream input,
4423         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4424         throws java.io.IOException {
4425       return PARSER.parseFrom(input, extensionRegistry);
4426     }
4427
4428     public static Builder newBuilder() { return Builder.create(); }
4429     public Builder newBuilderForType() { return newBuilder(); }
4430     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
4431       return newBuilder().mergeFrom(prototype);
4432     }
4433     public Builder toBuilder() { return newBuilder(this); }
4434
4435     @java.lang.Override
4436     protected Builder newBuilderForType(
4437         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4438       Builder builder = new Builder(parent);
4439       return builder;
4440     }
4441     /**
4442      * Protobuf type {@code openxc.CommandResponse}
4443      */
4444     public static final class Builder extends
4445         com.google.protobuf.GeneratedMessage.Builder<Builder>
4446        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
4447       public static final com.google.protobuf.Descriptors.Descriptor
4448           getDescriptor() {
4449         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
4450       }
4451
4452       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4453           internalGetFieldAccessorTable() {
4454         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
4455             .ensureFieldAccessorsInitialized(
4456                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
4457       }
4458
4459       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
4460       private Builder() {
4461         maybeForceBuilderInitialization();
4462       }
4463
4464       private Builder(
4465           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4466         super(parent);
4467         maybeForceBuilderInitialization();
4468       }
4469       private void maybeForceBuilderInitialization() {
4470         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4471         }
4472       }
4473       private static Builder create() {
4474         return new Builder();
4475       }
4476
4477       public Builder clear() {
4478         super.clear();
4479         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
4480         bitField0_ = (bitField0_ & ~0x00000001);
4481         message_ = "";
4482         bitField0_ = (bitField0_ & ~0x00000002);
4483         status_ = false;
4484         bitField0_ = (bitField0_ & ~0x00000004);
4485         return this;
4486       }
4487
4488       public Builder clone() {
4489         return create().mergeFrom(buildPartial());
4490       }
4491
4492       public com.google.protobuf.Descriptors.Descriptor
4493           getDescriptorForType() {
4494         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
4495       }
4496
4497       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
4498         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
4499       }
4500
4501       public com.openxc.BinaryMessages.CommandResponse build() {
4502         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
4503         if (!result.isInitialized()) {
4504           throw newUninitializedMessageException(result);
4505         }
4506         return result;
4507       }
4508
4509       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
4510         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
4511         int from_bitField0_ = bitField0_;
4512         int to_bitField0_ = 0;
4513         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4514           to_bitField0_ |= 0x00000001;
4515         }
4516         result.type_ = type_;
4517         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4518           to_bitField0_ |= 0x00000002;
4519         }
4520         result.message_ = message_;
4521         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4522           to_bitField0_ |= 0x00000004;
4523         }
4524         result.status_ = status_;
4525         result.bitField0_ = to_bitField0_;
4526         onBuilt();
4527         return result;
4528       }
4529
4530       public Builder mergeFrom(com.google.protobuf.Message other) {
4531         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
4532           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
4533         } else {
4534           super.mergeFrom(other);
4535           return this;
4536         }
4537       }
4538
4539       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
4540         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
4541         if (other.hasType()) {
4542           setType(other.getType());
4543         }
4544         if (other.hasMessage()) {
4545           bitField0_ |= 0x00000002;
4546           message_ = other.message_;
4547           onChanged();
4548         }
4549         if (other.hasStatus()) {
4550           setStatus(other.getStatus());
4551         }
4552         this.mergeUnknownFields(other.getUnknownFields());
4553         return this;
4554       }
4555
4556       public final boolean isInitialized() {
4557         return true;
4558       }
4559
4560       public Builder mergeFrom(
4561           com.google.protobuf.CodedInputStream input,
4562           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4563           throws java.io.IOException {
4564         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
4565         try {
4566           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4567         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4568           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
4569           throw e;
4570         } finally {
4571           if (parsedMessage != null) {
4572             mergeFrom(parsedMessage);
4573           }
4574         }
4575         return this;
4576       }
4577       private int bitField0_;
4578
4579       // optional .openxc.ControlCommand.Type type = 1;
4580       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
4581       /**
4582        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4583        */
4584       public boolean hasType() {
4585         return ((bitField0_ & 0x00000001) == 0x00000001);
4586       }
4587       /**
4588        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4589        */
4590       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
4591         return type_;
4592       }
4593       /**
4594        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4595        */
4596       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
4597         if (value == null) {
4598           throw new NullPointerException();
4599         }
4600         bitField0_ |= 0x00000001;
4601         type_ = value;
4602         onChanged();
4603         return this;
4604       }
4605       /**
4606        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
4607        */
4608       public Builder clearType() {
4609         bitField0_ = (bitField0_ & ~0x00000001);
4610         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
4611         onChanged();
4612         return this;
4613       }
4614
4615       // optional string message = 2;
4616       private java.lang.Object message_ = "";
4617       /**
4618        * <code>optional string message = 2;</code>
4619        */
4620       public boolean hasMessage() {
4621         return ((bitField0_ & 0x00000002) == 0x00000002);
4622       }
4623       /**
4624        * <code>optional string message = 2;</code>
4625        */
4626       public java.lang.String getMessage() {
4627         java.lang.Object ref = message_;
4628         if (!(ref instanceof java.lang.String)) {
4629           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4630               .toStringUtf8();
4631           message_ = s;
4632           return s;
4633         } else {
4634           return (java.lang.String) ref;
4635         }
4636       }
4637       /**
4638        * <code>optional string message = 2;</code>
4639        */
4640       public com.google.protobuf.ByteString
4641           getMessageBytes() {
4642         java.lang.Object ref = message_;
4643         if (ref instanceof String) {
4644           com.google.protobuf.ByteString b =
4645               com.google.protobuf.ByteString.copyFromUtf8(
4646                   (java.lang.String) ref);
4647           message_ = b;
4648           return b;
4649         } else {
4650           return (com.google.protobuf.ByteString) ref;
4651         }
4652       }
4653       /**
4654        * <code>optional string message = 2;</code>
4655        */
4656       public Builder setMessage(
4657           java.lang.String value) {
4658         if (value == null) {
4659     throw new NullPointerException();
4660   }
4661   bitField0_ |= 0x00000002;
4662         message_ = value;
4663         onChanged();
4664         return this;
4665       }
4666       /**
4667        * <code>optional string message = 2;</code>
4668        */
4669       public Builder clearMessage() {
4670         bitField0_ = (bitField0_ & ~0x00000002);
4671         message_ = getDefaultInstance().getMessage();
4672         onChanged();
4673         return this;
4674       }
4675       /**
4676        * <code>optional string message = 2;</code>
4677        */
4678       public Builder setMessageBytes(
4679           com.google.protobuf.ByteString value) {
4680         if (value == null) {
4681     throw new NullPointerException();
4682   }
4683   bitField0_ |= 0x00000002;
4684         message_ = value;
4685         onChanged();
4686         return this;
4687       }
4688
4689       // optional bool status = 3;
4690       private boolean status_ ;
4691       /**
4692        * <code>optional bool status = 3;</code>
4693        */
4694       public boolean hasStatus() {
4695         return ((bitField0_ & 0x00000004) == 0x00000004);
4696       }
4697       /**
4698        * <code>optional bool status = 3;</code>
4699        */
4700       public boolean getStatus() {
4701         return status_;
4702       }
4703       /**
4704        * <code>optional bool status = 3;</code>
4705        */
4706       public Builder setStatus(boolean value) {
4707         bitField0_ |= 0x00000004;
4708         status_ = value;
4709         onChanged();
4710         return this;
4711       }
4712       /**
4713        * <code>optional bool status = 3;</code>
4714        */
4715       public Builder clearStatus() {
4716         bitField0_ = (bitField0_ & ~0x00000004);
4717         status_ = false;
4718         onChanged();
4719         return this;
4720       }
4721
4722       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
4723     }
4724
4725     static {
4726       defaultInstance = new CommandResponse(true);
4727       defaultInstance.initFields();
4728     }
4729
4730     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
4731   }
4732
4733   public interface DiagnosticRequestOrBuilder
4734       extends com.google.protobuf.MessageOrBuilder {
4735
4736     // optional int32 bus = 1;
4737     /**
4738      * <code>optional int32 bus = 1;</code>
4739      */
4740     boolean hasBus();
4741     /**
4742      * <code>optional int32 bus = 1;</code>
4743      */
4744     int getBus();
4745
4746     // optional uint32 message_id = 2;
4747     /**
4748      * <code>optional uint32 message_id = 2;</code>
4749      */
4750     boolean hasMessageId();
4751     /**
4752      * <code>optional uint32 message_id = 2;</code>
4753      */
4754     int getMessageId();
4755
4756     // optional uint32 mode = 3;
4757     /**
4758      * <code>optional uint32 mode = 3;</code>
4759      */
4760     boolean hasMode();
4761     /**
4762      * <code>optional uint32 mode = 3;</code>
4763      */
4764     int getMode();
4765
4766     // optional uint32 pid = 4;
4767     /**
4768      * <code>optional uint32 pid = 4;</code>
4769      */
4770     boolean hasPid();
4771     /**
4772      * <code>optional uint32 pid = 4;</code>
4773      */
4774     int getPid();
4775
4776     // optional bytes payload = 5;
4777     /**
4778      * <code>optional bytes payload = 5;</code>
4779      *
4780      * <pre>
4781      * TODO we are capping this at 8 bytes for now - need to change when we
4782      * support multi-frame responses
4783      * </pre>
4784      */
4785     boolean hasPayload();
4786     /**
4787      * <code>optional bytes payload = 5;</code>
4788      *
4789      * <pre>
4790      * TODO we are capping this at 8 bytes for now - need to change when we
4791      * support multi-frame responses
4792      * </pre>
4793      */
4794     com.google.protobuf.ByteString getPayload();
4795
4796     // optional bool multiple_responses = 6;
4797     /**
4798      * <code>optional bool multiple_responses = 6;</code>
4799      */
4800     boolean hasMultipleResponses();
4801     /**
4802      * <code>optional bool multiple_responses = 6;</code>
4803      */
4804     boolean getMultipleResponses();
4805
4806     // optional double frequency = 7;
4807     /**
4808      * <code>optional double frequency = 7;</code>
4809      */
4810     boolean hasFrequency();
4811     /**
4812      * <code>optional double frequency = 7;</code>
4813      */
4814     double getFrequency();
4815
4816     // optional string name = 8;
4817     /**
4818      * <code>optional string name = 8;</code>
4819      */
4820     boolean hasName();
4821     /**
4822      * <code>optional string name = 8;</code>
4823      */
4824     java.lang.String getName();
4825     /**
4826      * <code>optional string name = 8;</code>
4827      */
4828     com.google.protobuf.ByteString
4829         getNameBytes();
4830
4831     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
4832     /**
4833      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4834      */
4835     boolean hasDecodedType();
4836     /**
4837      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4838      */
4839     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
4840   }
4841   /**
4842    * Protobuf type {@code openxc.DiagnosticRequest}
4843    */
4844   public static final class DiagnosticRequest extends
4845       com.google.protobuf.GeneratedMessage
4846       implements DiagnosticRequestOrBuilder {
4847     // Use DiagnosticRequest.newBuilder() to construct.
4848     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4849       super(builder);
4850       this.unknownFields = builder.getUnknownFields();
4851     }
4852     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4853
4854     private static final DiagnosticRequest defaultInstance;
4855     public static DiagnosticRequest getDefaultInstance() {
4856       return defaultInstance;
4857     }
4858
4859     public DiagnosticRequest getDefaultInstanceForType() {
4860       return defaultInstance;
4861     }
4862
4863     private final com.google.protobuf.UnknownFieldSet unknownFields;
4864     @java.lang.Override
4865     public final com.google.protobuf.UnknownFieldSet
4866         getUnknownFields() {
4867       return this.unknownFields;
4868     }
4869     private DiagnosticRequest(
4870         com.google.protobuf.CodedInputStream input,
4871         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4872         throws com.google.protobuf.InvalidProtocolBufferException {
4873       initFields();
4874       int mutable_bitField0_ = 0;
4875       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4876           com.google.protobuf.UnknownFieldSet.newBuilder();
4877       try {
4878         boolean done = false;
4879         while (!done) {
4880           int tag = input.readTag();
4881           switch (tag) {
4882             case 0:
4883               done = true;
4884               break;
4885             default: {
4886               if (!parseUnknownField(input, unknownFields,
4887                                      extensionRegistry, tag)) {
4888                 done = true;
4889               }
4890               break;
4891             }
4892             case 8: {
4893               bitField0_ |= 0x00000001;
4894               bus_ = input.readInt32();
4895               break;
4896             }
4897             case 16: {
4898               bitField0_ |= 0x00000002;
4899               messageId_ = input.readUInt32();
4900               break;
4901             }
4902             case 24: {
4903               bitField0_ |= 0x00000004;
4904               mode_ = input.readUInt32();
4905               break;
4906             }
4907             case 32: {
4908               bitField0_ |= 0x00000008;
4909               pid_ = input.readUInt32();
4910               break;
4911             }
4912             case 42: {
4913               bitField0_ |= 0x00000010;
4914               payload_ = input.readBytes();
4915               break;
4916             }
4917             case 48: {
4918               bitField0_ |= 0x00000020;
4919               multipleResponses_ = input.readBool();
4920               break;
4921             }
4922             case 57: {
4923               bitField0_ |= 0x00000040;
4924               frequency_ = input.readDouble();
4925               break;
4926             }
4927             case 66: {
4928               bitField0_ |= 0x00000080;
4929               name_ = input.readBytes();
4930               break;
4931             }
4932             case 72: {
4933               int rawValue = input.readEnum();
4934               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
4935               if (value == null) {
4936                 unknownFields.mergeVarintField(9, rawValue);
4937               } else {
4938                 bitField0_ |= 0x00000100;
4939                 decodedType_ = value;
4940               }
4941               break;
4942             }
4943           }
4944         }
4945       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4946         throw e.setUnfinishedMessage(this);
4947       } catch (java.io.IOException e) {
4948         throw new com.google.protobuf.InvalidProtocolBufferException(
4949             e.getMessage()).setUnfinishedMessage(this);
4950       } finally {
4951         this.unknownFields = unknownFields.build();
4952         makeExtensionsImmutable();
4953       }
4954     }
4955     public static final com.google.protobuf.Descriptors.Descriptor
4956         getDescriptor() {
4957       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4958     }
4959
4960     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4961         internalGetFieldAccessorTable() {
4962       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
4963           .ensureFieldAccessorsInitialized(
4964               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
4965     }
4966
4967     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
4968         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
4969       public DiagnosticRequest parsePartialFrom(
4970           com.google.protobuf.CodedInputStream input,
4971           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4972           throws com.google.protobuf.InvalidProtocolBufferException {
4973         return new DiagnosticRequest(input, extensionRegistry);
4974       }
4975     };
4976
4977     @java.lang.Override
4978     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
4979       return PARSER;
4980     }
4981
4982     /**
4983      * Protobuf enum {@code openxc.DiagnosticRequest.DecodedType}
4984      */
4985     public enum DecodedType
4986         implements com.google.protobuf.ProtocolMessageEnum {
4987       /**
4988        * <code>NONE = 1;</code>
4989        */
4990       NONE(0, 1),
4991       /**
4992        * <code>OBD2 = 2;</code>
4993        */
4994       OBD2(1, 2),
4995       ;
4996
4997       /**
4998        * <code>NONE = 1;</code>
4999        */
5000       public static final int NONE_VALUE = 1;
5001       /**
5002        * <code>OBD2 = 2;</code>
5003        */
5004       public static final int OBD2_VALUE = 2;
5005
5006
5007       public final int getNumber() { return value; }
5008
5009       public static DecodedType valueOf(int value) {
5010         switch (value) {
5011           case 1: return NONE;
5012           case 2: return OBD2;
5013           default: return null;
5014         }
5015       }
5016
5017       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
5018           internalGetValueMap() {
5019         return internalValueMap;
5020       }
5021       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
5022           internalValueMap =
5023             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
5024               public DecodedType findValueByNumber(int number) {
5025                 return DecodedType.valueOf(number);
5026               }
5027             };
5028
5029       public final com.google.protobuf.Descriptors.EnumValueDescriptor
5030           getValueDescriptor() {
5031         return getDescriptor().getValues().get(index);
5032       }
5033       public final com.google.protobuf.Descriptors.EnumDescriptor
5034           getDescriptorForType() {
5035         return getDescriptor();
5036       }
5037       public static final com.google.protobuf.Descriptors.EnumDescriptor
5038           getDescriptor() {
5039         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
5040       }
5041
5042       private static final DecodedType[] VALUES = values();
5043
5044       public static DecodedType valueOf(
5045           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
5046         if (desc.getType() != getDescriptor()) {
5047           throw new java.lang.IllegalArgumentException(
5048             "EnumValueDescriptor is not for this type.");
5049         }
5050         return VALUES[desc.getIndex()];
5051       }
5052
5053       private final int index;
5054       private final int value;
5055
5056       private DecodedType(int index, int value) {
5057         this.index = index;
5058         this.value = value;
5059       }
5060
5061       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
5062     }
5063
5064     private int bitField0_;
5065     // optional int32 bus = 1;
5066     public static final int BUS_FIELD_NUMBER = 1;
5067     private int bus_;
5068     /**
5069      * <code>optional int32 bus = 1;</code>
5070      */
5071     public boolean hasBus() {
5072       return ((bitField0_ & 0x00000001) == 0x00000001);
5073     }
5074     /**
5075      * <code>optional int32 bus = 1;</code>
5076      */
5077     public int getBus() {
5078       return bus_;
5079     }
5080
5081     // optional uint32 message_id = 2;
5082     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
5083     private int messageId_;
5084     /**
5085      * <code>optional uint32 message_id = 2;</code>
5086      */
5087     public boolean hasMessageId() {
5088       return ((bitField0_ & 0x00000002) == 0x00000002);
5089     }
5090     /**
5091      * <code>optional uint32 message_id = 2;</code>
5092      */
5093     public int getMessageId() {
5094       return messageId_;
5095     }
5096
5097     // optional uint32 mode = 3;
5098     public static final int MODE_FIELD_NUMBER = 3;
5099     private int mode_;
5100     /**
5101      * <code>optional uint32 mode = 3;</code>
5102      */
5103     public boolean hasMode() {
5104       return ((bitField0_ & 0x00000004) == 0x00000004);
5105     }
5106     /**
5107      * <code>optional uint32 mode = 3;</code>
5108      */
5109     public int getMode() {
5110       return mode_;
5111     }
5112
5113     // optional uint32 pid = 4;
5114     public static final int PID_FIELD_NUMBER = 4;
5115     private int pid_;
5116     /**
5117      * <code>optional uint32 pid = 4;</code>
5118      */
5119     public boolean hasPid() {
5120       return ((bitField0_ & 0x00000008) == 0x00000008);
5121     }
5122     /**
5123      * <code>optional uint32 pid = 4;</code>
5124      */
5125     public int getPid() {
5126       return pid_;
5127     }
5128
5129     // optional bytes payload = 5;
5130     public static final int PAYLOAD_FIELD_NUMBER = 5;
5131     private com.google.protobuf.ByteString payload_;
5132     /**
5133      * <code>optional bytes payload = 5;</code>
5134      *
5135      * <pre>
5136      * TODO we are capping this at 8 bytes for now - need to change when we
5137      * support multi-frame responses
5138      * </pre>
5139      */
5140     public boolean hasPayload() {
5141       return ((bitField0_ & 0x00000010) == 0x00000010);
5142     }
5143     /**
5144      * <code>optional bytes payload = 5;</code>
5145      *
5146      * <pre>
5147      * TODO we are capping this at 8 bytes for now - need to change when we
5148      * support multi-frame responses
5149      * </pre>
5150      */
5151     public com.google.protobuf.ByteString getPayload() {
5152       return payload_;
5153     }
5154
5155     // optional bool multiple_responses = 6;
5156     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
5157     private boolean multipleResponses_;
5158     /**
5159      * <code>optional bool multiple_responses = 6;</code>
5160      */
5161     public boolean hasMultipleResponses() {
5162       return ((bitField0_ & 0x00000020) == 0x00000020);
5163     }
5164     /**
5165      * <code>optional bool multiple_responses = 6;</code>
5166      */
5167     public boolean getMultipleResponses() {
5168       return multipleResponses_;
5169     }
5170
5171     // optional double frequency = 7;
5172     public static final int FREQUENCY_FIELD_NUMBER = 7;
5173     private double frequency_;
5174     /**
5175      * <code>optional double frequency = 7;</code>
5176      */
5177     public boolean hasFrequency() {
5178       return ((bitField0_ & 0x00000040) == 0x00000040);
5179     }
5180     /**
5181      * <code>optional double frequency = 7;</code>
5182      */
5183     public double getFrequency() {
5184       return frequency_;
5185     }
5186
5187     // optional string name = 8;
5188     public static final int NAME_FIELD_NUMBER = 8;
5189     private java.lang.Object name_;
5190     /**
5191      * <code>optional string name = 8;</code>
5192      */
5193     public boolean hasName() {
5194       return ((bitField0_ & 0x00000080) == 0x00000080);
5195     }
5196     /**
5197      * <code>optional string name = 8;</code>
5198      */
5199     public java.lang.String getName() {
5200       java.lang.Object ref = name_;
5201       if (ref instanceof java.lang.String) {
5202         return (java.lang.String) ref;
5203       } else {
5204         com.google.protobuf.ByteString bs =
5205             (com.google.protobuf.ByteString) ref;
5206         java.lang.String s = bs.toStringUtf8();
5207         if (bs.isValidUtf8()) {
5208           name_ = s;
5209         }
5210         return s;
5211       }
5212     }
5213     /**
5214      * <code>optional string name = 8;</code>
5215      */
5216     public com.google.protobuf.ByteString
5217         getNameBytes() {
5218       java.lang.Object ref = name_;
5219       if (ref instanceof java.lang.String) {
5220         com.google.protobuf.ByteString b =
5221             com.google.protobuf.ByteString.copyFromUtf8(
5222                 (java.lang.String) ref);
5223         name_ = b;
5224         return b;
5225       } else {
5226         return (com.google.protobuf.ByteString) ref;
5227       }
5228     }
5229
5230     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
5231     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
5232     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
5233     /**
5234      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
5235      */
5236     public boolean hasDecodedType() {
5237       return ((bitField0_ & 0x00000100) == 0x00000100);
5238     }
5239     /**
5240      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
5241      */
5242     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
5243       return decodedType_;
5244     }
5245
5246     private void initFields() {
5247       bus_ = 0;
5248       messageId_ = 0;
5249       mode_ = 0;
5250       pid_ = 0;
5251       payload_ = com.google.protobuf.ByteString.EMPTY;
5252       multipleResponses_ = false;
5253       frequency_ = 0D;
5254       name_ = "";
5255       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
5256     }
5257     private byte memoizedIsInitialized = -1;
5258     public final boolean isInitialized() {
5259       byte isInitialized = memoizedIsInitialized;
5260       if (isInitialized != -1) return isInitialized == 1;
5261
5262       memoizedIsInitialized = 1;
5263       return true;
5264     }
5265
5266     public void writeTo(com.google.protobuf.CodedOutputStream output)
5267                         throws java.io.IOException {
5268       getSerializedSize();
5269       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5270         output.writeInt32(1, bus_);
5271       }
5272       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5273         output.writeUInt32(2, messageId_);
5274       }
5275       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5276         output.writeUInt32(3, mode_);
5277       }
5278       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5279         output.writeUInt32(4, pid_);
5280       }
5281       if (((bitField0_ & 0x00000010) == 0x00000010)) {
5282         output.writeBytes(5, payload_);
5283       }
5284       if (((bitField0_ & 0x00000020) == 0x00000020)) {
5285         output.writeBool(6, multipleResponses_);
5286       }
5287       if (((bitField0_ & 0x00000040) == 0x00000040)) {
5288         output.writeDouble(7, frequency_);
5289       }
5290       if (((bitField0_ & 0x00000080) == 0x00000080)) {
5291         output.writeBytes(8, getNameBytes());
5292       }
5293       if (((bitField0_ & 0x00000100) == 0x00000100)) {
5294         output.writeEnum(9, decodedType_.getNumber());
5295       }
5296       getUnknownFields().writeTo(output);
5297     }
5298
5299     private int memoizedSerializedSize = -1;
5300     public int getSerializedSize() {
5301       int size = memoizedSerializedSize;
5302       if (size != -1) return size;
5303
5304       size = 0;
5305       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5306         size += com.google.protobuf.CodedOutputStream
5307           .computeInt32Size(1, bus_);
5308       }
5309       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5310         size += com.google.protobuf.CodedOutputStream
5311           .computeUInt32Size(2, messageId_);
5312       }
5313       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5314         size += com.google.protobuf.CodedOutputStream
5315           .computeUInt32Size(3, mode_);
5316       }
5317       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5318         size += com.google.protobuf.CodedOutputStream
5319           .computeUInt32Size(4, pid_);
5320       }
5321       if (((bitField0_ & 0x00000010) == 0x00000010)) {
5322         size += com.google.protobuf.CodedOutputStream
5323           .computeBytesSize(5, payload_);
5324       }
5325       if (((bitField0_ & 0x00000020) == 0x00000020)) {
5326         size += com.google.protobuf.CodedOutputStream
5327           .computeBoolSize(6, multipleResponses_);
5328       }
5329       if (((bitField0_ & 0x00000040) == 0x00000040)) {
5330         size += com.google.protobuf.CodedOutputStream
5331           .computeDoubleSize(7, frequency_);
5332       }
5333       if (((bitField0_ & 0x00000080) == 0x00000080)) {
5334         size += com.google.protobuf.CodedOutputStream
5335           .computeBytesSize(8, getNameBytes());
5336       }
5337       if (((bitField0_ & 0x00000100) == 0x00000100)) {
5338         size += com.google.protobuf.CodedOutputStream
5339           .computeEnumSize(9, decodedType_.getNumber());
5340       }
5341       size += getUnknownFields().getSerializedSize();
5342       memoizedSerializedSize = size;
5343       return size;
5344     }
5345
5346     private static final long serialVersionUID = 0L;
5347     @java.lang.Override
5348     protected java.lang.Object writeReplace()
5349         throws java.io.ObjectStreamException {
5350       return super.writeReplace();
5351     }
5352
5353     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
5354         com.google.protobuf.ByteString data)
5355         throws com.google.protobuf.InvalidProtocolBufferException {
5356       return PARSER.parseFrom(data);
5357     }
5358     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
5359         com.google.protobuf.ByteString data,
5360         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5361         throws com.google.protobuf.InvalidProtocolBufferException {
5362       return PARSER.parseFrom(data, extensionRegistry);
5363     }
5364     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
5365         throws com.google.protobuf.InvalidProtocolBufferException {
5366       return PARSER.parseFrom(data);
5367     }
5368     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
5369         byte[] data,
5370         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5371         throws com.google.protobuf.InvalidProtocolBufferException {
5372       return PARSER.parseFrom(data, extensionRegistry);
5373     }
5374     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
5375         throws java.io.IOException {
5376       return PARSER.parseFrom(input);
5377     }
5378     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
5379         java.io.InputStream input,
5380         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5381         throws java.io.IOException {
5382       return PARSER.parseFrom(input, extensionRegistry);
5383     }
5384     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
5385         throws java.io.IOException {
5386       return PARSER.parseDelimitedFrom(input);
5387     }
5388     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
5389         java.io.InputStream input,
5390         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5391         throws java.io.IOException {
5392       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5393     }
5394     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
5395         com.google.protobuf.CodedInputStream input)
5396         throws java.io.IOException {
5397       return PARSER.parseFrom(input);
5398     }
5399     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
5400         com.google.protobuf.CodedInputStream input,
5401         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5402         throws java.io.IOException {
5403       return PARSER.parseFrom(input, extensionRegistry);
5404     }
5405
5406     public static Builder newBuilder() { return Builder.create(); }
5407     public Builder newBuilderForType() { return newBuilder(); }
5408     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
5409       return newBuilder().mergeFrom(prototype);
5410     }
5411     public Builder toBuilder() { return newBuilder(this); }
5412
5413     @java.lang.Override
5414     protected Builder newBuilderForType(
5415         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5416       Builder builder = new Builder(parent);
5417       return builder;
5418     }
5419     /**
5420      * Protobuf type {@code openxc.DiagnosticRequest}
5421      */
5422     public static final class Builder extends
5423         com.google.protobuf.GeneratedMessage.Builder<Builder>
5424        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
5425       public static final com.google.protobuf.Descriptors.Descriptor
5426           getDescriptor() {
5427         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
5428       }
5429
5430       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5431           internalGetFieldAccessorTable() {
5432         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
5433             .ensureFieldAccessorsInitialized(
5434                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
5435       }
5436
5437       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
5438       private Builder() {
5439         maybeForceBuilderInitialization();
5440       }
5441
5442       private Builder(
5443           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5444         super(parent);
5445         maybeForceBuilderInitialization();
5446       }
5447       private void maybeForceBuilderInitialization() {
5448         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5449         }
5450       }
5451       private static Builder create() {
5452         return new Builder();
5453       }
5454
5455       public Builder clear() {
5456         super.clear();
5457         bus_ = 0;
5458         bitField0_ = (bitField0_ & ~0x00000001);
5459         messageId_ = 0;
5460         bitField0_ = (bitField0_ & ~0x00000002);
5461         mode_ = 0;
5462         bitField0_ = (bitField0_ & ~0x00000004);
5463         pid_ = 0;
5464         bitField0_ = (bitField0_ & ~0x00000008);
5465         payload_ = com.google.protobuf.ByteString.EMPTY;
5466         bitField0_ = (bitField0_ & ~0x00000010);
5467         multipleResponses_ = false;
5468         bitField0_ = (bitField0_ & ~0x00000020);
5469         frequency_ = 0D;
5470         bitField0_ = (bitField0_ & ~0x00000040);
5471         name_ = "";
5472         bitField0_ = (bitField0_ & ~0x00000080);
5473         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
5474         bitField0_ = (bitField0_ & ~0x00000100);
5475         return this;
5476       }
5477
5478       public Builder clone() {
5479         return create().mergeFrom(buildPartial());
5480       }
5481
5482       public com.google.protobuf.Descriptors.Descriptor
5483           getDescriptorForType() {
5484         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
5485       }
5486
5487       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
5488         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
5489       }
5490
5491       public com.openxc.BinaryMessages.DiagnosticRequest build() {
5492         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
5493         if (!result.isInitialized()) {
5494           throw newUninitializedMessageException(result);
5495         }
5496         return result;
5497       }
5498
5499       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
5500         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
5501         int from_bitField0_ = bitField0_;
5502         int to_bitField0_ = 0;
5503         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5504           to_bitField0_ |= 0x00000001;
5505         }
5506         result.bus_ = bus_;
5507         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5508           to_bitField0_ |= 0x00000002;
5509         }
5510         result.messageId_ = messageId_;
5511         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5512           to_bitField0_ |= 0x00000004;
5513         }
5514         result.mode_ = mode_;
5515         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
5516           to_bitField0_ |= 0x00000008;
5517         }
5518         result.pid_ = pid_;
5519         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
5520           to_bitField0_ |= 0x00000010;
5521         }
5522         result.payload_ = payload_;
5523         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
5524           to_bitField0_ |= 0x00000020;
5525         }
5526         result.multipleResponses_ = multipleResponses_;
5527         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
5528           to_bitField0_ |= 0x00000040;
5529         }
5530         result.frequency_ = frequency_;
5531         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
5532           to_bitField0_ |= 0x00000080;
5533         }
5534         result.name_ = name_;
5535         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
5536           to_bitField0_ |= 0x00000100;
5537         }
5538         result.decodedType_ = decodedType_;
5539         result.bitField0_ = to_bitField0_;
5540         onBuilt();
5541         return result;
5542       }
5543
5544       public Builder mergeFrom(com.google.protobuf.Message other) {
5545         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
5546           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
5547         } else {
5548           super.mergeFrom(other);
5549           return this;
5550         }
5551       }
5552
5553       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
5554         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
5555         if (other.hasBus()) {
5556           setBus(other.getBus());
5557         }
5558         if (other.hasMessageId()) {
5559           setMessageId(other.getMessageId());
5560         }
5561         if (other.hasMode()) {
5562           setMode(other.getMode());
5563         }
5564         if (other.hasPid()) {
5565           setPid(other.getPid());
5566         }
5567         if (other.hasPayload()) {
5568           setPayload(other.getPayload());
5569         }
5570         if (other.hasMultipleResponses()) {
5571           setMultipleResponses(other.getMultipleResponses());
5572         }
5573         if (other.hasFrequency()) {
5574           setFrequency(other.getFrequency());
5575         }
5576         if (other.hasName()) {
5577           bitField0_ |= 0x00000080;
5578           name_ = other.name_;
5579           onChanged();
5580         }
5581         if (other.hasDecodedType()) {
5582           setDecodedType(other.getDecodedType());
5583         }
5584         this.mergeUnknownFields(other.getUnknownFields());
5585         return this;
5586       }
5587
5588       public final boolean isInitialized() {
5589         return true;
5590       }
5591
5592       public Builder mergeFrom(
5593           com.google.protobuf.CodedInputStream input,
5594           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5595           throws java.io.IOException {
5596         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
5597         try {
5598           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5599         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5600           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
5601           throw e;
5602         } finally {
5603           if (parsedMessage != null) {
5604             mergeFrom(parsedMessage);
5605           }
5606         }
5607         return this;
5608       }
5609       private int bitField0_;
5610
5611       // optional int32 bus = 1;
5612       private int bus_ ;
5613       /**
5614        * <code>optional int32 bus = 1;</code>
5615        */
5616       public boolean hasBus() {
5617         return ((bitField0_ & 0x00000001) == 0x00000001);
5618       }
5619       /**
5620        * <code>optional int32 bus = 1;</code>
5621        */
5622       public int getBus() {
5623         return bus_;
5624       }
5625       /**
5626        * <code>optional int32 bus = 1;</code>
5627        */
5628       public Builder setBus(int value) {
5629         bitField0_ |= 0x00000001;
5630         bus_ = value;
5631         onChanged();
5632         return this;
5633       }
5634       /**
5635        * <code>optional int32 bus = 1;</code>
5636        */
5637       public Builder clearBus() {
5638         bitField0_ = (bitField0_ & ~0x00000001);
5639         bus_ = 0;
5640         onChanged();
5641         return this;
5642       }
5643
5644       // optional uint32 message_id = 2;
5645       private int messageId_ ;
5646       /**
5647        * <code>optional uint32 message_id = 2;</code>
5648        */
5649       public boolean hasMessageId() {
5650         return ((bitField0_ & 0x00000002) == 0x00000002);
5651       }
5652       /**
5653        * <code>optional uint32 message_id = 2;</code>
5654        */
5655       public int getMessageId() {
5656         return messageId_;
5657       }
5658       /**
5659        * <code>optional uint32 message_id = 2;</code>
5660        */
5661       public Builder setMessageId(int value) {
5662         bitField0_ |= 0x00000002;
5663         messageId_ = value;
5664         onChanged();
5665         return this;
5666       }
5667       /**
5668        * <code>optional uint32 message_id = 2;</code>
5669        */
5670       public Builder clearMessageId() {
5671         bitField0_ = (bitField0_ & ~0x00000002);
5672         messageId_ = 0;
5673         onChanged();
5674         return this;
5675       }
5676
5677       // optional uint32 mode = 3;
5678       private int mode_ ;
5679       /**
5680        * <code>optional uint32 mode = 3;</code>
5681        */
5682       public boolean hasMode() {
5683         return ((bitField0_ & 0x00000004) == 0x00000004);
5684       }
5685       /**
5686        * <code>optional uint32 mode = 3;</code>
5687        */
5688       public int getMode() {
5689         return mode_;
5690       }
5691       /**
5692        * <code>optional uint32 mode = 3;</code>
5693        */
5694       public Builder setMode(int value) {
5695         bitField0_ |= 0x00000004;
5696         mode_ = value;
5697         onChanged();
5698         return this;
5699       }
5700       /**
5701        * <code>optional uint32 mode = 3;</code>
5702        */
5703       public Builder clearMode() {
5704         bitField0_ = (bitField0_ & ~0x00000004);
5705         mode_ = 0;
5706         onChanged();
5707         return this;
5708       }
5709
5710       // optional uint32 pid = 4;
5711       private int pid_ ;
5712       /**
5713        * <code>optional uint32 pid = 4;</code>
5714        */
5715       public boolean hasPid() {
5716         return ((bitField0_ & 0x00000008) == 0x00000008);
5717       }
5718       /**
5719        * <code>optional uint32 pid = 4;</code>
5720        */
5721       public int getPid() {
5722         return pid_;
5723       }
5724       /**
5725        * <code>optional uint32 pid = 4;</code>
5726        */
5727       public Builder setPid(int value) {
5728         bitField0_ |= 0x00000008;
5729         pid_ = value;
5730         onChanged();
5731         return this;
5732       }
5733       /**
5734        * <code>optional uint32 pid = 4;</code>
5735        */
5736       public Builder clearPid() {
5737         bitField0_ = (bitField0_ & ~0x00000008);
5738         pid_ = 0;
5739         onChanged();
5740         return this;
5741       }
5742
5743       // optional bytes payload = 5;
5744       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
5745       /**
5746        * <code>optional bytes payload = 5;</code>
5747        *
5748        * <pre>
5749        * TODO we are capping this at 8 bytes for now - need to change when we
5750        * support multi-frame responses
5751        * </pre>
5752        */
5753       public boolean hasPayload() {
5754         return ((bitField0_ & 0x00000010) == 0x00000010);
5755       }
5756       /**
5757        * <code>optional bytes payload = 5;</code>
5758        *
5759        * <pre>
5760        * TODO we are capping this at 8 bytes for now - need to change when we
5761        * support multi-frame responses
5762        * </pre>
5763        */
5764       public com.google.protobuf.ByteString getPayload() {
5765         return payload_;
5766       }
5767       /**
5768        * <code>optional bytes payload = 5;</code>
5769        *
5770        * <pre>
5771        * TODO we are capping this at 8 bytes for now - need to change when we
5772        * support multi-frame responses
5773        * </pre>
5774        */
5775       public Builder setPayload(com.google.protobuf.ByteString value) {
5776         if (value == null) {
5777     throw new NullPointerException();
5778   }
5779   bitField0_ |= 0x00000010;
5780         payload_ = value;
5781         onChanged();
5782         return this;
5783       }
5784       /**
5785        * <code>optional bytes payload = 5;</code>
5786        *
5787        * <pre>
5788        * TODO we are capping this at 8 bytes for now - need to change when we
5789        * support multi-frame responses
5790        * </pre>
5791        */
5792       public Builder clearPayload() {
5793         bitField0_ = (bitField0_ & ~0x00000010);
5794         payload_ = getDefaultInstance().getPayload();
5795         onChanged();
5796         return this;
5797       }
5798
5799       // optional bool multiple_responses = 6;
5800       private boolean multipleResponses_ ;
5801       /**
5802        * <code>optional bool multiple_responses = 6;</code>
5803        */
5804       public boolean hasMultipleResponses() {
5805         return ((bitField0_ & 0x00000020) == 0x00000020);
5806       }
5807       /**
5808        * <code>optional bool multiple_responses = 6;</code>
5809        */
5810       public boolean getMultipleResponses() {
5811         return multipleResponses_;
5812       }
5813       /**
5814        * <code>optional bool multiple_responses = 6;</code>
5815        */
5816       public Builder setMultipleResponses(boolean value) {
5817         bitField0_ |= 0x00000020;
5818         multipleResponses_ = value;
5819         onChanged();
5820         return this;
5821       }
5822       /**
5823        * <code>optional bool multiple_responses = 6;</code>
5824        */
5825       public Builder clearMultipleResponses() {
5826         bitField0_ = (bitField0_ & ~0x00000020);
5827         multipleResponses_ = false;
5828         onChanged();
5829         return this;
5830       }
5831
5832       // optional double frequency = 7;
5833       private double frequency_ ;
5834       /**
5835        * <code>optional double frequency = 7;</code>
5836        */
5837       public boolean hasFrequency() {
5838         return ((bitField0_ & 0x00000040) == 0x00000040);
5839       }
5840       /**
5841        * <code>optional double frequency = 7;</code>
5842        */
5843       public double getFrequency() {
5844         return frequency_;
5845       }
5846       /**
5847        * <code>optional double frequency = 7;</code>
5848        */
5849       public Builder setFrequency(double value) {
5850         bitField0_ |= 0x00000040;
5851         frequency_ = value;
5852         onChanged();
5853         return this;
5854       }
5855       /**
5856        * <code>optional double frequency = 7;</code>
5857        */
5858       public Builder clearFrequency() {
5859         bitField0_ = (bitField0_ & ~0x00000040);
5860         frequency_ = 0D;
5861         onChanged();
5862         return this;
5863       }
5864
5865       // optional string name = 8;
5866       private java.lang.Object name_ = "";
5867       /**
5868        * <code>optional string name = 8;</code>
5869        */
5870       public boolean hasName() {
5871         return ((bitField0_ & 0x00000080) == 0x00000080);
5872       }
5873       /**
5874        * <code>optional string name = 8;</code>
5875        */
5876       public java.lang.String getName() {
5877         java.lang.Object ref = name_;
5878         if (!(ref instanceof java.lang.String)) {
5879           java.lang.String s = ((com.google.protobuf.ByteString) ref)
5880               .toStringUtf8();
5881           name_ = s;
5882           return s;
5883         } else {
5884           return (java.lang.String) ref;
5885         }
5886       }
5887       /**
5888        * <code>optional string name = 8;</code>
5889        */
5890       public com.google.protobuf.ByteString
5891           getNameBytes() {
5892         java.lang.Object ref = name_;
5893         if (ref instanceof String) {
5894           com.google.protobuf.ByteString b =
5895               com.google.protobuf.ByteString.copyFromUtf8(
5896                   (java.lang.String) ref);
5897           name_ = b;
5898           return b;
5899         } else {
5900           return (com.google.protobuf.ByteString) ref;
5901         }
5902       }
5903       /**
5904        * <code>optional string name = 8;</code>
5905        */
5906       public Builder setName(
5907           java.lang.String value) {
5908         if (value == null) {
5909     throw new NullPointerException();
5910   }
5911   bitField0_ |= 0x00000080;
5912         name_ = value;
5913         onChanged();
5914         return this;
5915       }
5916       /**
5917        * <code>optional string name = 8;</code>
5918        */
5919       public Builder clearName() {
5920         bitField0_ = (bitField0_ & ~0x00000080);
5921         name_ = getDefaultInstance().getName();
5922         onChanged();
5923         return this;
5924       }
5925       /**
5926        * <code>optional string name = 8;</code>
5927        */
5928       public Builder setNameBytes(
5929           com.google.protobuf.ByteString value) {
5930         if (value == null) {
5931     throw new NullPointerException();
5932   }
5933   bitField0_ |= 0x00000080;
5934         name_ = value;
5935         onChanged();
5936         return this;
5937       }
5938
5939       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
5940       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
5941       /**
5942        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
5943        */
5944       public boolean hasDecodedType() {
5945         return ((bitField0_ & 0x00000100) == 0x00000100);
5946       }
5947       /**
5948        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
5949        */
5950       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
5951         return decodedType_;
5952       }
5953       /**
5954        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
5955        */
5956       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
5957         if (value == null) {
5958           throw new NullPointerException();
5959         }
5960         bitField0_ |= 0x00000100;
5961         decodedType_ = value;
5962         onChanged();
5963         return this;
5964       }
5965       /**
5966        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
5967        */
5968       public Builder clearDecodedType() {
5969         bitField0_ = (bitField0_ & ~0x00000100);
5970         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
5971         onChanged();
5972         return this;
5973       }
5974
5975       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
5976     }
5977
5978     static {
5979       defaultInstance = new DiagnosticRequest(true);
5980       defaultInstance.initFields();
5981     }
5982
5983     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
5984   }
5985
5986   public interface DiagnosticResponseOrBuilder
5987       extends com.google.protobuf.MessageOrBuilder {
5988
5989     // optional int32 bus = 1;
5990     /**
5991      * <code>optional int32 bus = 1;</code>
5992      */
5993     boolean hasBus();
5994     /**
5995      * <code>optional int32 bus = 1;</code>
5996      */
5997     int getBus();
5998
5999     // optional uint32 message_id = 2;
6000     /**
6001      * <code>optional uint32 message_id = 2;</code>
6002      */
6003     boolean hasMessageId();
6004     /**
6005      * <code>optional uint32 message_id = 2;</code>
6006      */
6007     int getMessageId();
6008
6009     // optional uint32 mode = 3;
6010     /**
6011      * <code>optional uint32 mode = 3;</code>
6012      */
6013     boolean hasMode();
6014     /**
6015      * <code>optional uint32 mode = 3;</code>
6016      */
6017     int getMode();
6018
6019     // optional uint32 pid = 4;
6020     /**
6021      * <code>optional uint32 pid = 4;</code>
6022      */
6023     boolean hasPid();
6024     /**
6025      * <code>optional uint32 pid = 4;</code>
6026      */
6027     int getPid();
6028
6029     // optional bool success = 5;
6030     /**
6031      * <code>optional bool success = 5;</code>
6032      */
6033     boolean hasSuccess();
6034     /**
6035      * <code>optional bool success = 5;</code>
6036      */
6037     boolean getSuccess();
6038
6039     // optional uint32 negative_response_code = 6;
6040     /**
6041      * <code>optional uint32 negative_response_code = 6;</code>
6042      */
6043     boolean hasNegativeResponseCode();
6044     /**
6045      * <code>optional uint32 negative_response_code = 6;</code>
6046      */
6047     int getNegativeResponseCode();
6048
6049     // optional bytes payload = 7;
6050     /**
6051      * <code>optional bytes payload = 7;</code>
6052      *
6053      * <pre>
6054      * TODO we are capping this at 8 bytes for now - need to change when we
6055      * support multi-frame responses
6056      * </pre>
6057      */
6058     boolean hasPayload();
6059     /**
6060      * <code>optional bytes payload = 7;</code>
6061      *
6062      * <pre>
6063      * TODO we are capping this at 8 bytes for now - need to change when we
6064      * support multi-frame responses
6065      * </pre>
6066      */
6067     com.google.protobuf.ByteString getPayload();
6068
6069     // optional double value = 8;
6070     /**
6071      * <code>optional double value = 8;</code>
6072      */
6073     boolean hasValue();
6074     /**
6075      * <code>optional double value = 8;</code>
6076      */
6077     double getValue();
6078   }
6079   /**
6080    * Protobuf type {@code openxc.DiagnosticResponse}
6081    */
6082   public static final class DiagnosticResponse extends
6083       com.google.protobuf.GeneratedMessage
6084       implements DiagnosticResponseOrBuilder {
6085     // Use DiagnosticResponse.newBuilder() to construct.
6086     private DiagnosticResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6087       super(builder);
6088       this.unknownFields = builder.getUnknownFields();
6089     }
6090     private DiagnosticResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6091
6092     private static final DiagnosticResponse defaultInstance;
6093     public static DiagnosticResponse getDefaultInstance() {
6094       return defaultInstance;
6095     }
6096
6097     public DiagnosticResponse getDefaultInstanceForType() {
6098       return defaultInstance;
6099     }
6100
6101     private final com.google.protobuf.UnknownFieldSet unknownFields;
6102     @java.lang.Override
6103     public final com.google.protobuf.UnknownFieldSet
6104         getUnknownFields() {
6105       return this.unknownFields;
6106     }
6107     private DiagnosticResponse(
6108         com.google.protobuf.CodedInputStream input,
6109         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6110         throws com.google.protobuf.InvalidProtocolBufferException {
6111       initFields();
6112       int mutable_bitField0_ = 0;
6113       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6114           com.google.protobuf.UnknownFieldSet.newBuilder();
6115       try {
6116         boolean done = false;
6117         while (!done) {
6118           int tag = input.readTag();
6119           switch (tag) {
6120             case 0:
6121               done = true;
6122               break;
6123             default: {
6124               if (!parseUnknownField(input, unknownFields,
6125                                      extensionRegistry, tag)) {
6126                 done = true;
6127               }
6128               break;
6129             }
6130             case 8: {
6131               bitField0_ |= 0x00000001;
6132               bus_ = input.readInt32();
6133               break;
6134             }
6135             case 16: {
6136               bitField0_ |= 0x00000002;
6137               messageId_ = input.readUInt32();
6138               break;
6139             }
6140             case 24: {
6141               bitField0_ |= 0x00000004;
6142               mode_ = input.readUInt32();
6143               break;
6144             }
6145             case 32: {
6146               bitField0_ |= 0x00000008;
6147               pid_ = input.readUInt32();
6148               break;
6149             }
6150             case 40: {
6151               bitField0_ |= 0x00000010;
6152               success_ = input.readBool();
6153               break;
6154             }
6155             case 48: {
6156               bitField0_ |= 0x00000020;
6157               negativeResponseCode_ = input.readUInt32();
6158               break;
6159             }
6160             case 58: {
6161               bitField0_ |= 0x00000040;
6162               payload_ = input.readBytes();
6163               break;
6164             }
6165             case 65: {
6166               bitField0_ |= 0x00000080;
6167               value_ = input.readDouble();
6168               break;
6169             }
6170           }
6171         }
6172       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6173         throw e.setUnfinishedMessage(this);
6174       } catch (java.io.IOException e) {
6175         throw new com.google.protobuf.InvalidProtocolBufferException(
6176             e.getMessage()).setUnfinishedMessage(this);
6177       } finally {
6178         this.unknownFields = unknownFields.build();
6179         makeExtensionsImmutable();
6180       }
6181     }
6182     public static final com.google.protobuf.Descriptors.Descriptor
6183         getDescriptor() {
6184       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
6185     }
6186
6187     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6188         internalGetFieldAccessorTable() {
6189       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
6190           .ensureFieldAccessorsInitialized(
6191               com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
6192     }
6193
6194     public static com.google.protobuf.Parser<DiagnosticResponse> PARSER =
6195         new com.google.protobuf.AbstractParser<DiagnosticResponse>() {
6196       public DiagnosticResponse parsePartialFrom(
6197           com.google.protobuf.CodedInputStream input,
6198           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6199           throws com.google.protobuf.InvalidProtocolBufferException {
6200         return new DiagnosticResponse(input, extensionRegistry);
6201       }
6202     };
6203
6204     @java.lang.Override
6205     public com.google.protobuf.Parser<DiagnosticResponse> getParserForType() {
6206       return PARSER;
6207     }
6208
6209     private int bitField0_;
6210     // optional int32 bus = 1;
6211     public static final int BUS_FIELD_NUMBER = 1;
6212     private int bus_;
6213     /**
6214      * <code>optional int32 bus = 1;</code>
6215      */
6216     public boolean hasBus() {
6217       return ((bitField0_ & 0x00000001) == 0x00000001);
6218     }
6219     /**
6220      * <code>optional int32 bus = 1;</code>
6221      */
6222     public int getBus() {
6223       return bus_;
6224     }
6225
6226     // optional uint32 message_id = 2;
6227     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
6228     private int messageId_;
6229     /**
6230      * <code>optional uint32 message_id = 2;</code>
6231      */
6232     public boolean hasMessageId() {
6233       return ((bitField0_ & 0x00000002) == 0x00000002);
6234     }
6235     /**
6236      * <code>optional uint32 message_id = 2;</code>
6237      */
6238     public int getMessageId() {
6239       return messageId_;
6240     }
6241
6242     // optional uint32 mode = 3;
6243     public static final int MODE_FIELD_NUMBER = 3;
6244     private int mode_;
6245     /**
6246      * <code>optional uint32 mode = 3;</code>
6247      */
6248     public boolean hasMode() {
6249       return ((bitField0_ & 0x00000004) == 0x00000004);
6250     }
6251     /**
6252      * <code>optional uint32 mode = 3;</code>
6253      */
6254     public int getMode() {
6255       return mode_;
6256     }
6257
6258     // optional uint32 pid = 4;
6259     public static final int PID_FIELD_NUMBER = 4;
6260     private int pid_;
6261     /**
6262      * <code>optional uint32 pid = 4;</code>
6263      */
6264     public boolean hasPid() {
6265       return ((bitField0_ & 0x00000008) == 0x00000008);
6266     }
6267     /**
6268      * <code>optional uint32 pid = 4;</code>
6269      */
6270     public int getPid() {
6271       return pid_;
6272     }
6273
6274     // optional bool success = 5;
6275     public static final int SUCCESS_FIELD_NUMBER = 5;
6276     private boolean success_;
6277     /**
6278      * <code>optional bool success = 5;</code>
6279      */
6280     public boolean hasSuccess() {
6281       return ((bitField0_ & 0x00000010) == 0x00000010);
6282     }
6283     /**
6284      * <code>optional bool success = 5;</code>
6285      */
6286     public boolean getSuccess() {
6287       return success_;
6288     }
6289
6290     // optional uint32 negative_response_code = 6;
6291     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
6292     private int negativeResponseCode_;
6293     /**
6294      * <code>optional uint32 negative_response_code = 6;</code>
6295      */
6296     public boolean hasNegativeResponseCode() {
6297       return ((bitField0_ & 0x00000020) == 0x00000020);
6298     }
6299     /**
6300      * <code>optional uint32 negative_response_code = 6;</code>
6301      */
6302     public int getNegativeResponseCode() {
6303       return negativeResponseCode_;
6304     }
6305
6306     // optional bytes payload = 7;
6307     public static final int PAYLOAD_FIELD_NUMBER = 7;
6308     private com.google.protobuf.ByteString payload_;
6309     /**
6310      * <code>optional bytes payload = 7;</code>
6311      *
6312      * <pre>
6313      * TODO we are capping this at 8 bytes for now - need to change when we
6314      * support multi-frame responses
6315      * </pre>
6316      */
6317     public boolean hasPayload() {
6318       return ((bitField0_ & 0x00000040) == 0x00000040);
6319     }
6320     /**
6321      * <code>optional bytes payload = 7;</code>
6322      *
6323      * <pre>
6324      * TODO we are capping this at 8 bytes for now - need to change when we
6325      * support multi-frame responses
6326      * </pre>
6327      */
6328     public com.google.protobuf.ByteString getPayload() {
6329       return payload_;
6330     }
6331
6332     // optional double value = 8;
6333     public static final int VALUE_FIELD_NUMBER = 8;
6334     private double value_;
6335     /**
6336      * <code>optional double value = 8;</code>
6337      */
6338     public boolean hasValue() {
6339       return ((bitField0_ & 0x00000080) == 0x00000080);
6340     }
6341     /**
6342      * <code>optional double value = 8;</code>
6343      */
6344     public double getValue() {
6345       return value_;
6346     }
6347
6348     private void initFields() {
6349       bus_ = 0;
6350       messageId_ = 0;
6351       mode_ = 0;
6352       pid_ = 0;
6353       success_ = false;
6354       negativeResponseCode_ = 0;
6355       payload_ = com.google.protobuf.ByteString.EMPTY;
6356       value_ = 0D;
6357     }
6358     private byte memoizedIsInitialized = -1;
6359     public final boolean isInitialized() {
6360       byte isInitialized = memoizedIsInitialized;
6361       if (isInitialized != -1) return isInitialized == 1;
6362
6363       memoizedIsInitialized = 1;
6364       return true;
6365     }
6366
6367     public void writeTo(com.google.protobuf.CodedOutputStream output)
6368                         throws java.io.IOException {
6369       getSerializedSize();
6370       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6371         output.writeInt32(1, bus_);
6372       }
6373       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6374         output.writeUInt32(2, messageId_);
6375       }
6376       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6377         output.writeUInt32(3, mode_);
6378       }
6379       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6380         output.writeUInt32(4, pid_);
6381       }
6382       if (((bitField0_ & 0x00000010) == 0x00000010)) {
6383         output.writeBool(5, success_);
6384       }
6385       if (((bitField0_ & 0x00000020) == 0x00000020)) {
6386         output.writeUInt32(6, negativeResponseCode_);
6387       }
6388       if (((bitField0_ & 0x00000040) == 0x00000040)) {
6389         output.writeBytes(7, payload_);
6390       }
6391       if (((bitField0_ & 0x00000080) == 0x00000080)) {
6392         output.writeDouble(8, value_);
6393       }
6394       getUnknownFields().writeTo(output);
6395     }
6396
6397     private int memoizedSerializedSize = -1;
6398     public int getSerializedSize() {
6399       int size = memoizedSerializedSize;
6400       if (size != -1) return size;
6401
6402       size = 0;
6403       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6404         size += com.google.protobuf.CodedOutputStream
6405           .computeInt32Size(1, bus_);
6406       }
6407       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6408         size += com.google.protobuf.CodedOutputStream
6409           .computeUInt32Size(2, messageId_);
6410       }
6411       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6412         size += com.google.protobuf.CodedOutputStream
6413           .computeUInt32Size(3, mode_);
6414       }
6415       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6416         size += com.google.protobuf.CodedOutputStream
6417           .computeUInt32Size(4, pid_);
6418       }
6419       if (((bitField0_ & 0x00000010) == 0x00000010)) {
6420         size += com.google.protobuf.CodedOutputStream
6421           .computeBoolSize(5, success_);
6422       }
6423       if (((bitField0_ & 0x00000020) == 0x00000020)) {
6424         size += com.google.protobuf.CodedOutputStream
6425           .computeUInt32Size(6, negativeResponseCode_);
6426       }
6427       if (((bitField0_ & 0x00000040) == 0x00000040)) {
6428         size += com.google.protobuf.CodedOutputStream
6429           .computeBytesSize(7, payload_);
6430       }
6431       if (((bitField0_ & 0x00000080) == 0x00000080)) {
6432         size += com.google.protobuf.CodedOutputStream
6433           .computeDoubleSize(8, value_);
6434       }
6435       size += getUnknownFields().getSerializedSize();
6436       memoizedSerializedSize = size;
6437       return size;
6438     }
6439
6440     private static final long serialVersionUID = 0L;
6441     @java.lang.Override
6442     protected java.lang.Object writeReplace()
6443         throws java.io.ObjectStreamException {
6444       return super.writeReplace();
6445     }
6446
6447     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
6448         com.google.protobuf.ByteString data)
6449         throws com.google.protobuf.InvalidProtocolBufferException {
6450       return PARSER.parseFrom(data);
6451     }
6452     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
6453         com.google.protobuf.ByteString data,
6454         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6455         throws com.google.protobuf.InvalidProtocolBufferException {
6456       return PARSER.parseFrom(data, extensionRegistry);
6457     }
6458     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
6459         throws com.google.protobuf.InvalidProtocolBufferException {
6460       return PARSER.parseFrom(data);
6461     }
6462     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
6463         byte[] data,
6464         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6465         throws com.google.protobuf.InvalidProtocolBufferException {
6466       return PARSER.parseFrom(data, extensionRegistry);
6467     }
6468     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
6469         throws java.io.IOException {
6470       return PARSER.parseFrom(input);
6471     }
6472     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
6473         java.io.InputStream input,
6474         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6475         throws java.io.IOException {
6476       return PARSER.parseFrom(input, extensionRegistry);
6477     }
6478     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
6479         throws java.io.IOException {
6480       return PARSER.parseDelimitedFrom(input);
6481     }
6482     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
6483         java.io.InputStream input,
6484         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6485         throws java.io.IOException {
6486       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6487     }
6488     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
6489         com.google.protobuf.CodedInputStream input)
6490         throws java.io.IOException {
6491       return PARSER.parseFrom(input);
6492     }
6493     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
6494         com.google.protobuf.CodedInputStream input,
6495         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6496         throws java.io.IOException {
6497       return PARSER.parseFrom(input, extensionRegistry);
6498     }
6499
6500     public static Builder newBuilder() { return Builder.create(); }
6501     public Builder newBuilderForType() { return newBuilder(); }
6502     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
6503       return newBuilder().mergeFrom(prototype);
6504     }
6505     public Builder toBuilder() { return newBuilder(this); }
6506
6507     @java.lang.Override
6508     protected Builder newBuilderForType(
6509         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6510       Builder builder = new Builder(parent);
6511       return builder;
6512     }
6513     /**
6514      * Protobuf type {@code openxc.DiagnosticResponse}
6515      */
6516     public static final class Builder extends
6517         com.google.protobuf.GeneratedMessage.Builder<Builder>
6518        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
6519       public static final com.google.protobuf.Descriptors.Descriptor
6520           getDescriptor() {
6521         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
6522       }
6523
6524       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6525           internalGetFieldAccessorTable() {
6526         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
6527             .ensureFieldAccessorsInitialized(
6528                 com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
6529       }
6530
6531       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
6532       private Builder() {
6533         maybeForceBuilderInitialization();
6534       }
6535
6536       private Builder(
6537           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6538         super(parent);
6539         maybeForceBuilderInitialization();
6540       }
6541       private void maybeForceBuilderInitialization() {
6542         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6543         }
6544       }
6545       private static Builder create() {
6546         return new Builder();
6547       }
6548
6549       public Builder clear() {
6550         super.clear();
6551         bus_ = 0;
6552         bitField0_ = (bitField0_ & ~0x00000001);
6553         messageId_ = 0;
6554         bitField0_ = (bitField0_ & ~0x00000002);
6555         mode_ = 0;
6556         bitField0_ = (bitField0_ & ~0x00000004);
6557         pid_ = 0;
6558         bitField0_ = (bitField0_ & ~0x00000008);
6559         success_ = false;
6560         bitField0_ = (bitField0_ & ~0x00000010);
6561         negativeResponseCode_ = 0;
6562         bitField0_ = (bitField0_ & ~0x00000020);
6563         payload_ = com.google.protobuf.ByteString.EMPTY;
6564         bitField0_ = (bitField0_ & ~0x00000040);
6565         value_ = 0D;
6566         bitField0_ = (bitField0_ & ~0x00000080);
6567         return this;
6568       }
6569
6570       public Builder clone() {
6571         return create().mergeFrom(buildPartial());
6572       }
6573
6574       public com.google.protobuf.Descriptors.Descriptor
6575           getDescriptorForType() {
6576         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
6577       }
6578
6579       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
6580         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
6581       }
6582
6583       public com.openxc.BinaryMessages.DiagnosticResponse build() {
6584         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
6585         if (!result.isInitialized()) {
6586           throw newUninitializedMessageException(result);
6587         }
6588         return result;
6589       }
6590
6591       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
6592         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
6593         int from_bitField0_ = bitField0_;
6594         int to_bitField0_ = 0;
6595         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6596           to_bitField0_ |= 0x00000001;
6597         }
6598         result.bus_ = bus_;
6599         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6600           to_bitField0_ |= 0x00000002;
6601         }
6602         result.messageId_ = messageId_;
6603         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6604           to_bitField0_ |= 0x00000004;
6605         }
6606         result.mode_ = mode_;
6607         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
6608           to_bitField0_ |= 0x00000008;
6609         }
6610         result.pid_ = pid_;
6611         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
6612           to_bitField0_ |= 0x00000010;
6613         }
6614         result.success_ = success_;
6615         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
6616           to_bitField0_ |= 0x00000020;
6617         }
6618         result.negativeResponseCode_ = negativeResponseCode_;
6619         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
6620           to_bitField0_ |= 0x00000040;
6621         }
6622         result.payload_ = payload_;
6623         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
6624           to_bitField0_ |= 0x00000080;
6625         }
6626         result.value_ = value_;
6627         result.bitField0_ = to_bitField0_;
6628         onBuilt();
6629         return result;
6630       }
6631
6632       public Builder mergeFrom(com.google.protobuf.Message other) {
6633         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
6634           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
6635         } else {
6636           super.mergeFrom(other);
6637           return this;
6638         }
6639       }
6640
6641       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
6642         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
6643         if (other.hasBus()) {
6644           setBus(other.getBus());
6645         }
6646         if (other.hasMessageId()) {
6647           setMessageId(other.getMessageId());
6648         }
6649         if (other.hasMode()) {
6650           setMode(other.getMode());
6651         }
6652         if (other.hasPid()) {
6653           setPid(other.getPid());
6654         }
6655         if (other.hasSuccess()) {
6656           setSuccess(other.getSuccess());
6657         }
6658         if (other.hasNegativeResponseCode()) {
6659           setNegativeResponseCode(other.getNegativeResponseCode());
6660         }
6661         if (other.hasPayload()) {
6662           setPayload(other.getPayload());
6663         }
6664         if (other.hasValue()) {
6665           setValue(other.getValue());
6666         }
6667         this.mergeUnknownFields(other.getUnknownFields());
6668         return this;
6669       }
6670
6671       public final boolean isInitialized() {
6672         return true;
6673       }
6674
6675       public Builder mergeFrom(
6676           com.google.protobuf.CodedInputStream input,
6677           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6678           throws java.io.IOException {
6679         com.openxc.BinaryMessages.DiagnosticResponse parsedMessage = null;
6680         try {
6681           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6682         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6683           parsedMessage = (com.openxc.BinaryMessages.DiagnosticResponse) e.getUnfinishedMessage();
6684           throw e;
6685         } finally {
6686           if (parsedMessage != null) {
6687             mergeFrom(parsedMessage);
6688           }
6689         }
6690         return this;
6691       }
6692       private int bitField0_;
6693
6694       // optional int32 bus = 1;
6695       private int bus_ ;
6696       /**
6697        * <code>optional int32 bus = 1;</code>
6698        */
6699       public boolean hasBus() {
6700         return ((bitField0_ & 0x00000001) == 0x00000001);
6701       }
6702       /**
6703        * <code>optional int32 bus = 1;</code>
6704        */
6705       public int getBus() {
6706         return bus_;
6707       }
6708       /**
6709        * <code>optional int32 bus = 1;</code>
6710        */
6711       public Builder setBus(int value) {
6712         bitField0_ |= 0x00000001;
6713         bus_ = value;
6714         onChanged();
6715         return this;
6716       }
6717       /**
6718        * <code>optional int32 bus = 1;</code>
6719        */
6720       public Builder clearBus() {
6721         bitField0_ = (bitField0_ & ~0x00000001);
6722         bus_ = 0;
6723         onChanged();
6724         return this;
6725       }
6726
6727       // optional uint32 message_id = 2;
6728       private int messageId_ ;
6729       /**
6730        * <code>optional uint32 message_id = 2;</code>
6731        */
6732       public boolean hasMessageId() {
6733         return ((bitField0_ & 0x00000002) == 0x00000002);
6734       }
6735       /**
6736        * <code>optional uint32 message_id = 2;</code>
6737        */
6738       public int getMessageId() {
6739         return messageId_;
6740       }
6741       /**
6742        * <code>optional uint32 message_id = 2;</code>
6743        */
6744       public Builder setMessageId(int value) {
6745         bitField0_ |= 0x00000002;
6746         messageId_ = value;
6747         onChanged();
6748         return this;
6749       }
6750       /**
6751        * <code>optional uint32 message_id = 2;</code>
6752        */
6753       public Builder clearMessageId() {
6754         bitField0_ = (bitField0_ & ~0x00000002);
6755         messageId_ = 0;
6756         onChanged();
6757         return this;
6758       }
6759
6760       // optional uint32 mode = 3;
6761       private int mode_ ;
6762       /**
6763        * <code>optional uint32 mode = 3;</code>
6764        */
6765       public boolean hasMode() {
6766         return ((bitField0_ & 0x00000004) == 0x00000004);
6767       }
6768       /**
6769        * <code>optional uint32 mode = 3;</code>
6770        */
6771       public int getMode() {
6772         return mode_;
6773       }
6774       /**
6775        * <code>optional uint32 mode = 3;</code>
6776        */
6777       public Builder setMode(int value) {
6778         bitField0_ |= 0x00000004;
6779         mode_ = value;
6780         onChanged();
6781         return this;
6782       }
6783       /**
6784        * <code>optional uint32 mode = 3;</code>
6785        */
6786       public Builder clearMode() {
6787         bitField0_ = (bitField0_ & ~0x00000004);
6788         mode_ = 0;
6789         onChanged();
6790         return this;
6791       }
6792
6793       // optional uint32 pid = 4;
6794       private int pid_ ;
6795       /**
6796        * <code>optional uint32 pid = 4;</code>
6797        */
6798       public boolean hasPid() {
6799         return ((bitField0_ & 0x00000008) == 0x00000008);
6800       }
6801       /**
6802        * <code>optional uint32 pid = 4;</code>
6803        */
6804       public int getPid() {
6805         return pid_;
6806       }
6807       /**
6808        * <code>optional uint32 pid = 4;</code>
6809        */
6810       public Builder setPid(int value) {
6811         bitField0_ |= 0x00000008;
6812         pid_ = value;
6813         onChanged();
6814         return this;
6815       }
6816       /**
6817        * <code>optional uint32 pid = 4;</code>
6818        */
6819       public Builder clearPid() {
6820         bitField0_ = (bitField0_ & ~0x00000008);
6821         pid_ = 0;
6822         onChanged();
6823         return this;
6824       }
6825
6826       // optional bool success = 5;
6827       private boolean success_ ;
6828       /**
6829        * <code>optional bool success = 5;</code>
6830        */
6831       public boolean hasSuccess() {
6832         return ((bitField0_ & 0x00000010) == 0x00000010);
6833       }
6834       /**
6835        * <code>optional bool success = 5;</code>
6836        */
6837       public boolean getSuccess() {
6838         return success_;
6839       }
6840       /**
6841        * <code>optional bool success = 5;</code>
6842        */
6843       public Builder setSuccess(boolean value) {
6844         bitField0_ |= 0x00000010;
6845         success_ = value;
6846         onChanged();
6847         return this;
6848       }
6849       /**
6850        * <code>optional bool success = 5;</code>
6851        */
6852       public Builder clearSuccess() {
6853         bitField0_ = (bitField0_ & ~0x00000010);
6854         success_ = false;
6855         onChanged();
6856         return this;
6857       }
6858
6859       // optional uint32 negative_response_code = 6;
6860       private int negativeResponseCode_ ;
6861       /**
6862        * <code>optional uint32 negative_response_code = 6;</code>
6863        */
6864       public boolean hasNegativeResponseCode() {
6865         return ((bitField0_ & 0x00000020) == 0x00000020);
6866       }
6867       /**
6868        * <code>optional uint32 negative_response_code = 6;</code>
6869        */
6870       public int getNegativeResponseCode() {
6871         return negativeResponseCode_;
6872       }
6873       /**
6874        * <code>optional uint32 negative_response_code = 6;</code>
6875        */
6876       public Builder setNegativeResponseCode(int value) {
6877         bitField0_ |= 0x00000020;
6878         negativeResponseCode_ = value;
6879         onChanged();
6880         return this;
6881       }
6882       /**
6883        * <code>optional uint32 negative_response_code = 6;</code>
6884        */
6885       public Builder clearNegativeResponseCode() {
6886         bitField0_ = (bitField0_ & ~0x00000020);
6887         negativeResponseCode_ = 0;
6888         onChanged();
6889         return this;
6890       }
6891
6892       // optional bytes payload = 7;
6893       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
6894       /**
6895        * <code>optional bytes payload = 7;</code>
6896        *
6897        * <pre>
6898        * TODO we are capping this at 8 bytes for now - need to change when we
6899        * support multi-frame responses
6900        * </pre>
6901        */
6902       public boolean hasPayload() {
6903         return ((bitField0_ & 0x00000040) == 0x00000040);
6904       }
6905       /**
6906        * <code>optional bytes payload = 7;</code>
6907        *
6908        * <pre>
6909        * TODO we are capping this at 8 bytes for now - need to change when we
6910        * support multi-frame responses
6911        * </pre>
6912        */
6913       public com.google.protobuf.ByteString getPayload() {
6914         return payload_;
6915       }
6916       /**
6917        * <code>optional bytes payload = 7;</code>
6918        *
6919        * <pre>
6920        * TODO we are capping this at 8 bytes for now - need to change when we
6921        * support multi-frame responses
6922        * </pre>
6923        */
6924       public Builder setPayload(com.google.protobuf.ByteString value) {
6925         if (value == null) {
6926     throw new NullPointerException();
6927   }
6928   bitField0_ |= 0x00000040;
6929         payload_ = value;
6930         onChanged();
6931         return this;
6932       }
6933       /**
6934        * <code>optional bytes payload = 7;</code>
6935        *
6936        * <pre>
6937        * TODO we are capping this at 8 bytes for now - need to change when we
6938        * support multi-frame responses
6939        * </pre>
6940        */
6941       public Builder clearPayload() {
6942         bitField0_ = (bitField0_ & ~0x00000040);
6943         payload_ = getDefaultInstance().getPayload();
6944         onChanged();
6945         return this;
6946       }
6947
6948       // optional double value = 8;
6949       private double value_ ;
6950       /**
6951        * <code>optional double value = 8;</code>
6952        */
6953       public boolean hasValue() {
6954         return ((bitField0_ & 0x00000080) == 0x00000080);
6955       }
6956       /**
6957        * <code>optional double value = 8;</code>
6958        */
6959       public double getValue() {
6960         return value_;
6961       }
6962       /**
6963        * <code>optional double value = 8;</code>
6964        */
6965       public Builder setValue(double value) {
6966         bitField0_ |= 0x00000080;
6967         value_ = value;
6968         onChanged();
6969         return this;
6970       }
6971       /**
6972        * <code>optional double value = 8;</code>
6973        */
6974       public Builder clearValue() {
6975         bitField0_ = (bitField0_ & ~0x00000080);
6976         value_ = 0D;
6977         onChanged();
6978         return this;
6979       }
6980
6981       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
6982     }
6983
6984     static {
6985       defaultInstance = new DiagnosticResponse(true);
6986       defaultInstance.initFields();
6987     }
6988
6989     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
6990   }
6991
6992   public interface DynamicFieldOrBuilder
6993       extends com.google.protobuf.MessageOrBuilder {
6994
6995     // optional .openxc.DynamicField.Type type = 1;
6996     /**
6997      * <code>optional .openxc.DynamicField.Type type = 1;</code>
6998      */
6999     boolean hasType();
7000     /**
7001      * <code>optional .openxc.DynamicField.Type type = 1;</code>
7002      */
7003     com.openxc.BinaryMessages.DynamicField.Type getType();
7004
7005     // optional string string_value = 2;
7006     /**
7007      * <code>optional string string_value = 2;</code>
7008      */
7009     boolean hasStringValue();
7010     /**
7011      * <code>optional string string_value = 2;</code>
7012      */
7013     java.lang.String getStringValue();
7014     /**
7015      * <code>optional string string_value = 2;</code>
7016      */
7017     com.google.protobuf.ByteString
7018         getStringValueBytes();
7019
7020     // optional double numeric_value = 3;
7021     /**
7022      * <code>optional double numeric_value = 3;</code>
7023      */
7024     boolean hasNumericValue();
7025     /**
7026      * <code>optional double numeric_value = 3;</code>
7027      */
7028     double getNumericValue();
7029
7030     // optional bool boolean_value = 4;
7031     /**
7032      * <code>optional bool boolean_value = 4;</code>
7033      */
7034     boolean hasBooleanValue();
7035     /**
7036      * <code>optional bool boolean_value = 4;</code>
7037      */
7038     boolean getBooleanValue();
7039   }
7040   /**
7041    * Protobuf type {@code openxc.DynamicField}
7042    */
7043   public static final class DynamicField extends
7044       com.google.protobuf.GeneratedMessage
7045       implements DynamicFieldOrBuilder {
7046     // Use DynamicField.newBuilder() to construct.
7047     private DynamicField(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
7048       super(builder);
7049       this.unknownFields = builder.getUnknownFields();
7050     }
7051     private DynamicField(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
7052
7053     private static final DynamicField defaultInstance;
7054     public static DynamicField getDefaultInstance() {
7055       return defaultInstance;
7056     }
7057
7058     public DynamicField getDefaultInstanceForType() {
7059       return defaultInstance;
7060     }
7061
7062     private final com.google.protobuf.UnknownFieldSet unknownFields;
7063     @java.lang.Override
7064     public final com.google.protobuf.UnknownFieldSet
7065         getUnknownFields() {
7066       return this.unknownFields;
7067     }
7068     private DynamicField(
7069         com.google.protobuf.CodedInputStream input,
7070         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7071         throws com.google.protobuf.InvalidProtocolBufferException {
7072       initFields();
7073       int mutable_bitField0_ = 0;
7074       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
7075           com.google.protobuf.UnknownFieldSet.newBuilder();
7076       try {
7077         boolean done = false;
7078         while (!done) {
7079           int tag = input.readTag();
7080           switch (tag) {
7081             case 0:
7082               done = true;
7083               break;
7084             default: {
7085               if (!parseUnknownField(input, unknownFields,
7086                                      extensionRegistry, tag)) {
7087                 done = true;
7088               }
7089               break;
7090             }
7091             case 8: {
7092               int rawValue = input.readEnum();
7093               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
7094               if (value == null) {
7095                 unknownFields.mergeVarintField(1, rawValue);
7096               } else {
7097                 bitField0_ |= 0x00000001;
7098                 type_ = value;
7099               }
7100               break;
7101             }
7102             case 18: {
7103               bitField0_ |= 0x00000002;
7104               stringValue_ = input.readBytes();
7105               break;
7106             }
7107             case 25: {
7108               bitField0_ |= 0x00000004;
7109               numericValue_ = input.readDouble();
7110               break;
7111             }
7112             case 32: {
7113               bitField0_ |= 0x00000008;
7114               booleanValue_ = input.readBool();
7115               break;
7116             }
7117           }
7118         }
7119       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7120         throw e.setUnfinishedMessage(this);
7121       } catch (java.io.IOException e) {
7122         throw new com.google.protobuf.InvalidProtocolBufferException(
7123             e.getMessage()).setUnfinishedMessage(this);
7124       } finally {
7125         this.unknownFields = unknownFields.build();
7126         makeExtensionsImmutable();
7127       }
7128     }
7129     public static final com.google.protobuf.Descriptors.Descriptor
7130         getDescriptor() {
7131       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
7132     }
7133
7134     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7135         internalGetFieldAccessorTable() {
7136       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
7137           .ensureFieldAccessorsInitialized(
7138               com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
7139     }
7140
7141     public static com.google.protobuf.Parser<DynamicField> PARSER =
7142         new com.google.protobuf.AbstractParser<DynamicField>() {
7143       public DynamicField parsePartialFrom(
7144           com.google.protobuf.CodedInputStream input,
7145           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7146           throws com.google.protobuf.InvalidProtocolBufferException {
7147         return new DynamicField(input, extensionRegistry);
7148       }
7149     };
7150
7151     @java.lang.Override
7152     public com.google.protobuf.Parser<DynamicField> getParserForType() {
7153       return PARSER;
7154     }
7155
7156     /**
7157      * Protobuf enum {@code openxc.DynamicField.Type}
7158      */
7159     public enum Type
7160         implements com.google.protobuf.ProtocolMessageEnum {
7161       /**
7162        * <code>STRING = 1;</code>
7163        */
7164       STRING(0, 1),
7165       /**
7166        * <code>NUM = 2;</code>
7167        */
7168       NUM(1, 2),
7169       /**
7170        * <code>BOOL = 3;</code>
7171        */
7172       BOOL(2, 3),
7173       ;
7174
7175       /**
7176        * <code>STRING = 1;</code>
7177        */
7178       public static final int STRING_VALUE = 1;
7179       /**
7180        * <code>NUM = 2;</code>
7181        */
7182       public static final int NUM_VALUE = 2;
7183       /**
7184        * <code>BOOL = 3;</code>
7185        */
7186       public static final int BOOL_VALUE = 3;
7187
7188
7189       public final int getNumber() { return value; }
7190
7191       public static Type valueOf(int value) {
7192         switch (value) {
7193           case 1: return STRING;
7194           case 2: return NUM;
7195           case 3: return BOOL;
7196           default: return null;
7197         }
7198       }
7199
7200       public static com.google.protobuf.Internal.EnumLiteMap<Type>
7201           internalGetValueMap() {
7202         return internalValueMap;
7203       }
7204       private static com.google.protobuf.Internal.EnumLiteMap<Type>
7205           internalValueMap =
7206             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
7207               public Type findValueByNumber(int number) {
7208                 return Type.valueOf(number);
7209               }
7210             };
7211
7212       public final com.google.protobuf.Descriptors.EnumValueDescriptor
7213           getValueDescriptor() {
7214         return getDescriptor().getValues().get(index);
7215       }
7216       public final com.google.protobuf.Descriptors.EnumDescriptor
7217           getDescriptorForType() {
7218         return getDescriptor();
7219       }
7220       public static final com.google.protobuf.Descriptors.EnumDescriptor
7221           getDescriptor() {
7222         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
7223       }
7224
7225       private static final Type[] VALUES = values();
7226
7227       public static Type valueOf(
7228           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
7229         if (desc.getType() != getDescriptor()) {
7230           throw new java.lang.IllegalArgumentException(
7231             "EnumValueDescriptor is not for this type.");
7232         }
7233         return VALUES[desc.getIndex()];
7234       }
7235
7236       private final int index;
7237       private final int value;
7238
7239       private Type(int index, int value) {
7240         this.index = index;
7241         this.value = value;
7242       }
7243
7244       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
7245     }
7246
7247     private int bitField0_;
7248     // optional .openxc.DynamicField.Type type = 1;
7249     public static final int TYPE_FIELD_NUMBER = 1;
7250     private com.openxc.BinaryMessages.DynamicField.Type type_;
7251     /**
7252      * <code>optional .openxc.DynamicField.Type type = 1;</code>
7253      */
7254     public boolean hasType() {
7255       return ((bitField0_ & 0x00000001) == 0x00000001);
7256     }
7257     /**
7258      * <code>optional .openxc.DynamicField.Type type = 1;</code>
7259      */
7260     public com.openxc.BinaryMessages.DynamicField.Type getType() {
7261       return type_;
7262     }
7263
7264     // optional string string_value = 2;
7265     public static final int STRING_VALUE_FIELD_NUMBER = 2;
7266     private java.lang.Object stringValue_;
7267     /**
7268      * <code>optional string string_value = 2;</code>
7269      */
7270     public boolean hasStringValue() {
7271       return ((bitField0_ & 0x00000002) == 0x00000002);
7272     }
7273     /**
7274      * <code>optional string string_value = 2;</code>
7275      */
7276     public java.lang.String getStringValue() {
7277       java.lang.Object ref = stringValue_;
7278       if (ref instanceof java.lang.String) {
7279         return (java.lang.String) ref;
7280       } else {
7281         com.google.protobuf.ByteString bs =
7282             (com.google.protobuf.ByteString) ref;
7283         java.lang.String s = bs.toStringUtf8();
7284         if (bs.isValidUtf8()) {
7285           stringValue_ = s;
7286         }
7287         return s;
7288       }
7289     }
7290     /**
7291      * <code>optional string string_value = 2;</code>
7292      */
7293     public com.google.protobuf.ByteString
7294         getStringValueBytes() {
7295       java.lang.Object ref = stringValue_;
7296       if (ref instanceof java.lang.String) {
7297         com.google.protobuf.ByteString b =
7298             com.google.protobuf.ByteString.copyFromUtf8(
7299                 (java.lang.String) ref);
7300         stringValue_ = b;
7301         return b;
7302       } else {
7303         return (com.google.protobuf.ByteString) ref;
7304       }
7305     }
7306
7307     // optional double numeric_value = 3;
7308     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
7309     private double numericValue_;
7310     /**
7311      * <code>optional double numeric_value = 3;</code>
7312      */
7313     public boolean hasNumericValue() {
7314       return ((bitField0_ & 0x00000004) == 0x00000004);
7315     }
7316     /**
7317      * <code>optional double numeric_value = 3;</code>
7318      */
7319     public double getNumericValue() {
7320       return numericValue_;
7321     }
7322
7323     // optional bool boolean_value = 4;
7324     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
7325     private boolean booleanValue_;
7326     /**
7327      * <code>optional bool boolean_value = 4;</code>
7328      */
7329     public boolean hasBooleanValue() {
7330       return ((bitField0_ & 0x00000008) == 0x00000008);
7331     }
7332     /**
7333      * <code>optional bool boolean_value = 4;</code>
7334      */
7335     public boolean getBooleanValue() {
7336       return booleanValue_;
7337     }
7338
7339     private void initFields() {
7340       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
7341       stringValue_ = "";
7342       numericValue_ = 0D;
7343       booleanValue_ = false;
7344     }
7345     private byte memoizedIsInitialized = -1;
7346     public final boolean isInitialized() {
7347       byte isInitialized = memoizedIsInitialized;
7348       if (isInitialized != -1) return isInitialized == 1;
7349
7350       memoizedIsInitialized = 1;
7351       return true;
7352     }
7353
7354     public void writeTo(com.google.protobuf.CodedOutputStream output)
7355                         throws java.io.IOException {
7356       getSerializedSize();
7357       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7358         output.writeEnum(1, type_.getNumber());
7359       }
7360       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7361         output.writeBytes(2, getStringValueBytes());
7362       }
7363       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7364         output.writeDouble(3, numericValue_);
7365       }
7366       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7367         output.writeBool(4, booleanValue_);
7368       }
7369       getUnknownFields().writeTo(output);
7370     }
7371
7372     private int memoizedSerializedSize = -1;
7373     public int getSerializedSize() {
7374       int size = memoizedSerializedSize;
7375       if (size != -1) return size;
7376
7377       size = 0;
7378       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7379         size += com.google.protobuf.CodedOutputStream
7380           .computeEnumSize(1, type_.getNumber());
7381       }
7382       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7383         size += com.google.protobuf.CodedOutputStream
7384           .computeBytesSize(2, getStringValueBytes());
7385       }
7386       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7387         size += com.google.protobuf.CodedOutputStream
7388           .computeDoubleSize(3, numericValue_);
7389       }
7390       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7391         size += com.google.protobuf.CodedOutputStream
7392           .computeBoolSize(4, booleanValue_);
7393       }
7394       size += getUnknownFields().getSerializedSize();
7395       memoizedSerializedSize = size;
7396       return size;
7397     }
7398
7399     private static final long serialVersionUID = 0L;
7400     @java.lang.Override
7401     protected java.lang.Object writeReplace()
7402         throws java.io.ObjectStreamException {
7403       return super.writeReplace();
7404     }
7405
7406     public static com.openxc.BinaryMessages.DynamicField parseFrom(
7407         com.google.protobuf.ByteString data)
7408         throws com.google.protobuf.InvalidProtocolBufferException {
7409       return PARSER.parseFrom(data);
7410     }
7411     public static com.openxc.BinaryMessages.DynamicField parseFrom(
7412         com.google.protobuf.ByteString data,
7413         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7414         throws com.google.protobuf.InvalidProtocolBufferException {
7415       return PARSER.parseFrom(data, extensionRegistry);
7416     }
7417     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
7418         throws com.google.protobuf.InvalidProtocolBufferException {
7419       return PARSER.parseFrom(data);
7420     }
7421     public static com.openxc.BinaryMessages.DynamicField parseFrom(
7422         byte[] data,
7423         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7424         throws com.google.protobuf.InvalidProtocolBufferException {
7425       return PARSER.parseFrom(data, extensionRegistry);
7426     }
7427     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
7428         throws java.io.IOException {
7429       return PARSER.parseFrom(input);
7430     }
7431     public static com.openxc.BinaryMessages.DynamicField parseFrom(
7432         java.io.InputStream input,
7433         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7434         throws java.io.IOException {
7435       return PARSER.parseFrom(input, extensionRegistry);
7436     }
7437     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
7438         throws java.io.IOException {
7439       return PARSER.parseDelimitedFrom(input);
7440     }
7441     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
7442         java.io.InputStream input,
7443         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7444         throws java.io.IOException {
7445       return PARSER.parseDelimitedFrom(input, extensionRegistry);
7446     }
7447     public static com.openxc.BinaryMessages.DynamicField parseFrom(
7448         com.google.protobuf.CodedInputStream input)
7449         throws java.io.IOException {
7450       return PARSER.parseFrom(input);
7451     }
7452     public static com.openxc.BinaryMessages.DynamicField parseFrom(
7453         com.google.protobuf.CodedInputStream input,
7454         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7455         throws java.io.IOException {
7456       return PARSER.parseFrom(input, extensionRegistry);
7457     }
7458
7459     public static Builder newBuilder() { return Builder.create(); }
7460     public Builder newBuilderForType() { return newBuilder(); }
7461     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
7462       return newBuilder().mergeFrom(prototype);
7463     }
7464     public Builder toBuilder() { return newBuilder(this); }
7465
7466     @java.lang.Override
7467     protected Builder newBuilderForType(
7468         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7469       Builder builder = new Builder(parent);
7470       return builder;
7471     }
7472     /**
7473      * Protobuf type {@code openxc.DynamicField}
7474      */
7475     public static final class Builder extends
7476         com.google.protobuf.GeneratedMessage.Builder<Builder>
7477        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
7478       public static final com.google.protobuf.Descriptors.Descriptor
7479           getDescriptor() {
7480         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
7481       }
7482
7483       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7484           internalGetFieldAccessorTable() {
7485         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
7486             .ensureFieldAccessorsInitialized(
7487                 com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
7488       }
7489
7490       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
7491       private Builder() {
7492         maybeForceBuilderInitialization();
7493       }
7494
7495       private Builder(
7496           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7497         super(parent);
7498         maybeForceBuilderInitialization();
7499       }
7500       private void maybeForceBuilderInitialization() {
7501         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7502         }
7503       }
7504       private static Builder create() {
7505         return new Builder();
7506       }
7507
7508       public Builder clear() {
7509         super.clear();
7510         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
7511         bitField0_ = (bitField0_ & ~0x00000001);
7512         stringValue_ = "";
7513         bitField0_ = (bitField0_ & ~0x00000002);
7514         numericValue_ = 0D;
7515         bitField0_ = (bitField0_ & ~0x00000004);
7516         booleanValue_ = false;
7517         bitField0_ = (bitField0_ & ~0x00000008);
7518         return this;
7519       }
7520
7521       public Builder clone() {
7522         return create().mergeFrom(buildPartial());
7523       }
7524
7525       public com.google.protobuf.Descriptors.Descriptor
7526           getDescriptorForType() {
7527         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
7528       }
7529
7530       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
7531         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7532       }
7533
7534       public com.openxc.BinaryMessages.DynamicField build() {
7535         com.openxc.BinaryMessages.DynamicField result = buildPartial();
7536         if (!result.isInitialized()) {
7537           throw newUninitializedMessageException(result);
7538         }
7539         return result;
7540       }
7541
7542       public com.openxc.BinaryMessages.DynamicField buildPartial() {
7543         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
7544         int from_bitField0_ = bitField0_;
7545         int to_bitField0_ = 0;
7546         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7547           to_bitField0_ |= 0x00000001;
7548         }
7549         result.type_ = type_;
7550         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7551           to_bitField0_ |= 0x00000002;
7552         }
7553         result.stringValue_ = stringValue_;
7554         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
7555           to_bitField0_ |= 0x00000004;
7556         }
7557         result.numericValue_ = numericValue_;
7558         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
7559           to_bitField0_ |= 0x00000008;
7560         }
7561         result.booleanValue_ = booleanValue_;
7562         result.bitField0_ = to_bitField0_;
7563         onBuilt();
7564         return result;
7565       }
7566
7567       public Builder mergeFrom(com.google.protobuf.Message other) {
7568         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
7569           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
7570         } else {
7571           super.mergeFrom(other);
7572           return this;
7573         }
7574       }
7575
7576       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
7577         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
7578         if (other.hasType()) {
7579           setType(other.getType());
7580         }
7581         if (other.hasStringValue()) {
7582           bitField0_ |= 0x00000002;
7583           stringValue_ = other.stringValue_;
7584           onChanged();
7585         }
7586         if (other.hasNumericValue()) {
7587           setNumericValue(other.getNumericValue());
7588         }
7589         if (other.hasBooleanValue()) {
7590           setBooleanValue(other.getBooleanValue());
7591         }
7592         this.mergeUnknownFields(other.getUnknownFields());
7593         return this;
7594       }
7595
7596       public final boolean isInitialized() {
7597         return true;
7598       }
7599
7600       public Builder mergeFrom(
7601           com.google.protobuf.CodedInputStream input,
7602           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7603           throws java.io.IOException {
7604         com.openxc.BinaryMessages.DynamicField parsedMessage = null;
7605         try {
7606           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
7607         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7608           parsedMessage = (com.openxc.BinaryMessages.DynamicField) e.getUnfinishedMessage();
7609           throw e;
7610         } finally {
7611           if (parsedMessage != null) {
7612             mergeFrom(parsedMessage);
7613           }
7614         }
7615         return this;
7616       }
7617       private int bitField0_;
7618
7619       // optional .openxc.DynamicField.Type type = 1;
7620       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
7621       /**
7622        * <code>optional .openxc.DynamicField.Type type = 1;</code>
7623        */
7624       public boolean hasType() {
7625         return ((bitField0_ & 0x00000001) == 0x00000001);
7626       }
7627       /**
7628        * <code>optional .openxc.DynamicField.Type type = 1;</code>
7629        */
7630       public com.openxc.BinaryMessages.DynamicField.Type getType() {
7631         return type_;
7632       }
7633       /**
7634        * <code>optional .openxc.DynamicField.Type type = 1;</code>
7635        */
7636       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
7637         if (value == null) {
7638           throw new NullPointerException();
7639         }
7640         bitField0_ |= 0x00000001;
7641         type_ = value;
7642         onChanged();
7643         return this;
7644       }
7645       /**
7646        * <code>optional .openxc.DynamicField.Type type = 1;</code>
7647        */
7648       public Builder clearType() {
7649         bitField0_ = (bitField0_ & ~0x00000001);
7650         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
7651         onChanged();
7652         return this;
7653       }
7654
7655       // optional string string_value = 2;
7656       private java.lang.Object stringValue_ = "";
7657       /**
7658        * <code>optional string string_value = 2;</code>
7659        */
7660       public boolean hasStringValue() {
7661         return ((bitField0_ & 0x00000002) == 0x00000002);
7662       }
7663       /**
7664        * <code>optional string string_value = 2;</code>
7665        */
7666       public java.lang.String getStringValue() {
7667         java.lang.Object ref = stringValue_;
7668         if (!(ref instanceof java.lang.String)) {
7669           java.lang.String s = ((com.google.protobuf.ByteString) ref)
7670               .toStringUtf8();
7671           stringValue_ = s;
7672           return s;
7673         } else {
7674           return (java.lang.String) ref;
7675         }
7676       }
7677       /**
7678        * <code>optional string string_value = 2;</code>
7679        */
7680       public com.google.protobuf.ByteString
7681           getStringValueBytes() {
7682         java.lang.Object ref = stringValue_;
7683         if (ref instanceof String) {
7684           com.google.protobuf.ByteString b =
7685               com.google.protobuf.ByteString.copyFromUtf8(
7686                   (java.lang.String) ref);
7687           stringValue_ = b;
7688           return b;
7689         } else {
7690           return (com.google.protobuf.ByteString) ref;
7691         }
7692       }
7693       /**
7694        * <code>optional string string_value = 2;</code>
7695        */
7696       public Builder setStringValue(
7697           java.lang.String value) {
7698         if (value == null) {
7699     throw new NullPointerException();
7700   }
7701   bitField0_ |= 0x00000002;
7702         stringValue_ = value;
7703         onChanged();
7704         return this;
7705       }
7706       /**
7707        * <code>optional string string_value = 2;</code>
7708        */
7709       public Builder clearStringValue() {
7710         bitField0_ = (bitField0_ & ~0x00000002);
7711         stringValue_ = getDefaultInstance().getStringValue();
7712         onChanged();
7713         return this;
7714       }
7715       /**
7716        * <code>optional string string_value = 2;</code>
7717        */
7718       public Builder setStringValueBytes(
7719           com.google.protobuf.ByteString value) {
7720         if (value == null) {
7721     throw new NullPointerException();
7722   }
7723   bitField0_ |= 0x00000002;
7724         stringValue_ = value;
7725         onChanged();
7726         return this;
7727       }
7728
7729       // optional double numeric_value = 3;
7730       private double numericValue_ ;
7731       /**
7732        * <code>optional double numeric_value = 3;</code>
7733        */
7734       public boolean hasNumericValue() {
7735         return ((bitField0_ & 0x00000004) == 0x00000004);
7736       }
7737       /**
7738        * <code>optional double numeric_value = 3;</code>
7739        */
7740       public double getNumericValue() {
7741         return numericValue_;
7742       }
7743       /**
7744        * <code>optional double numeric_value = 3;</code>
7745        */
7746       public Builder setNumericValue(double value) {
7747         bitField0_ |= 0x00000004;
7748         numericValue_ = value;
7749         onChanged();
7750         return this;
7751       }
7752       /**
7753        * <code>optional double numeric_value = 3;</code>
7754        */
7755       public Builder clearNumericValue() {
7756         bitField0_ = (bitField0_ & ~0x00000004);
7757         numericValue_ = 0D;
7758         onChanged();
7759         return this;
7760       }
7761
7762       // optional bool boolean_value = 4;
7763       private boolean booleanValue_ ;
7764       /**
7765        * <code>optional bool boolean_value = 4;</code>
7766        */
7767       public boolean hasBooleanValue() {
7768         return ((bitField0_ & 0x00000008) == 0x00000008);
7769       }
7770       /**
7771        * <code>optional bool boolean_value = 4;</code>
7772        */
7773       public boolean getBooleanValue() {
7774         return booleanValue_;
7775       }
7776       /**
7777        * <code>optional bool boolean_value = 4;</code>
7778        */
7779       public Builder setBooleanValue(boolean value) {
7780         bitField0_ |= 0x00000008;
7781         booleanValue_ = value;
7782         onChanged();
7783         return this;
7784       }
7785       /**
7786        * <code>optional bool boolean_value = 4;</code>
7787        */
7788       public Builder clearBooleanValue() {
7789         bitField0_ = (bitField0_ & ~0x00000008);
7790         booleanValue_ = false;
7791         onChanged();
7792         return this;
7793       }
7794
7795       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
7796     }
7797
7798     static {
7799       defaultInstance = new DynamicField(true);
7800       defaultInstance.initFields();
7801     }
7802
7803     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
7804   }
7805
7806   public interface TranslatedMessageOrBuilder
7807       extends com.google.protobuf.MessageOrBuilder {
7808
7809     // optional .openxc.TranslatedMessage.Type type = 1;
7810     /**
7811      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7812      */
7813     boolean hasType();
7814     /**
7815      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7816      */
7817     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
7818
7819     // optional string name = 2;
7820     /**
7821      * <code>optional string name = 2;</code>
7822      */
7823     boolean hasName();
7824     /**
7825      * <code>optional string name = 2;</code>
7826      */
7827     java.lang.String getName();
7828     /**
7829      * <code>optional string name = 2;</code>
7830      */
7831     com.google.protobuf.ByteString
7832         getNameBytes();
7833
7834     // optional .openxc.DynamicField value = 3;
7835     /**
7836      * <code>optional .openxc.DynamicField value = 3;</code>
7837      */
7838     boolean hasValue();
7839     /**
7840      * <code>optional .openxc.DynamicField value = 3;</code>
7841      */
7842     com.openxc.BinaryMessages.DynamicField getValue();
7843     /**
7844      * <code>optional .openxc.DynamicField value = 3;</code>
7845      */
7846     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
7847
7848     // optional .openxc.DynamicField event = 4;
7849     /**
7850      * <code>optional .openxc.DynamicField event = 4;</code>
7851      */
7852     boolean hasEvent();
7853     /**
7854      * <code>optional .openxc.DynamicField event = 4;</code>
7855      */
7856     com.openxc.BinaryMessages.DynamicField getEvent();
7857     /**
7858      * <code>optional .openxc.DynamicField event = 4;</code>
7859      */
7860     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
7861   }
7862   /**
7863    * Protobuf type {@code openxc.TranslatedMessage}
7864    */
7865   public static final class TranslatedMessage extends
7866       com.google.protobuf.GeneratedMessage
7867       implements TranslatedMessageOrBuilder {
7868     // Use TranslatedMessage.newBuilder() to construct.
7869     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
7870       super(builder);
7871       this.unknownFields = builder.getUnknownFields();
7872     }
7873     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
7874
7875     private static final TranslatedMessage defaultInstance;
7876     public static TranslatedMessage getDefaultInstance() {
7877       return defaultInstance;
7878     }
7879
7880     public TranslatedMessage getDefaultInstanceForType() {
7881       return defaultInstance;
7882     }
7883
7884     private final com.google.protobuf.UnknownFieldSet unknownFields;
7885     @java.lang.Override
7886     public final com.google.protobuf.UnknownFieldSet
7887         getUnknownFields() {
7888       return this.unknownFields;
7889     }
7890     private TranslatedMessage(
7891         com.google.protobuf.CodedInputStream input,
7892         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7893         throws com.google.protobuf.InvalidProtocolBufferException {
7894       initFields();
7895       int mutable_bitField0_ = 0;
7896       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
7897           com.google.protobuf.UnknownFieldSet.newBuilder();
7898       try {
7899         boolean done = false;
7900         while (!done) {
7901           int tag = input.readTag();
7902           switch (tag) {
7903             case 0:
7904               done = true;
7905               break;
7906             default: {
7907               if (!parseUnknownField(input, unknownFields,
7908                                      extensionRegistry, tag)) {
7909                 done = true;
7910               }
7911               break;
7912             }
7913             case 8: {
7914               int rawValue = input.readEnum();
7915               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
7916               if (value == null) {
7917                 unknownFields.mergeVarintField(1, rawValue);
7918               } else {
7919                 bitField0_ |= 0x00000001;
7920                 type_ = value;
7921               }
7922               break;
7923             }
7924             case 18: {
7925               bitField0_ |= 0x00000002;
7926               name_ = input.readBytes();
7927               break;
7928             }
7929             case 26: {
7930               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
7931               if (((bitField0_ & 0x00000004) == 0x00000004)) {
7932                 subBuilder = value_.toBuilder();
7933               }
7934               value_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
7935               if (subBuilder != null) {
7936                 subBuilder.mergeFrom(value_);
7937                 value_ = subBuilder.buildPartial();
7938               }
7939               bitField0_ |= 0x00000004;
7940               break;
7941             }
7942             case 34: {
7943               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
7944               if (((bitField0_ & 0x00000008) == 0x00000008)) {
7945                 subBuilder = event_.toBuilder();
7946               }
7947               event_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
7948               if (subBuilder != null) {
7949                 subBuilder.mergeFrom(event_);
7950                 event_ = subBuilder.buildPartial();
7951               }
7952               bitField0_ |= 0x00000008;
7953               break;
7954             }
7955           }
7956         }
7957       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7958         throw e.setUnfinishedMessage(this);
7959       } catch (java.io.IOException e) {
7960         throw new com.google.protobuf.InvalidProtocolBufferException(
7961             e.getMessage()).setUnfinishedMessage(this);
7962       } finally {
7963         this.unknownFields = unknownFields.build();
7964         makeExtensionsImmutable();
7965       }
7966     }
7967     public static final com.google.protobuf.Descriptors.Descriptor
7968         getDescriptor() {
7969       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
7970     }
7971
7972     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7973         internalGetFieldAccessorTable() {
7974       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
7975           .ensureFieldAccessorsInitialized(
7976               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
7977     }
7978
7979     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
7980         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
7981       public TranslatedMessage parsePartialFrom(
7982           com.google.protobuf.CodedInputStream input,
7983           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7984           throws com.google.protobuf.InvalidProtocolBufferException {
7985         return new TranslatedMessage(input, extensionRegistry);
7986       }
7987     };
7988
7989     @java.lang.Override
7990     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
7991       return PARSER;
7992     }
7993
7994     /**
7995      * Protobuf enum {@code openxc.TranslatedMessage.Type}
7996      */
7997     public enum Type
7998         implements com.google.protobuf.ProtocolMessageEnum {
7999       /**
8000        * <code>STRING = 1;</code>
8001        */
8002       STRING(0, 1),
8003       /**
8004        * <code>NUM = 2;</code>
8005        */
8006       NUM(1, 2),
8007       /**
8008        * <code>BOOL = 3;</code>
8009        */
8010       BOOL(2, 3),
8011       /**
8012        * <code>EVENTED_STRING = 4;</code>
8013        */
8014       EVENTED_STRING(3, 4),
8015       /**
8016        * <code>EVENTED_NUM = 5;</code>
8017        */
8018       EVENTED_NUM(4, 5),
8019       /**
8020        * <code>EVENTED_BOOL = 6;</code>
8021        */
8022       EVENTED_BOOL(5, 6),
8023       ;
8024
8025       /**
8026        * <code>STRING = 1;</code>
8027        */
8028       public static final int STRING_VALUE = 1;
8029       /**
8030        * <code>NUM = 2;</code>
8031        */
8032       public static final int NUM_VALUE = 2;
8033       /**
8034        * <code>BOOL = 3;</code>
8035        */
8036       public static final int BOOL_VALUE = 3;
8037       /**
8038        * <code>EVENTED_STRING = 4;</code>
8039        */
8040       public static final int EVENTED_STRING_VALUE = 4;
8041       /**
8042        * <code>EVENTED_NUM = 5;</code>
8043        */
8044       public static final int EVENTED_NUM_VALUE = 5;
8045       /**
8046        * <code>EVENTED_BOOL = 6;</code>
8047        */
8048       public static final int EVENTED_BOOL_VALUE = 6;
8049
8050
8051       public final int getNumber() { return value; }
8052
8053       public static Type valueOf(int value) {
8054         switch (value) {
8055           case 1: return STRING;
8056           case 2: return NUM;
8057           case 3: return BOOL;
8058           case 4: return EVENTED_STRING;
8059           case 5: return EVENTED_NUM;
8060           case 6: return EVENTED_BOOL;
8061           default: return null;
8062         }
8063       }
8064
8065       public static com.google.protobuf.Internal.EnumLiteMap<Type>
8066           internalGetValueMap() {
8067         return internalValueMap;
8068       }
8069       private static com.google.protobuf.Internal.EnumLiteMap<Type>
8070           internalValueMap =
8071             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
8072               public Type findValueByNumber(int number) {
8073                 return Type.valueOf(number);
8074               }
8075             };
8076
8077       public final com.google.protobuf.Descriptors.EnumValueDescriptor
8078           getValueDescriptor() {
8079         return getDescriptor().getValues().get(index);
8080       }
8081       public final com.google.protobuf.Descriptors.EnumDescriptor
8082           getDescriptorForType() {
8083         return getDescriptor();
8084       }
8085       public static final com.google.protobuf.Descriptors.EnumDescriptor
8086           getDescriptor() {
8087         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
8088       }
8089
8090       private static final Type[] VALUES = values();
8091
8092       public static Type valueOf(
8093           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
8094         if (desc.getType() != getDescriptor()) {
8095           throw new java.lang.IllegalArgumentException(
8096             "EnumValueDescriptor is not for this type.");
8097         }
8098         return VALUES[desc.getIndex()];
8099       }
8100
8101       private final int index;
8102       private final int value;
8103
8104       private Type(int index, int value) {
8105         this.index = index;
8106         this.value = value;
8107       }
8108
8109       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
8110     }
8111
8112     private int bitField0_;
8113     // optional .openxc.TranslatedMessage.Type type = 1;
8114     public static final int TYPE_FIELD_NUMBER = 1;
8115     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
8116     /**
8117      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
8118      */
8119     public boolean hasType() {
8120       return ((bitField0_ & 0x00000001) == 0x00000001);
8121     }
8122     /**
8123      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
8124      */
8125     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
8126       return type_;
8127     }
8128
8129     // optional string name = 2;
8130     public static final int NAME_FIELD_NUMBER = 2;
8131     private java.lang.Object name_;
8132     /**
8133      * <code>optional string name = 2;</code>
8134      */
8135     public boolean hasName() {
8136       return ((bitField0_ & 0x00000002) == 0x00000002);
8137     }
8138     /**
8139      * <code>optional string name = 2;</code>
8140      */
8141     public java.lang.String getName() {
8142       java.lang.Object ref = name_;
8143       if (ref instanceof java.lang.String) {
8144         return (java.lang.String) ref;
8145       } else {
8146         com.google.protobuf.ByteString bs =
8147             (com.google.protobuf.ByteString) ref;
8148         java.lang.String s = bs.toStringUtf8();
8149         if (bs.isValidUtf8()) {
8150           name_ = s;
8151         }
8152         return s;
8153       }
8154     }
8155     /**
8156      * <code>optional string name = 2;</code>
8157      */
8158     public com.google.protobuf.ByteString
8159         getNameBytes() {
8160       java.lang.Object ref = name_;
8161       if (ref instanceof java.lang.String) {
8162         com.google.protobuf.ByteString b =
8163             com.google.protobuf.ByteString.copyFromUtf8(
8164                 (java.lang.String) ref);
8165         name_ = b;
8166         return b;
8167       } else {
8168         return (com.google.protobuf.ByteString) ref;
8169       }
8170     }
8171
8172     // optional .openxc.DynamicField value = 3;
8173     public static final int VALUE_FIELD_NUMBER = 3;
8174     private com.openxc.BinaryMessages.DynamicField value_;
8175     /**
8176      * <code>optional .openxc.DynamicField value = 3;</code>
8177      */
8178     public boolean hasValue() {
8179       return ((bitField0_ & 0x00000004) == 0x00000004);
8180     }
8181     /**
8182      * <code>optional .openxc.DynamicField value = 3;</code>
8183      */
8184     public com.openxc.BinaryMessages.DynamicField getValue() {
8185       return value_;
8186     }
8187     /**
8188      * <code>optional .openxc.DynamicField value = 3;</code>
8189      */
8190     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
8191       return value_;
8192     }
8193
8194     // optional .openxc.DynamicField event = 4;
8195     public static final int EVENT_FIELD_NUMBER = 4;
8196     private com.openxc.BinaryMessages.DynamicField event_;
8197     /**
8198      * <code>optional .openxc.DynamicField event = 4;</code>
8199      */
8200     public boolean hasEvent() {
8201       return ((bitField0_ & 0x00000008) == 0x00000008);
8202     }
8203     /**
8204      * <code>optional .openxc.DynamicField event = 4;</code>
8205      */
8206     public com.openxc.BinaryMessages.DynamicField getEvent() {
8207       return event_;
8208     }
8209     /**
8210      * <code>optional .openxc.DynamicField event = 4;</code>
8211      */
8212     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
8213       return event_;
8214     }
8215
8216     private void initFields() {
8217       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
8218       name_ = "";
8219       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8220       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8221     }
8222     private byte memoizedIsInitialized = -1;
8223     public final boolean isInitialized() {
8224       byte isInitialized = memoizedIsInitialized;
8225       if (isInitialized != -1) return isInitialized == 1;
8226
8227       memoizedIsInitialized = 1;
8228       return true;
8229     }
8230
8231     public void writeTo(com.google.protobuf.CodedOutputStream output)
8232                         throws java.io.IOException {
8233       getSerializedSize();
8234       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8235         output.writeEnum(1, type_.getNumber());
8236       }
8237       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8238         output.writeBytes(2, getNameBytes());
8239       }
8240       if (((bitField0_ & 0x00000004) == 0x00000004)) {
8241         output.writeMessage(3, value_);
8242       }
8243       if (((bitField0_ & 0x00000008) == 0x00000008)) {
8244         output.writeMessage(4, event_);
8245       }
8246       getUnknownFields().writeTo(output);
8247     }
8248
8249     private int memoizedSerializedSize = -1;
8250     public int getSerializedSize() {
8251       int size = memoizedSerializedSize;
8252       if (size != -1) return size;
8253
8254       size = 0;
8255       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8256         size += com.google.protobuf.CodedOutputStream
8257           .computeEnumSize(1, type_.getNumber());
8258       }
8259       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8260         size += com.google.protobuf.CodedOutputStream
8261           .computeBytesSize(2, getNameBytes());
8262       }
8263       if (((bitField0_ & 0x00000004) == 0x00000004)) {
8264         size += com.google.protobuf.CodedOutputStream
8265           .computeMessageSize(3, value_);
8266       }
8267       if (((bitField0_ & 0x00000008) == 0x00000008)) {
8268         size += com.google.protobuf.CodedOutputStream
8269           .computeMessageSize(4, event_);
8270       }
8271       size += getUnknownFields().getSerializedSize();
8272       memoizedSerializedSize = size;
8273       return size;
8274     }
8275
8276     private static final long serialVersionUID = 0L;
8277     @java.lang.Override
8278     protected java.lang.Object writeReplace()
8279         throws java.io.ObjectStreamException {
8280       return super.writeReplace();
8281     }
8282
8283     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
8284         com.google.protobuf.ByteString data)
8285         throws com.google.protobuf.InvalidProtocolBufferException {
8286       return PARSER.parseFrom(data);
8287     }
8288     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
8289         com.google.protobuf.ByteString data,
8290         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8291         throws com.google.protobuf.InvalidProtocolBufferException {
8292       return PARSER.parseFrom(data, extensionRegistry);
8293     }
8294     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
8295         throws com.google.protobuf.InvalidProtocolBufferException {
8296       return PARSER.parseFrom(data);
8297     }
8298     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
8299         byte[] data,
8300         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8301         throws com.google.protobuf.InvalidProtocolBufferException {
8302       return PARSER.parseFrom(data, extensionRegistry);
8303     }
8304     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
8305         throws java.io.IOException {
8306       return PARSER.parseFrom(input);
8307     }
8308     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
8309         java.io.InputStream input,
8310         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8311         throws java.io.IOException {
8312       return PARSER.parseFrom(input, extensionRegistry);
8313     }
8314     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
8315         throws java.io.IOException {
8316       return PARSER.parseDelimitedFrom(input);
8317     }
8318     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
8319         java.io.InputStream input,
8320         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8321         throws java.io.IOException {
8322       return PARSER.parseDelimitedFrom(input, extensionRegistry);
8323     }
8324     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
8325         com.google.protobuf.CodedInputStream input)
8326         throws java.io.IOException {
8327       return PARSER.parseFrom(input);
8328     }
8329     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
8330         com.google.protobuf.CodedInputStream input,
8331         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8332         throws java.io.IOException {
8333       return PARSER.parseFrom(input, extensionRegistry);
8334     }
8335
8336     public static Builder newBuilder() { return Builder.create(); }
8337     public Builder newBuilderForType() { return newBuilder(); }
8338     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
8339       return newBuilder().mergeFrom(prototype);
8340     }
8341     public Builder toBuilder() { return newBuilder(this); }
8342
8343     @java.lang.Override
8344     protected Builder newBuilderForType(
8345         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8346       Builder builder = new Builder(parent);
8347       return builder;
8348     }
8349     /**
8350      * Protobuf type {@code openxc.TranslatedMessage}
8351      */
8352     public static final class Builder extends
8353         com.google.protobuf.GeneratedMessage.Builder<Builder>
8354        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
8355       public static final com.google.protobuf.Descriptors.Descriptor
8356           getDescriptor() {
8357         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
8358       }
8359
8360       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8361           internalGetFieldAccessorTable() {
8362         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
8363             .ensureFieldAccessorsInitialized(
8364                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
8365       }
8366
8367       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
8368       private Builder() {
8369         maybeForceBuilderInitialization();
8370       }
8371
8372       private Builder(
8373           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8374         super(parent);
8375         maybeForceBuilderInitialization();
8376       }
8377       private void maybeForceBuilderInitialization() {
8378         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
8379           getValueFieldBuilder();
8380           getEventFieldBuilder();
8381         }
8382       }
8383       private static Builder create() {
8384         return new Builder();
8385       }
8386
8387       public Builder clear() {
8388         super.clear();
8389         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
8390         bitField0_ = (bitField0_ & ~0x00000001);
8391         name_ = "";
8392         bitField0_ = (bitField0_ & ~0x00000002);
8393         if (valueBuilder_ == null) {
8394           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8395         } else {
8396           valueBuilder_.clear();
8397         }
8398         bitField0_ = (bitField0_ & ~0x00000004);
8399         if (eventBuilder_ == null) {
8400           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8401         } else {
8402           eventBuilder_.clear();
8403         }
8404         bitField0_ = (bitField0_ & ~0x00000008);
8405         return this;
8406       }
8407
8408       public Builder clone() {
8409         return create().mergeFrom(buildPartial());
8410       }
8411
8412       public com.google.protobuf.Descriptors.Descriptor
8413           getDescriptorForType() {
8414         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
8415       }
8416
8417       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
8418         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
8419       }
8420
8421       public com.openxc.BinaryMessages.TranslatedMessage build() {
8422         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
8423         if (!result.isInitialized()) {
8424           throw newUninitializedMessageException(result);
8425         }
8426         return result;
8427       }
8428
8429       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
8430         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
8431         int from_bitField0_ = bitField0_;
8432         int to_bitField0_ = 0;
8433         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
8434           to_bitField0_ |= 0x00000001;
8435         }
8436         result.type_ = type_;
8437         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
8438           to_bitField0_ |= 0x00000002;
8439         }
8440         result.name_ = name_;
8441         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
8442           to_bitField0_ |= 0x00000004;
8443         }
8444         if (valueBuilder_ == null) {
8445           result.value_ = value_;
8446         } else {
8447           result.value_ = valueBuilder_.build();
8448         }
8449         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
8450           to_bitField0_ |= 0x00000008;
8451         }
8452         if (eventBuilder_ == null) {
8453           result.event_ = event_;
8454         } else {
8455           result.event_ = eventBuilder_.build();
8456         }
8457         result.bitField0_ = to_bitField0_;
8458         onBuilt();
8459         return result;
8460       }
8461
8462       public Builder mergeFrom(com.google.protobuf.Message other) {
8463         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
8464           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
8465         } else {
8466           super.mergeFrom(other);
8467           return this;
8468         }
8469       }
8470
8471       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
8472         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
8473         if (other.hasType()) {
8474           setType(other.getType());
8475         }
8476         if (other.hasName()) {
8477           bitField0_ |= 0x00000002;
8478           name_ = other.name_;
8479           onChanged();
8480         }
8481         if (other.hasValue()) {
8482           mergeValue(other.getValue());
8483         }
8484         if (other.hasEvent()) {
8485           mergeEvent(other.getEvent());
8486         }
8487         this.mergeUnknownFields(other.getUnknownFields());
8488         return this;
8489       }
8490
8491       public final boolean isInitialized() {
8492         return true;
8493       }
8494
8495       public Builder mergeFrom(
8496           com.google.protobuf.CodedInputStream input,
8497           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8498           throws java.io.IOException {
8499         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
8500         try {
8501           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
8502         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8503           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
8504           throw e;
8505         } finally {
8506           if (parsedMessage != null) {
8507             mergeFrom(parsedMessage);
8508           }
8509         }
8510         return this;
8511       }
8512       private int bitField0_;
8513
8514       // optional .openxc.TranslatedMessage.Type type = 1;
8515       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
8516       /**
8517        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
8518        */
8519       public boolean hasType() {
8520         return ((bitField0_ & 0x00000001) == 0x00000001);
8521       }
8522       /**
8523        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
8524        */
8525       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
8526         return type_;
8527       }
8528       /**
8529        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
8530        */
8531       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
8532         if (value == null) {
8533           throw new NullPointerException();
8534         }
8535         bitField0_ |= 0x00000001;
8536         type_ = value;
8537         onChanged();
8538         return this;
8539       }
8540       /**
8541        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
8542        */
8543       public Builder clearType() {
8544         bitField0_ = (bitField0_ & ~0x00000001);
8545         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
8546         onChanged();
8547         return this;
8548       }
8549
8550       // optional string name = 2;
8551       private java.lang.Object name_ = "";
8552       /**
8553        * <code>optional string name = 2;</code>
8554        */
8555       public boolean hasName() {
8556         return ((bitField0_ & 0x00000002) == 0x00000002);
8557       }
8558       /**
8559        * <code>optional string name = 2;</code>
8560        */
8561       public java.lang.String getName() {
8562         java.lang.Object ref = name_;
8563         if (!(ref instanceof java.lang.String)) {
8564           java.lang.String s = ((com.google.protobuf.ByteString) ref)
8565               .toStringUtf8();
8566           name_ = s;
8567           return s;
8568         } else {
8569           return (java.lang.String) ref;
8570         }
8571       }
8572       /**
8573        * <code>optional string name = 2;</code>
8574        */
8575       public com.google.protobuf.ByteString
8576           getNameBytes() {
8577         java.lang.Object ref = name_;
8578         if (ref instanceof String) {
8579           com.google.protobuf.ByteString b =
8580               com.google.protobuf.ByteString.copyFromUtf8(
8581                   (java.lang.String) ref);
8582           name_ = b;
8583           return b;
8584         } else {
8585           return (com.google.protobuf.ByteString) ref;
8586         }
8587       }
8588       /**
8589        * <code>optional string name = 2;</code>
8590        */
8591       public Builder setName(
8592           java.lang.String value) {
8593         if (value == null) {
8594     throw new NullPointerException();
8595   }
8596   bitField0_ |= 0x00000002;
8597         name_ = value;
8598         onChanged();
8599         return this;
8600       }
8601       /**
8602        * <code>optional string name = 2;</code>
8603        */
8604       public Builder clearName() {
8605         bitField0_ = (bitField0_ & ~0x00000002);
8606         name_ = getDefaultInstance().getName();
8607         onChanged();
8608         return this;
8609       }
8610       /**
8611        * <code>optional string name = 2;</code>
8612        */
8613       public Builder setNameBytes(
8614           com.google.protobuf.ByteString value) {
8615         if (value == null) {
8616     throw new NullPointerException();
8617   }
8618   bitField0_ |= 0x00000002;
8619         name_ = value;
8620         onChanged();
8621         return this;
8622       }
8623
8624       // optional .openxc.DynamicField value = 3;
8625       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8626       private com.google.protobuf.SingleFieldBuilder<
8627           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
8628       /**
8629        * <code>optional .openxc.DynamicField value = 3;</code>
8630        */
8631       public boolean hasValue() {
8632         return ((bitField0_ & 0x00000004) == 0x00000004);
8633       }
8634       /**
8635        * <code>optional .openxc.DynamicField value = 3;</code>
8636        */
8637       public com.openxc.BinaryMessages.DynamicField getValue() {
8638         if (valueBuilder_ == null) {
8639           return value_;
8640         } else {
8641           return valueBuilder_.getMessage();
8642         }
8643       }
8644       /**
8645        * <code>optional .openxc.DynamicField value = 3;</code>
8646        */
8647       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
8648         if (valueBuilder_ == null) {
8649           if (value == null) {
8650             throw new NullPointerException();
8651           }
8652           value_ = value;
8653           onChanged();
8654         } else {
8655           valueBuilder_.setMessage(value);
8656         }
8657         bitField0_ |= 0x00000004;
8658         return this;
8659       }
8660       /**
8661        * <code>optional .openxc.DynamicField value = 3;</code>
8662        */
8663       public Builder setValue(
8664           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
8665         if (valueBuilder_ == null) {
8666           value_ = builderForValue.build();
8667           onChanged();
8668         } else {
8669           valueBuilder_.setMessage(builderForValue.build());
8670         }
8671         bitField0_ |= 0x00000004;
8672         return this;
8673       }
8674       /**
8675        * <code>optional .openxc.DynamicField value = 3;</code>
8676        */
8677       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
8678         if (valueBuilder_ == null) {
8679           if (((bitField0_ & 0x00000004) == 0x00000004) &&
8680               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
8681             value_ =
8682               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
8683           } else {
8684             value_ = value;
8685           }
8686           onChanged();
8687         } else {
8688           valueBuilder_.mergeFrom(value);
8689         }
8690         bitField0_ |= 0x00000004;
8691         return this;
8692       }
8693       /**
8694        * <code>optional .openxc.DynamicField value = 3;</code>
8695        */
8696       public Builder clearValue() {
8697         if (valueBuilder_ == null) {
8698           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8699           onChanged();
8700         } else {
8701           valueBuilder_.clear();
8702         }
8703         bitField0_ = (bitField0_ & ~0x00000004);
8704         return this;
8705       }
8706       /**
8707        * <code>optional .openxc.DynamicField value = 3;</code>
8708        */
8709       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
8710         bitField0_ |= 0x00000004;
8711         onChanged();
8712         return getValueFieldBuilder().getBuilder();
8713       }
8714       /**
8715        * <code>optional .openxc.DynamicField value = 3;</code>
8716        */
8717       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
8718         if (valueBuilder_ != null) {
8719           return valueBuilder_.getMessageOrBuilder();
8720         } else {
8721           return value_;
8722         }
8723       }
8724       /**
8725        * <code>optional .openxc.DynamicField value = 3;</code>
8726        */
8727       private com.google.protobuf.SingleFieldBuilder<
8728           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
8729           getValueFieldBuilder() {
8730         if (valueBuilder_ == null) {
8731           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
8732               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
8733                   value_,
8734                   getParentForChildren(),
8735                   isClean());
8736           value_ = null;
8737         }
8738         return valueBuilder_;
8739       }
8740
8741       // optional .openxc.DynamicField event = 4;
8742       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8743       private com.google.protobuf.SingleFieldBuilder<
8744           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
8745       /**
8746        * <code>optional .openxc.DynamicField event = 4;</code>
8747        */
8748       public boolean hasEvent() {
8749         return ((bitField0_ & 0x00000008) == 0x00000008);
8750       }
8751       /**
8752        * <code>optional .openxc.DynamicField event = 4;</code>
8753        */
8754       public com.openxc.BinaryMessages.DynamicField getEvent() {
8755         if (eventBuilder_ == null) {
8756           return event_;
8757         } else {
8758           return eventBuilder_.getMessage();
8759         }
8760       }
8761       /**
8762        * <code>optional .openxc.DynamicField event = 4;</code>
8763        */
8764       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
8765         if (eventBuilder_ == null) {
8766           if (value == null) {
8767             throw new NullPointerException();
8768           }
8769           event_ = value;
8770           onChanged();
8771         } else {
8772           eventBuilder_.setMessage(value);
8773         }
8774         bitField0_ |= 0x00000008;
8775         return this;
8776       }
8777       /**
8778        * <code>optional .openxc.DynamicField event = 4;</code>
8779        */
8780       public Builder setEvent(
8781           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
8782         if (eventBuilder_ == null) {
8783           event_ = builderForValue.build();
8784           onChanged();
8785         } else {
8786           eventBuilder_.setMessage(builderForValue.build());
8787         }
8788         bitField0_ |= 0x00000008;
8789         return this;
8790       }
8791       /**
8792        * <code>optional .openxc.DynamicField event = 4;</code>
8793        */
8794       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
8795         if (eventBuilder_ == null) {
8796           if (((bitField0_ & 0x00000008) == 0x00000008) &&
8797               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
8798             event_ =
8799               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
8800           } else {
8801             event_ = value;
8802           }
8803           onChanged();
8804         } else {
8805           eventBuilder_.mergeFrom(value);
8806         }
8807         bitField0_ |= 0x00000008;
8808         return this;
8809       }
8810       /**
8811        * <code>optional .openxc.DynamicField event = 4;</code>
8812        */
8813       public Builder clearEvent() {
8814         if (eventBuilder_ == null) {
8815           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8816           onChanged();
8817         } else {
8818           eventBuilder_.clear();
8819         }
8820         bitField0_ = (bitField0_ & ~0x00000008);
8821         return this;
8822       }
8823       /**
8824        * <code>optional .openxc.DynamicField event = 4;</code>
8825        */
8826       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
8827         bitField0_ |= 0x00000008;
8828         onChanged();
8829         return getEventFieldBuilder().getBuilder();
8830       }
8831       /**
8832        * <code>optional .openxc.DynamicField event = 4;</code>
8833        */
8834       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
8835         if (eventBuilder_ != null) {
8836           return eventBuilder_.getMessageOrBuilder();
8837         } else {
8838           return event_;
8839         }
8840       }
8841       /**
8842        * <code>optional .openxc.DynamicField event = 4;</code>
8843        */
8844       private com.google.protobuf.SingleFieldBuilder<
8845           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
8846           getEventFieldBuilder() {
8847         if (eventBuilder_ == null) {
8848           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
8849               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
8850                   event_,
8851                   getParentForChildren(),
8852                   isClean());
8853           event_ = null;
8854         }
8855         return eventBuilder_;
8856       }
8857
8858       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
8859     }
8860
8861     static {
8862       defaultInstance = new TranslatedMessage(true);
8863       defaultInstance.initFields();
8864     }
8865
8866     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
8867   }
8868
8869   private static com.google.protobuf.Descriptors.Descriptor
8870     internal_static_openxc_VehicleMessage_descriptor;
8871   private static
8872     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8873       internal_static_openxc_VehicleMessage_fieldAccessorTable;
8874   private static com.google.protobuf.Descriptors.Descriptor
8875     internal_static_openxc_RawMessage_descriptor;
8876   private static
8877     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8878       internal_static_openxc_RawMessage_fieldAccessorTable;
8879   private static com.google.protobuf.Descriptors.Descriptor
8880     internal_static_openxc_ControlCommand_descriptor;
8881   private static
8882     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8883       internal_static_openxc_ControlCommand_fieldAccessorTable;
8884   private static com.google.protobuf.Descriptors.Descriptor
8885     internal_static_openxc_DiagnosticControlCommand_descriptor;
8886   private static
8887     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8888       internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable;
8889   private static com.google.protobuf.Descriptors.Descriptor
8890     internal_static_openxc_PassthroughModeControlCommand_descriptor;
8891   private static
8892     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8893       internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable;
8894   private static com.google.protobuf.Descriptors.Descriptor
8895     internal_static_openxc_CommandResponse_descriptor;
8896   private static
8897     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8898       internal_static_openxc_CommandResponse_fieldAccessorTable;
8899   private static com.google.protobuf.Descriptors.Descriptor
8900     internal_static_openxc_DiagnosticRequest_descriptor;
8901   private static
8902     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8903       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
8904   private static com.google.protobuf.Descriptors.Descriptor
8905     internal_static_openxc_DiagnosticResponse_descriptor;
8906   private static
8907     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8908       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
8909   private static com.google.protobuf.Descriptors.Descriptor
8910     internal_static_openxc_DynamicField_descriptor;
8911   private static
8912     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8913       internal_static_openxc_DynamicField_fieldAccessorTable;
8914   private static com.google.protobuf.Descriptors.Descriptor
8915     internal_static_openxc_TranslatedMessage_descriptor;
8916   private static
8917     com.google.protobuf.GeneratedMessage.FieldAccessorTable
8918       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
8919
8920   public static com.google.protobuf.Descriptors.FileDescriptor
8921       getDescriptor() {
8922     return descriptor;
8923   }
8924   private static com.google.protobuf.Descriptors.FileDescriptor
8925       descriptor;
8926   static {
8927     java.lang.String[] descriptorData = {
8928       "\n\014openxc.proto\022\006openxc\"\224\003\n\016VehicleMessag" +
8929       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
8930       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
8931       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
8932       "xc.TranslatedMessage\0227\n\023diagnostic_respo" +
8933       "nse\030\004 \001(\0132\032.openxc.DiagnosticResponse\022/\n" +
8934       "\017control_command\030\005 \001(\0132\026.openxc.ControlC" +
8935       "ommand\0221\n\020command_response\030\006 \001(\0132\027.openx" +
8936       "c.CommandResponse\"Z\n\004Type\022\007\n\003RAW\020\001\022\016\n\nTR" +
8937       "ANSLATED\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CONTROL_CO",
8938       "MMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\";\n\nRawMess" +
8939       "age\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004" +
8940       "data\030\003 \001(\014\"\207\002\n\016ControlCommand\022)\n\004type\030\001 " +
8941       "\001(\0162\033.openxc.ControlCommand.Type\022<\n\022diag" +
8942       "nostic_request\030\002 \001(\0132 .openxc.Diagnostic" +
8943       "ControlCommand\022G\n\030passthrough_mode_reque" +
8944       "st\030\003 \001(\0132%.openxc.PassthroughModeControl" +
8945       "Command\"C\n\004Type\022\013\n\007VERSION\020\001\022\r\n\tDEVICE_I" +
8946       "D\020\002\022\016\n\nDIAGNOSTIC\020\003\022\017\n\013PASSTHROUGH\020\004\"\236\001\n" +
8947       "\030DiagnosticControlCommand\022*\n\007request\030\001 \001",
8948       "(\0132\031.openxc.DiagnosticRequest\0227\n\006action\030" +
8949       "\002 \001(\0162\'.openxc.DiagnosticControlCommand." +
8950       "Action\"\035\n\006Action\022\007\n\003ADD\020\001\022\n\n\006CANCEL\020\002\"=\n" +
8951       "\035PassthroughModeControlCommand\022\013\n\003bus\030\001 " +
8952       "\001(\005\022\017\n\007enabled\030\002 \001(\010\"]\n\017CommandResponse\022" +
8953       ")\n\004type\030\001 \001(\0162\033.openxc.ControlCommand.Ty" +
8954       "pe\022\017\n\007message\030\002 \001(\t\022\016\n\006status\030\003 \001(\010\"\375\001\n\021" +
8955       "DiagnosticRequest\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessag" +
8956       "e_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n" +
8957       "\007payload\030\005 \001(\014\022\032\n\022multiple_responses\030\006 \001",
8958       "(\010\022\021\n\tfrequency\030\007 \001(\001\022\014\n\004name\030\010 \001(\t\022;\n\014d" +
8959       "ecoded_type\030\t \001(\0162%.openxc.DiagnosticReq" +
8960       "uest.DecodedType\"!\n\013DecodedType\022\010\n\004NONE\020" +
8961       "\001\022\010\n\004OBD2\020\002\"\241\001\n\022DiagnosticResponse\022\013\n\003bu" +
8962       "s\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(" +
8963       "\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005 \001(\010\022\036\n\026negat" +
8964       "ive_response_code\030\006 \001(\r\022\017\n\007payload\030\007 \001(\014" +
8965       "\022\r\n\005value\030\010 \001(\001\"\242\001\n\014DynamicField\022\'\n\004type" +
8966       "\030\001 \001(\0162\031.openxc.DynamicField.Type\022\024\n\014str" +
8967       "ing_value\030\002 \001(\t\022\025\n\rnumeric_value\030\003 \001(\001\022\025",
8968       "\n\rboolean_value\030\004 \001(\010\"%\n\004Type\022\n\n\006STRING\020" +
8969       "\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\"\367\001\n\021TranslatedMessa" +
8970       "ge\022,\n\004type\030\001 \001(\0162\036.openxc.TranslatedMess" +
8971       "age.Type\022\014\n\004name\030\002 \001(\t\022#\n\005value\030\003 \001(\0132\024." +
8972       "openxc.DynamicField\022#\n\005event\030\004 \001(\0132\024.ope" +
8973       "nxc.DynamicField\"\\\n\004Type\022\n\n\006STRING\020\001\022\007\n\003" +
8974       "NUM\020\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTED_STRING\020\004\022\017\n\013E" +
8975       "VENTED_NUM\020\005\022\020\n\014EVENTED_BOOL\020\006B\034\n\ncom.op" +
8976       "enxcB\016BinaryMessages"
8977     };
8978     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
8979       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
8980         public com.google.protobuf.ExtensionRegistry assignDescriptors(
8981             com.google.protobuf.Descriptors.FileDescriptor root) {
8982           descriptor = root;
8983           internal_static_openxc_VehicleMessage_descriptor =
8984             getDescriptor().getMessageTypes().get(0);
8985           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
8986             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
8987               internal_static_openxc_VehicleMessage_descriptor,
8988               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", });
8989           internal_static_openxc_RawMessage_descriptor =
8990             getDescriptor().getMessageTypes().get(1);
8991           internal_static_openxc_RawMessage_fieldAccessorTable = new
8992             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
8993               internal_static_openxc_RawMessage_descriptor,
8994               new java.lang.String[] { "Bus", "MessageId", "Data", });
8995           internal_static_openxc_ControlCommand_descriptor =
8996             getDescriptor().getMessageTypes().get(2);
8997           internal_static_openxc_ControlCommand_fieldAccessorTable = new
8998             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
8999               internal_static_openxc_ControlCommand_descriptor,
9000               new java.lang.String[] { "Type", "DiagnosticRequest", "PassthroughModeRequest", });
9001           internal_static_openxc_DiagnosticControlCommand_descriptor =
9002             getDescriptor().getMessageTypes().get(3);
9003           internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable = new
9004             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9005               internal_static_openxc_DiagnosticControlCommand_descriptor,
9006               new java.lang.String[] { "Request", "Action", });
9007           internal_static_openxc_PassthroughModeControlCommand_descriptor =
9008             getDescriptor().getMessageTypes().get(4);
9009           internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable = new
9010             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9011               internal_static_openxc_PassthroughModeControlCommand_descriptor,
9012               new java.lang.String[] { "Bus", "Enabled", });
9013           internal_static_openxc_CommandResponse_descriptor =
9014             getDescriptor().getMessageTypes().get(5);
9015           internal_static_openxc_CommandResponse_fieldAccessorTable = new
9016             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9017               internal_static_openxc_CommandResponse_descriptor,
9018               new java.lang.String[] { "Type", "Message", "Status", });
9019           internal_static_openxc_DiagnosticRequest_descriptor =
9020             getDescriptor().getMessageTypes().get(6);
9021           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
9022             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9023               internal_static_openxc_DiagnosticRequest_descriptor,
9024               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Frequency", "Name", "DecodedType", });
9025           internal_static_openxc_DiagnosticResponse_descriptor =
9026             getDescriptor().getMessageTypes().get(7);
9027           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
9028             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9029               internal_static_openxc_DiagnosticResponse_descriptor,
9030               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", });
9031           internal_static_openxc_DynamicField_descriptor =
9032             getDescriptor().getMessageTypes().get(8);
9033           internal_static_openxc_DynamicField_fieldAccessorTable = new
9034             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9035               internal_static_openxc_DynamicField_descriptor,
9036               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", });
9037           internal_static_openxc_TranslatedMessage_descriptor =
9038             getDescriptor().getMessageTypes().get(9);
9039           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
9040             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
9041               internal_static_openxc_TranslatedMessage_descriptor,
9042               new java.lang.String[] { "Type", "Name", "Value", "Event", });
9043           return null;
9044         }
9045       };
9046     com.google.protobuf.Descriptors.FileDescriptor
9047       .internalBuildGeneratedFileFrom(descriptorData,
9048         new com.google.protobuf.Descriptors.FileDescriptor[] {
9049         }, assigner);
9050   }
9051
9052   // @@protoc_insertion_point(outer_class_scope)
9053 }