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.DiagnosticRequest diagnostic_request = 2;
2060     /**
2061      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2062      */
2063     boolean hasDiagnosticRequest();
2064     /**
2065      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2066      */
2067     com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest();
2068     /**
2069      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2070      */
2071     com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder();
2072
2073     // optional .openxc.ControlCommand.Action action = 3;
2074     /**
2075      * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2076      */
2077     boolean hasAction();
2078     /**
2079      * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2080      */
2081     com.openxc.BinaryMessages.ControlCommand.Action getAction();
2082   }
2083   /**
2084    * Protobuf type {@code openxc.ControlCommand}
2085    */
2086   public static final class ControlCommand extends
2087       com.google.protobuf.GeneratedMessage
2088       implements ControlCommandOrBuilder {
2089     // Use ControlCommand.newBuilder() to construct.
2090     private ControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2091       super(builder);
2092       this.unknownFields = builder.getUnknownFields();
2093     }
2094     private ControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2095
2096     private static final ControlCommand defaultInstance;
2097     public static ControlCommand getDefaultInstance() {
2098       return defaultInstance;
2099     }
2100
2101     public ControlCommand getDefaultInstanceForType() {
2102       return defaultInstance;
2103     }
2104
2105     private final com.google.protobuf.UnknownFieldSet unknownFields;
2106     @java.lang.Override
2107     public final com.google.protobuf.UnknownFieldSet
2108         getUnknownFields() {
2109       return this.unknownFields;
2110     }
2111     private ControlCommand(
2112         com.google.protobuf.CodedInputStream input,
2113         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2114         throws com.google.protobuf.InvalidProtocolBufferException {
2115       initFields();
2116       int mutable_bitField0_ = 0;
2117       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2118           com.google.protobuf.UnknownFieldSet.newBuilder();
2119       try {
2120         boolean done = false;
2121         while (!done) {
2122           int tag = input.readTag();
2123           switch (tag) {
2124             case 0:
2125               done = true;
2126               break;
2127             default: {
2128               if (!parseUnknownField(input, unknownFields,
2129                                      extensionRegistry, tag)) {
2130                 done = true;
2131               }
2132               break;
2133             }
2134             case 8: {
2135               int rawValue = input.readEnum();
2136               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2137               if (value == null) {
2138                 unknownFields.mergeVarintField(1, rawValue);
2139               } else {
2140                 bitField0_ |= 0x00000001;
2141                 type_ = value;
2142               }
2143               break;
2144             }
2145             case 18: {
2146               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = null;
2147               if (((bitField0_ & 0x00000002) == 0x00000002)) {
2148                 subBuilder = diagnosticRequest_.toBuilder();
2149               }
2150               diagnosticRequest_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticRequest.PARSER, extensionRegistry);
2151               if (subBuilder != null) {
2152                 subBuilder.mergeFrom(diagnosticRequest_);
2153                 diagnosticRequest_ = subBuilder.buildPartial();
2154               }
2155               bitField0_ |= 0x00000002;
2156               break;
2157             }
2158             case 24: {
2159               int rawValue = input.readEnum();
2160               com.openxc.BinaryMessages.ControlCommand.Action value = com.openxc.BinaryMessages.ControlCommand.Action.valueOf(rawValue);
2161               if (value == null) {
2162                 unknownFields.mergeVarintField(3, rawValue);
2163               } else {
2164                 bitField0_ |= 0x00000004;
2165                 action_ = value;
2166               }
2167               break;
2168             }
2169           }
2170         }
2171       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2172         throw e.setUnfinishedMessage(this);
2173       } catch (java.io.IOException e) {
2174         throw new com.google.protobuf.InvalidProtocolBufferException(
2175             e.getMessage()).setUnfinishedMessage(this);
2176       } finally {
2177         this.unknownFields = unknownFields.build();
2178         makeExtensionsImmutable();
2179       }
2180     }
2181     public static final com.google.protobuf.Descriptors.Descriptor
2182         getDescriptor() {
2183       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2184     }
2185
2186     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2187         internalGetFieldAccessorTable() {
2188       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2189           .ensureFieldAccessorsInitialized(
2190               com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2191     }
2192
2193     public static com.google.protobuf.Parser<ControlCommand> PARSER =
2194         new com.google.protobuf.AbstractParser<ControlCommand>() {
2195       public ControlCommand parsePartialFrom(
2196           com.google.protobuf.CodedInputStream input,
2197           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2198           throws com.google.protobuf.InvalidProtocolBufferException {
2199         return new ControlCommand(input, extensionRegistry);
2200       }
2201     };
2202
2203     @java.lang.Override
2204     public com.google.protobuf.Parser<ControlCommand> getParserForType() {
2205       return PARSER;
2206     }
2207
2208     /**
2209      * Protobuf enum {@code openxc.ControlCommand.Type}
2210      */
2211     public enum Type
2212         implements com.google.protobuf.ProtocolMessageEnum {
2213       /**
2214        * <code>VERSION = 1;</code>
2215        */
2216       VERSION(0, 1),
2217       /**
2218        * <code>DEVICE_ID = 2;</code>
2219        */
2220       DEVICE_ID(1, 2),
2221       /**
2222        * <code>DIAGNOSTIC = 3;</code>
2223        */
2224       DIAGNOSTIC(2, 3),
2225       ;
2226
2227       /**
2228        * <code>VERSION = 1;</code>
2229        */
2230       public static final int VERSION_VALUE = 1;
2231       /**
2232        * <code>DEVICE_ID = 2;</code>
2233        */
2234       public static final int DEVICE_ID_VALUE = 2;
2235       /**
2236        * <code>DIAGNOSTIC = 3;</code>
2237        */
2238       public static final int DIAGNOSTIC_VALUE = 3;
2239
2240
2241       public final int getNumber() { return value; }
2242
2243       public static Type valueOf(int value) {
2244         switch (value) {
2245           case 1: return VERSION;
2246           case 2: return DEVICE_ID;
2247           case 3: return DIAGNOSTIC;
2248           default: return null;
2249         }
2250       }
2251
2252       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2253           internalGetValueMap() {
2254         return internalValueMap;
2255       }
2256       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2257           internalValueMap =
2258             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2259               public Type findValueByNumber(int number) {
2260                 return Type.valueOf(number);
2261               }
2262             };
2263
2264       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2265           getValueDescriptor() {
2266         return getDescriptor().getValues().get(index);
2267       }
2268       public final com.google.protobuf.Descriptors.EnumDescriptor
2269           getDescriptorForType() {
2270         return getDescriptor();
2271       }
2272       public static final com.google.protobuf.Descriptors.EnumDescriptor
2273           getDescriptor() {
2274         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
2275       }
2276
2277       private static final Type[] VALUES = values();
2278
2279       public static Type valueOf(
2280           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2281         if (desc.getType() != getDescriptor()) {
2282           throw new java.lang.IllegalArgumentException(
2283             "EnumValueDescriptor is not for this type.");
2284         }
2285         return VALUES[desc.getIndex()];
2286       }
2287
2288       private final int index;
2289       private final int value;
2290
2291       private Type(int index, int value) {
2292         this.index = index;
2293         this.value = value;
2294       }
2295
2296       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
2297     }
2298
2299     /**
2300      * Protobuf enum {@code openxc.ControlCommand.Action}
2301      */
2302     public enum Action
2303         implements com.google.protobuf.ProtocolMessageEnum {
2304       /**
2305        * <code>ADD = 1;</code>
2306        */
2307       ADD(0, 1),
2308       /**
2309        * <code>CANCEL = 2;</code>
2310        */
2311       CANCEL(1, 2),
2312       ;
2313
2314       /**
2315        * <code>ADD = 1;</code>
2316        */
2317       public static final int ADD_VALUE = 1;
2318       /**
2319        * <code>CANCEL = 2;</code>
2320        */
2321       public static final int CANCEL_VALUE = 2;
2322
2323
2324       public final int getNumber() { return value; }
2325
2326       public static Action valueOf(int value) {
2327         switch (value) {
2328           case 1: return ADD;
2329           case 2: return CANCEL;
2330           default: return null;
2331         }
2332       }
2333
2334       public static com.google.protobuf.Internal.EnumLiteMap<Action>
2335           internalGetValueMap() {
2336         return internalValueMap;
2337       }
2338       private static com.google.protobuf.Internal.EnumLiteMap<Action>
2339           internalValueMap =
2340             new com.google.protobuf.Internal.EnumLiteMap<Action>() {
2341               public Action findValueByNumber(int number) {
2342                 return Action.valueOf(number);
2343               }
2344             };
2345
2346       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2347           getValueDescriptor() {
2348         return getDescriptor().getValues().get(index);
2349       }
2350       public final com.google.protobuf.Descriptors.EnumDescriptor
2351           getDescriptorForType() {
2352         return getDescriptor();
2353       }
2354       public static final com.google.protobuf.Descriptors.EnumDescriptor
2355           getDescriptor() {
2356         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(1);
2357       }
2358
2359       private static final Action[] VALUES = values();
2360
2361       public static Action valueOf(
2362           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2363         if (desc.getType() != getDescriptor()) {
2364           throw new java.lang.IllegalArgumentException(
2365             "EnumValueDescriptor is not for this type.");
2366         }
2367         return VALUES[desc.getIndex()];
2368       }
2369
2370       private final int index;
2371       private final int value;
2372
2373       private Action(int index, int value) {
2374         this.index = index;
2375         this.value = value;
2376       }
2377
2378       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Action)
2379     }
2380
2381     private int bitField0_;
2382     // optional .openxc.ControlCommand.Type type = 1;
2383     public static final int TYPE_FIELD_NUMBER = 1;
2384     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2385     /**
2386      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2387      */
2388     public boolean hasType() {
2389       return ((bitField0_ & 0x00000001) == 0x00000001);
2390     }
2391     /**
2392      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2393      */
2394     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2395       return type_;
2396     }
2397
2398     // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2399     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
2400     private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_;
2401     /**
2402      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2403      */
2404     public boolean hasDiagnosticRequest() {
2405       return ((bitField0_ & 0x00000002) == 0x00000002);
2406     }
2407     /**
2408      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2409      */
2410     public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2411       return diagnosticRequest_;
2412     }
2413     /**
2414      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2415      */
2416     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2417       return diagnosticRequest_;
2418     }
2419
2420     // optional .openxc.ControlCommand.Action action = 3;
2421     public static final int ACTION_FIELD_NUMBER = 3;
2422     private com.openxc.BinaryMessages.ControlCommand.Action action_;
2423     /**
2424      * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2425      */
2426     public boolean hasAction() {
2427       return ((bitField0_ & 0x00000004) == 0x00000004);
2428     }
2429     /**
2430      * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2431      */
2432     public com.openxc.BinaryMessages.ControlCommand.Action getAction() {
2433       return action_;
2434     }
2435
2436     private void initFields() {
2437       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2438       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2439       action_ = com.openxc.BinaryMessages.ControlCommand.Action.ADD;
2440     }
2441     private byte memoizedIsInitialized = -1;
2442     public final boolean isInitialized() {
2443       byte isInitialized = memoizedIsInitialized;
2444       if (isInitialized != -1) return isInitialized == 1;
2445
2446       memoizedIsInitialized = 1;
2447       return true;
2448     }
2449
2450     public void writeTo(com.google.protobuf.CodedOutputStream output)
2451                         throws java.io.IOException {
2452       getSerializedSize();
2453       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2454         output.writeEnum(1, type_.getNumber());
2455       }
2456       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2457         output.writeMessage(2, diagnosticRequest_);
2458       }
2459       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2460         output.writeEnum(3, action_.getNumber());
2461       }
2462       getUnknownFields().writeTo(output);
2463     }
2464
2465     private int memoizedSerializedSize = -1;
2466     public int getSerializedSize() {
2467       int size = memoizedSerializedSize;
2468       if (size != -1) return size;
2469
2470       size = 0;
2471       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2472         size += com.google.protobuf.CodedOutputStream
2473           .computeEnumSize(1, type_.getNumber());
2474       }
2475       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2476         size += com.google.protobuf.CodedOutputStream
2477           .computeMessageSize(2, diagnosticRequest_);
2478       }
2479       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2480         size += com.google.protobuf.CodedOutputStream
2481           .computeEnumSize(3, action_.getNumber());
2482       }
2483       size += getUnknownFields().getSerializedSize();
2484       memoizedSerializedSize = size;
2485       return size;
2486     }
2487
2488     private static final long serialVersionUID = 0L;
2489     @java.lang.Override
2490     protected java.lang.Object writeReplace()
2491         throws java.io.ObjectStreamException {
2492       return super.writeReplace();
2493     }
2494
2495     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2496         com.google.protobuf.ByteString data)
2497         throws com.google.protobuf.InvalidProtocolBufferException {
2498       return PARSER.parseFrom(data);
2499     }
2500     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2501         com.google.protobuf.ByteString data,
2502         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2503         throws com.google.protobuf.InvalidProtocolBufferException {
2504       return PARSER.parseFrom(data, extensionRegistry);
2505     }
2506     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
2507         throws com.google.protobuf.InvalidProtocolBufferException {
2508       return PARSER.parseFrom(data);
2509     }
2510     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2511         byte[] data,
2512         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2513         throws com.google.protobuf.InvalidProtocolBufferException {
2514       return PARSER.parseFrom(data, extensionRegistry);
2515     }
2516     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
2517         throws java.io.IOException {
2518       return PARSER.parseFrom(input);
2519     }
2520     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2521         java.io.InputStream input,
2522         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2523         throws java.io.IOException {
2524       return PARSER.parseFrom(input, extensionRegistry);
2525     }
2526     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
2527         throws java.io.IOException {
2528       return PARSER.parseDelimitedFrom(input);
2529     }
2530     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
2531         java.io.InputStream input,
2532         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2533         throws java.io.IOException {
2534       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2535     }
2536     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2537         com.google.protobuf.CodedInputStream input)
2538         throws java.io.IOException {
2539       return PARSER.parseFrom(input);
2540     }
2541     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2542         com.google.protobuf.CodedInputStream input,
2543         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2544         throws java.io.IOException {
2545       return PARSER.parseFrom(input, extensionRegistry);
2546     }
2547
2548     public static Builder newBuilder() { return Builder.create(); }
2549     public Builder newBuilderForType() { return newBuilder(); }
2550     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
2551       return newBuilder().mergeFrom(prototype);
2552     }
2553     public Builder toBuilder() { return newBuilder(this); }
2554
2555     @java.lang.Override
2556     protected Builder newBuilderForType(
2557         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2558       Builder builder = new Builder(parent);
2559       return builder;
2560     }
2561     /**
2562      * Protobuf type {@code openxc.ControlCommand}
2563      */
2564     public static final class Builder extends
2565         com.google.protobuf.GeneratedMessage.Builder<Builder>
2566        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
2567       public static final com.google.protobuf.Descriptors.Descriptor
2568           getDescriptor() {
2569         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2570       }
2571
2572       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2573           internalGetFieldAccessorTable() {
2574         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2575             .ensureFieldAccessorsInitialized(
2576                 com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2577       }
2578
2579       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
2580       private Builder() {
2581         maybeForceBuilderInitialization();
2582       }
2583
2584       private Builder(
2585           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2586         super(parent);
2587         maybeForceBuilderInitialization();
2588       }
2589       private void maybeForceBuilderInitialization() {
2590         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2591           getDiagnosticRequestFieldBuilder();
2592         }
2593       }
2594       private static Builder create() {
2595         return new Builder();
2596       }
2597
2598       public Builder clear() {
2599         super.clear();
2600         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2601         bitField0_ = (bitField0_ & ~0x00000001);
2602         if (diagnosticRequestBuilder_ == null) {
2603           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2604         } else {
2605           diagnosticRequestBuilder_.clear();
2606         }
2607         bitField0_ = (bitField0_ & ~0x00000002);
2608         action_ = com.openxc.BinaryMessages.ControlCommand.Action.ADD;
2609         bitField0_ = (bitField0_ & ~0x00000004);
2610         return this;
2611       }
2612
2613       public Builder clone() {
2614         return create().mergeFrom(buildPartial());
2615       }
2616
2617       public com.google.protobuf.Descriptors.Descriptor
2618           getDescriptorForType() {
2619         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2620       }
2621
2622       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
2623         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
2624       }
2625
2626       public com.openxc.BinaryMessages.ControlCommand build() {
2627         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2628         if (!result.isInitialized()) {
2629           throw newUninitializedMessageException(result);
2630         }
2631         return result;
2632       }
2633
2634       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
2635         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
2636         int from_bitField0_ = bitField0_;
2637         int to_bitField0_ = 0;
2638         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2639           to_bitField0_ |= 0x00000001;
2640         }
2641         result.type_ = type_;
2642         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2643           to_bitField0_ |= 0x00000002;
2644         }
2645         if (diagnosticRequestBuilder_ == null) {
2646           result.diagnosticRequest_ = diagnosticRequest_;
2647         } else {
2648           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
2649         }
2650         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2651           to_bitField0_ |= 0x00000004;
2652         }
2653         result.action_ = action_;
2654         result.bitField0_ = to_bitField0_;
2655         onBuilt();
2656         return result;
2657       }
2658
2659       public Builder mergeFrom(com.google.protobuf.Message other) {
2660         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
2661           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
2662         } else {
2663           super.mergeFrom(other);
2664           return this;
2665         }
2666       }
2667
2668       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
2669         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
2670         if (other.hasType()) {
2671           setType(other.getType());
2672         }
2673         if (other.hasDiagnosticRequest()) {
2674           mergeDiagnosticRequest(other.getDiagnosticRequest());
2675         }
2676         if (other.hasAction()) {
2677           setAction(other.getAction());
2678         }
2679         this.mergeUnknownFields(other.getUnknownFields());
2680         return this;
2681       }
2682
2683       public final boolean isInitialized() {
2684         return true;
2685       }
2686
2687       public Builder mergeFrom(
2688           com.google.protobuf.CodedInputStream input,
2689           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2690           throws java.io.IOException {
2691         com.openxc.BinaryMessages.ControlCommand parsedMessage = null;
2692         try {
2693           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2694         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2695           parsedMessage = (com.openxc.BinaryMessages.ControlCommand) e.getUnfinishedMessage();
2696           throw e;
2697         } finally {
2698           if (parsedMessage != null) {
2699             mergeFrom(parsedMessage);
2700           }
2701         }
2702         return this;
2703       }
2704       private int bitField0_;
2705
2706       // optional .openxc.ControlCommand.Type type = 1;
2707       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2708       /**
2709        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2710        */
2711       public boolean hasType() {
2712         return ((bitField0_ & 0x00000001) == 0x00000001);
2713       }
2714       /**
2715        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2716        */
2717       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2718         return type_;
2719       }
2720       /**
2721        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2722        */
2723       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
2724         if (value == null) {
2725           throw new NullPointerException();
2726         }
2727         bitField0_ |= 0x00000001;
2728         type_ = value;
2729         onChanged();
2730         return this;
2731       }
2732       /**
2733        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2734        */
2735       public Builder clearType() {
2736         bitField0_ = (bitField0_ & ~0x00000001);
2737         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2738         onChanged();
2739         return this;
2740       }
2741
2742       // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2743       private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2744       private com.google.protobuf.SingleFieldBuilder<
2745           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> diagnosticRequestBuilder_;
2746       /**
2747        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2748        */
2749       public boolean hasDiagnosticRequest() {
2750         return ((bitField0_ & 0x00000002) == 0x00000002);
2751       }
2752       /**
2753        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2754        */
2755       public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2756         if (diagnosticRequestBuilder_ == null) {
2757           return diagnosticRequest_;
2758         } else {
2759           return diagnosticRequestBuilder_.getMessage();
2760         }
2761       }
2762       /**
2763        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2764        */
2765       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2766         if (diagnosticRequestBuilder_ == null) {
2767           if (value == null) {
2768             throw new NullPointerException();
2769           }
2770           diagnosticRequest_ = value;
2771           onChanged();
2772         } else {
2773           diagnosticRequestBuilder_.setMessage(value);
2774         }
2775         bitField0_ |= 0x00000002;
2776         return this;
2777       }
2778       /**
2779        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2780        */
2781       public Builder setDiagnosticRequest(
2782           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
2783         if (diagnosticRequestBuilder_ == null) {
2784           diagnosticRequest_ = builderForValue.build();
2785           onChanged();
2786         } else {
2787           diagnosticRequestBuilder_.setMessage(builderForValue.build());
2788         }
2789         bitField0_ |= 0x00000002;
2790         return this;
2791       }
2792       /**
2793        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2794        */
2795       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2796         if (diagnosticRequestBuilder_ == null) {
2797           if (((bitField0_ & 0x00000002) == 0x00000002) &&
2798               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
2799             diagnosticRequest_ =
2800               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
2801           } else {
2802             diagnosticRequest_ = value;
2803           }
2804           onChanged();
2805         } else {
2806           diagnosticRequestBuilder_.mergeFrom(value);
2807         }
2808         bitField0_ |= 0x00000002;
2809         return this;
2810       }
2811       /**
2812        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2813        */
2814       public Builder clearDiagnosticRequest() {
2815         if (diagnosticRequestBuilder_ == null) {
2816           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2817           onChanged();
2818         } else {
2819           diagnosticRequestBuilder_.clear();
2820         }
2821         bitField0_ = (bitField0_ & ~0x00000002);
2822         return this;
2823       }
2824       /**
2825        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2826        */
2827       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getDiagnosticRequestBuilder() {
2828         bitField0_ |= 0x00000002;
2829         onChanged();
2830         return getDiagnosticRequestFieldBuilder().getBuilder();
2831       }
2832       /**
2833        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2834        */
2835       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2836         if (diagnosticRequestBuilder_ != null) {
2837           return diagnosticRequestBuilder_.getMessageOrBuilder();
2838         } else {
2839           return diagnosticRequest_;
2840         }
2841       }
2842       /**
2843        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2844        */
2845       private com.google.protobuf.SingleFieldBuilder<
2846           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>
2847           getDiagnosticRequestFieldBuilder() {
2848         if (diagnosticRequestBuilder_ == null) {
2849           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2850               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
2851                   diagnosticRequest_,
2852                   getParentForChildren(),
2853                   isClean());
2854           diagnosticRequest_ = null;
2855         }
2856         return diagnosticRequestBuilder_;
2857       }
2858
2859       // optional .openxc.ControlCommand.Action action = 3;
2860       private com.openxc.BinaryMessages.ControlCommand.Action action_ = com.openxc.BinaryMessages.ControlCommand.Action.ADD;
2861       /**
2862        * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2863        */
2864       public boolean hasAction() {
2865         return ((bitField0_ & 0x00000004) == 0x00000004);
2866       }
2867       /**
2868        * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2869        */
2870       public com.openxc.BinaryMessages.ControlCommand.Action getAction() {
2871         return action_;
2872       }
2873       /**
2874        * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2875        */
2876       public Builder setAction(com.openxc.BinaryMessages.ControlCommand.Action value) {
2877         if (value == null) {
2878           throw new NullPointerException();
2879         }
2880         bitField0_ |= 0x00000004;
2881         action_ = value;
2882         onChanged();
2883         return this;
2884       }
2885       /**
2886        * <code>optional .openxc.ControlCommand.Action action = 3;</code>
2887        */
2888       public Builder clearAction() {
2889         bitField0_ = (bitField0_ & ~0x00000004);
2890         action_ = com.openxc.BinaryMessages.ControlCommand.Action.ADD;
2891         onChanged();
2892         return this;
2893       }
2894
2895       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
2896     }
2897
2898     static {
2899       defaultInstance = new ControlCommand(true);
2900       defaultInstance.initFields();
2901     }
2902
2903     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
2904   }
2905
2906   public interface CommandResponseOrBuilder
2907       extends com.google.protobuf.MessageOrBuilder {
2908
2909     // optional .openxc.ControlCommand.Type type = 1;
2910     /**
2911      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2912      */
2913     boolean hasType();
2914     /**
2915      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2916      */
2917     com.openxc.BinaryMessages.ControlCommand.Type getType();
2918
2919     // optional string message = 2;
2920     /**
2921      * <code>optional string message = 2;</code>
2922      */
2923     boolean hasMessage();
2924     /**
2925      * <code>optional string message = 2;</code>
2926      */
2927     java.lang.String getMessage();
2928     /**
2929      * <code>optional string message = 2;</code>
2930      */
2931     com.google.protobuf.ByteString
2932         getMessageBytes();
2933
2934     // optional bool status = 3;
2935     /**
2936      * <code>optional bool status = 3;</code>
2937      */
2938     boolean hasStatus();
2939     /**
2940      * <code>optional bool status = 3;</code>
2941      */
2942     boolean getStatus();
2943   }
2944   /**
2945    * Protobuf type {@code openxc.CommandResponse}
2946    */
2947   public static final class CommandResponse extends
2948       com.google.protobuf.GeneratedMessage
2949       implements CommandResponseOrBuilder {
2950     // Use CommandResponse.newBuilder() to construct.
2951     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2952       super(builder);
2953       this.unknownFields = builder.getUnknownFields();
2954     }
2955     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2956
2957     private static final CommandResponse defaultInstance;
2958     public static CommandResponse getDefaultInstance() {
2959       return defaultInstance;
2960     }
2961
2962     public CommandResponse getDefaultInstanceForType() {
2963       return defaultInstance;
2964     }
2965
2966     private final com.google.protobuf.UnknownFieldSet unknownFields;
2967     @java.lang.Override
2968     public final com.google.protobuf.UnknownFieldSet
2969         getUnknownFields() {
2970       return this.unknownFields;
2971     }
2972     private CommandResponse(
2973         com.google.protobuf.CodedInputStream input,
2974         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2975         throws com.google.protobuf.InvalidProtocolBufferException {
2976       initFields();
2977       int mutable_bitField0_ = 0;
2978       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2979           com.google.protobuf.UnknownFieldSet.newBuilder();
2980       try {
2981         boolean done = false;
2982         while (!done) {
2983           int tag = input.readTag();
2984           switch (tag) {
2985             case 0:
2986               done = true;
2987               break;
2988             default: {
2989               if (!parseUnknownField(input, unknownFields,
2990                                      extensionRegistry, tag)) {
2991                 done = true;
2992               }
2993               break;
2994             }
2995             case 8: {
2996               int rawValue = input.readEnum();
2997               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2998               if (value == null) {
2999                 unknownFields.mergeVarintField(1, rawValue);
3000               } else {
3001                 bitField0_ |= 0x00000001;
3002                 type_ = value;
3003               }
3004               break;
3005             }
3006             case 18: {
3007               bitField0_ |= 0x00000002;
3008               message_ = input.readBytes();
3009               break;
3010             }
3011             case 24: {
3012               bitField0_ |= 0x00000004;
3013               status_ = input.readBool();
3014               break;
3015             }
3016           }
3017         }
3018       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3019         throw e.setUnfinishedMessage(this);
3020       } catch (java.io.IOException e) {
3021         throw new com.google.protobuf.InvalidProtocolBufferException(
3022             e.getMessage()).setUnfinishedMessage(this);
3023       } finally {
3024         this.unknownFields = unknownFields.build();
3025         makeExtensionsImmutable();
3026       }
3027     }
3028     public static final com.google.protobuf.Descriptors.Descriptor
3029         getDescriptor() {
3030       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3031     }
3032
3033     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3034         internalGetFieldAccessorTable() {
3035       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
3036           .ensureFieldAccessorsInitialized(
3037               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
3038     }
3039
3040     public static com.google.protobuf.Parser<CommandResponse> PARSER =
3041         new com.google.protobuf.AbstractParser<CommandResponse>() {
3042       public CommandResponse parsePartialFrom(
3043           com.google.protobuf.CodedInputStream input,
3044           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3045           throws com.google.protobuf.InvalidProtocolBufferException {
3046         return new CommandResponse(input, extensionRegistry);
3047       }
3048     };
3049
3050     @java.lang.Override
3051     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
3052       return PARSER;
3053     }
3054
3055     private int bitField0_;
3056     // optional .openxc.ControlCommand.Type type = 1;
3057     public static final int TYPE_FIELD_NUMBER = 1;
3058     private com.openxc.BinaryMessages.ControlCommand.Type type_;
3059     /**
3060      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3061      */
3062     public boolean hasType() {
3063       return ((bitField0_ & 0x00000001) == 0x00000001);
3064     }
3065     /**
3066      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3067      */
3068     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
3069       return type_;
3070     }
3071
3072     // optional string message = 2;
3073     public static final int MESSAGE_FIELD_NUMBER = 2;
3074     private java.lang.Object message_;
3075     /**
3076      * <code>optional string message = 2;</code>
3077      */
3078     public boolean hasMessage() {
3079       return ((bitField0_ & 0x00000002) == 0x00000002);
3080     }
3081     /**
3082      * <code>optional string message = 2;</code>
3083      */
3084     public java.lang.String getMessage() {
3085       java.lang.Object ref = message_;
3086       if (ref instanceof java.lang.String) {
3087         return (java.lang.String) ref;
3088       } else {
3089         com.google.protobuf.ByteString bs =
3090             (com.google.protobuf.ByteString) ref;
3091         java.lang.String s = bs.toStringUtf8();
3092         if (bs.isValidUtf8()) {
3093           message_ = s;
3094         }
3095         return s;
3096       }
3097     }
3098     /**
3099      * <code>optional string message = 2;</code>
3100      */
3101     public com.google.protobuf.ByteString
3102         getMessageBytes() {
3103       java.lang.Object ref = message_;
3104       if (ref instanceof java.lang.String) {
3105         com.google.protobuf.ByteString b =
3106             com.google.protobuf.ByteString.copyFromUtf8(
3107                 (java.lang.String) ref);
3108         message_ = b;
3109         return b;
3110       } else {
3111         return (com.google.protobuf.ByteString) ref;
3112       }
3113     }
3114
3115     // optional bool status = 3;
3116     public static final int STATUS_FIELD_NUMBER = 3;
3117     private boolean status_;
3118     /**
3119      * <code>optional bool status = 3;</code>
3120      */
3121     public boolean hasStatus() {
3122       return ((bitField0_ & 0x00000004) == 0x00000004);
3123     }
3124     /**
3125      * <code>optional bool status = 3;</code>
3126      */
3127     public boolean getStatus() {
3128       return status_;
3129     }
3130
3131     private void initFields() {
3132       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3133       message_ = "";
3134       status_ = false;
3135     }
3136     private byte memoizedIsInitialized = -1;
3137     public final boolean isInitialized() {
3138       byte isInitialized = memoizedIsInitialized;
3139       if (isInitialized != -1) return isInitialized == 1;
3140
3141       memoizedIsInitialized = 1;
3142       return true;
3143     }
3144
3145     public void writeTo(com.google.protobuf.CodedOutputStream output)
3146                         throws java.io.IOException {
3147       getSerializedSize();
3148       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3149         output.writeEnum(1, type_.getNumber());
3150       }
3151       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3152         output.writeBytes(2, getMessageBytes());
3153       }
3154       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3155         output.writeBool(3, status_);
3156       }
3157       getUnknownFields().writeTo(output);
3158     }
3159
3160     private int memoizedSerializedSize = -1;
3161     public int getSerializedSize() {
3162       int size = memoizedSerializedSize;
3163       if (size != -1) return size;
3164
3165       size = 0;
3166       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3167         size += com.google.protobuf.CodedOutputStream
3168           .computeEnumSize(1, type_.getNumber());
3169       }
3170       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3171         size += com.google.protobuf.CodedOutputStream
3172           .computeBytesSize(2, getMessageBytes());
3173       }
3174       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3175         size += com.google.protobuf.CodedOutputStream
3176           .computeBoolSize(3, status_);
3177       }
3178       size += getUnknownFields().getSerializedSize();
3179       memoizedSerializedSize = size;
3180       return size;
3181     }
3182
3183     private static final long serialVersionUID = 0L;
3184     @java.lang.Override
3185     protected java.lang.Object writeReplace()
3186         throws java.io.ObjectStreamException {
3187       return super.writeReplace();
3188     }
3189
3190     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3191         com.google.protobuf.ByteString data)
3192         throws com.google.protobuf.InvalidProtocolBufferException {
3193       return PARSER.parseFrom(data);
3194     }
3195     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3196         com.google.protobuf.ByteString data,
3197         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3198         throws com.google.protobuf.InvalidProtocolBufferException {
3199       return PARSER.parseFrom(data, extensionRegistry);
3200     }
3201     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
3202         throws com.google.protobuf.InvalidProtocolBufferException {
3203       return PARSER.parseFrom(data);
3204     }
3205     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3206         byte[] data,
3207         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3208         throws com.google.protobuf.InvalidProtocolBufferException {
3209       return PARSER.parseFrom(data, extensionRegistry);
3210     }
3211     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
3212         throws java.io.IOException {
3213       return PARSER.parseFrom(input);
3214     }
3215     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3216         java.io.InputStream input,
3217         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3218         throws java.io.IOException {
3219       return PARSER.parseFrom(input, extensionRegistry);
3220     }
3221     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
3222         throws java.io.IOException {
3223       return PARSER.parseDelimitedFrom(input);
3224     }
3225     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
3226         java.io.InputStream input,
3227         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3228         throws java.io.IOException {
3229       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3230     }
3231     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3232         com.google.protobuf.CodedInputStream input)
3233         throws java.io.IOException {
3234       return PARSER.parseFrom(input);
3235     }
3236     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3237         com.google.protobuf.CodedInputStream input,
3238         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3239         throws java.io.IOException {
3240       return PARSER.parseFrom(input, extensionRegistry);
3241     }
3242
3243     public static Builder newBuilder() { return Builder.create(); }
3244     public Builder newBuilderForType() { return newBuilder(); }
3245     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
3246       return newBuilder().mergeFrom(prototype);
3247     }
3248     public Builder toBuilder() { return newBuilder(this); }
3249
3250     @java.lang.Override
3251     protected Builder newBuilderForType(
3252         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3253       Builder builder = new Builder(parent);
3254       return builder;
3255     }
3256     /**
3257      * Protobuf type {@code openxc.CommandResponse}
3258      */
3259     public static final class Builder extends
3260         com.google.protobuf.GeneratedMessage.Builder<Builder>
3261        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
3262       public static final com.google.protobuf.Descriptors.Descriptor
3263           getDescriptor() {
3264         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3265       }
3266
3267       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3268           internalGetFieldAccessorTable() {
3269         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
3270             .ensureFieldAccessorsInitialized(
3271                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
3272       }
3273
3274       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
3275       private Builder() {
3276         maybeForceBuilderInitialization();
3277       }
3278
3279       private Builder(
3280           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3281         super(parent);
3282         maybeForceBuilderInitialization();
3283       }
3284       private void maybeForceBuilderInitialization() {
3285         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3286         }
3287       }
3288       private static Builder create() {
3289         return new Builder();
3290       }
3291
3292       public Builder clear() {
3293         super.clear();
3294         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3295         bitField0_ = (bitField0_ & ~0x00000001);
3296         message_ = "";
3297         bitField0_ = (bitField0_ & ~0x00000002);
3298         status_ = false;
3299         bitField0_ = (bitField0_ & ~0x00000004);
3300         return this;
3301       }
3302
3303       public Builder clone() {
3304         return create().mergeFrom(buildPartial());
3305       }
3306
3307       public com.google.protobuf.Descriptors.Descriptor
3308           getDescriptorForType() {
3309         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3310       }
3311
3312       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
3313         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
3314       }
3315
3316       public com.openxc.BinaryMessages.CommandResponse build() {
3317         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
3318         if (!result.isInitialized()) {
3319           throw newUninitializedMessageException(result);
3320         }
3321         return result;
3322       }
3323
3324       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
3325         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
3326         int from_bitField0_ = bitField0_;
3327         int to_bitField0_ = 0;
3328         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3329           to_bitField0_ |= 0x00000001;
3330         }
3331         result.type_ = type_;
3332         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3333           to_bitField0_ |= 0x00000002;
3334         }
3335         result.message_ = message_;
3336         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
3337           to_bitField0_ |= 0x00000004;
3338         }
3339         result.status_ = status_;
3340         result.bitField0_ = to_bitField0_;
3341         onBuilt();
3342         return result;
3343       }
3344
3345       public Builder mergeFrom(com.google.protobuf.Message other) {
3346         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
3347           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
3348         } else {
3349           super.mergeFrom(other);
3350           return this;
3351         }
3352       }
3353
3354       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
3355         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
3356         if (other.hasType()) {
3357           setType(other.getType());
3358         }
3359         if (other.hasMessage()) {
3360           bitField0_ |= 0x00000002;
3361           message_ = other.message_;
3362           onChanged();
3363         }
3364         if (other.hasStatus()) {
3365           setStatus(other.getStatus());
3366         }
3367         this.mergeUnknownFields(other.getUnknownFields());
3368         return this;
3369       }
3370
3371       public final boolean isInitialized() {
3372         return true;
3373       }
3374
3375       public Builder mergeFrom(
3376           com.google.protobuf.CodedInputStream input,
3377           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3378           throws java.io.IOException {
3379         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
3380         try {
3381           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3382         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3383           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
3384           throw e;
3385         } finally {
3386           if (parsedMessage != null) {
3387             mergeFrom(parsedMessage);
3388           }
3389         }
3390         return this;
3391       }
3392       private int bitField0_;
3393
3394       // optional .openxc.ControlCommand.Type type = 1;
3395       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3396       /**
3397        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3398        */
3399       public boolean hasType() {
3400         return ((bitField0_ & 0x00000001) == 0x00000001);
3401       }
3402       /**
3403        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3404        */
3405       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
3406         return type_;
3407       }
3408       /**
3409        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3410        */
3411       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
3412         if (value == null) {
3413           throw new NullPointerException();
3414         }
3415         bitField0_ |= 0x00000001;
3416         type_ = value;
3417         onChanged();
3418         return this;
3419       }
3420       /**
3421        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3422        */
3423       public Builder clearType() {
3424         bitField0_ = (bitField0_ & ~0x00000001);
3425         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3426         onChanged();
3427         return this;
3428       }
3429
3430       // optional string message = 2;
3431       private java.lang.Object message_ = "";
3432       /**
3433        * <code>optional string message = 2;</code>
3434        */
3435       public boolean hasMessage() {
3436         return ((bitField0_ & 0x00000002) == 0x00000002);
3437       }
3438       /**
3439        * <code>optional string message = 2;</code>
3440        */
3441       public java.lang.String getMessage() {
3442         java.lang.Object ref = message_;
3443         if (!(ref instanceof java.lang.String)) {
3444           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3445               .toStringUtf8();
3446           message_ = s;
3447           return s;
3448         } else {
3449           return (java.lang.String) ref;
3450         }
3451       }
3452       /**
3453        * <code>optional string message = 2;</code>
3454        */
3455       public com.google.protobuf.ByteString
3456           getMessageBytes() {
3457         java.lang.Object ref = message_;
3458         if (ref instanceof String) {
3459           com.google.protobuf.ByteString b =
3460               com.google.protobuf.ByteString.copyFromUtf8(
3461                   (java.lang.String) ref);
3462           message_ = b;
3463           return b;
3464         } else {
3465           return (com.google.protobuf.ByteString) ref;
3466         }
3467       }
3468       /**
3469        * <code>optional string message = 2;</code>
3470        */
3471       public Builder setMessage(
3472           java.lang.String value) {
3473         if (value == null) {
3474     throw new NullPointerException();
3475   }
3476   bitField0_ |= 0x00000002;
3477         message_ = value;
3478         onChanged();
3479         return this;
3480       }
3481       /**
3482        * <code>optional string message = 2;</code>
3483        */
3484       public Builder clearMessage() {
3485         bitField0_ = (bitField0_ & ~0x00000002);
3486         message_ = getDefaultInstance().getMessage();
3487         onChanged();
3488         return this;
3489       }
3490       /**
3491        * <code>optional string message = 2;</code>
3492        */
3493       public Builder setMessageBytes(
3494           com.google.protobuf.ByteString value) {
3495         if (value == null) {
3496     throw new NullPointerException();
3497   }
3498   bitField0_ |= 0x00000002;
3499         message_ = value;
3500         onChanged();
3501         return this;
3502       }
3503
3504       // optional bool status = 3;
3505       private boolean status_ ;
3506       /**
3507        * <code>optional bool status = 3;</code>
3508        */
3509       public boolean hasStatus() {
3510         return ((bitField0_ & 0x00000004) == 0x00000004);
3511       }
3512       /**
3513        * <code>optional bool status = 3;</code>
3514        */
3515       public boolean getStatus() {
3516         return status_;
3517       }
3518       /**
3519        * <code>optional bool status = 3;</code>
3520        */
3521       public Builder setStatus(boolean value) {
3522         bitField0_ |= 0x00000004;
3523         status_ = value;
3524         onChanged();
3525         return this;
3526       }
3527       /**
3528        * <code>optional bool status = 3;</code>
3529        */
3530       public Builder clearStatus() {
3531         bitField0_ = (bitField0_ & ~0x00000004);
3532         status_ = false;
3533         onChanged();
3534         return this;
3535       }
3536
3537       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
3538     }
3539
3540     static {
3541       defaultInstance = new CommandResponse(true);
3542       defaultInstance.initFields();
3543     }
3544
3545     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
3546   }
3547
3548   public interface DiagnosticRequestOrBuilder
3549       extends com.google.protobuf.MessageOrBuilder {
3550
3551     // optional int32 bus = 1;
3552     /**
3553      * <code>optional int32 bus = 1;</code>
3554      */
3555     boolean hasBus();
3556     /**
3557      * <code>optional int32 bus = 1;</code>
3558      */
3559     int getBus();
3560
3561     // optional uint32 message_id = 2;
3562     /**
3563      * <code>optional uint32 message_id = 2;</code>
3564      */
3565     boolean hasMessageId();
3566     /**
3567      * <code>optional uint32 message_id = 2;</code>
3568      */
3569     int getMessageId();
3570
3571     // optional uint32 mode = 3;
3572     /**
3573      * <code>optional uint32 mode = 3;</code>
3574      */
3575     boolean hasMode();
3576     /**
3577      * <code>optional uint32 mode = 3;</code>
3578      */
3579     int getMode();
3580
3581     // optional uint32 pid = 4;
3582     /**
3583      * <code>optional uint32 pid = 4;</code>
3584      */
3585     boolean hasPid();
3586     /**
3587      * <code>optional uint32 pid = 4;</code>
3588      */
3589     int getPid();
3590
3591     // optional bytes payload = 5;
3592     /**
3593      * <code>optional bytes payload = 5;</code>
3594      *
3595      * <pre>
3596      * TODO we are capping this at 8 bytes for now - need to change when we
3597      * support multi-frame responses
3598      * </pre>
3599      */
3600     boolean hasPayload();
3601     /**
3602      * <code>optional bytes payload = 5;</code>
3603      *
3604      * <pre>
3605      * TODO we are capping this at 8 bytes for now - need to change when we
3606      * support multi-frame responses
3607      * </pre>
3608      */
3609     com.google.protobuf.ByteString getPayload();
3610
3611     // optional bool multiple_responses = 6;
3612     /**
3613      * <code>optional bool multiple_responses = 6;</code>
3614      */
3615     boolean hasMultipleResponses();
3616     /**
3617      * <code>optional bool multiple_responses = 6;</code>
3618      */
3619     boolean getMultipleResponses();
3620
3621     // optional double frequency = 7;
3622     /**
3623      * <code>optional double frequency = 7;</code>
3624      */
3625     boolean hasFrequency();
3626     /**
3627      * <code>optional double frequency = 7;</code>
3628      */
3629     double getFrequency();
3630
3631     // optional string name = 8;
3632     /**
3633      * <code>optional string name = 8;</code>
3634      */
3635     boolean hasName();
3636     /**
3637      * <code>optional string name = 8;</code>
3638      */
3639     java.lang.String getName();
3640     /**
3641      * <code>optional string name = 8;</code>
3642      */
3643     com.google.protobuf.ByteString
3644         getNameBytes();
3645
3646     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
3647     /**
3648      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3649      */
3650     boolean hasDecodedType();
3651     /**
3652      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3653      */
3654     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
3655   }
3656   /**
3657    * Protobuf type {@code openxc.DiagnosticRequest}
3658    */
3659   public static final class DiagnosticRequest extends
3660       com.google.protobuf.GeneratedMessage
3661       implements DiagnosticRequestOrBuilder {
3662     // Use DiagnosticRequest.newBuilder() to construct.
3663     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3664       super(builder);
3665       this.unknownFields = builder.getUnknownFields();
3666     }
3667     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3668
3669     private static final DiagnosticRequest defaultInstance;
3670     public static DiagnosticRequest getDefaultInstance() {
3671       return defaultInstance;
3672     }
3673
3674     public DiagnosticRequest getDefaultInstanceForType() {
3675       return defaultInstance;
3676     }
3677
3678     private final com.google.protobuf.UnknownFieldSet unknownFields;
3679     @java.lang.Override
3680     public final com.google.protobuf.UnknownFieldSet
3681         getUnknownFields() {
3682       return this.unknownFields;
3683     }
3684     private DiagnosticRequest(
3685         com.google.protobuf.CodedInputStream input,
3686         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3687         throws com.google.protobuf.InvalidProtocolBufferException {
3688       initFields();
3689       int mutable_bitField0_ = 0;
3690       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3691           com.google.protobuf.UnknownFieldSet.newBuilder();
3692       try {
3693         boolean done = false;
3694         while (!done) {
3695           int tag = input.readTag();
3696           switch (tag) {
3697             case 0:
3698               done = true;
3699               break;
3700             default: {
3701               if (!parseUnknownField(input, unknownFields,
3702                                      extensionRegistry, tag)) {
3703                 done = true;
3704               }
3705               break;
3706             }
3707             case 8: {
3708               bitField0_ |= 0x00000001;
3709               bus_ = input.readInt32();
3710               break;
3711             }
3712             case 16: {
3713               bitField0_ |= 0x00000002;
3714               messageId_ = input.readUInt32();
3715               break;
3716             }
3717             case 24: {
3718               bitField0_ |= 0x00000004;
3719               mode_ = input.readUInt32();
3720               break;
3721             }
3722             case 32: {
3723               bitField0_ |= 0x00000008;
3724               pid_ = input.readUInt32();
3725               break;
3726             }
3727             case 42: {
3728               bitField0_ |= 0x00000010;
3729               payload_ = input.readBytes();
3730               break;
3731             }
3732             case 48: {
3733               bitField0_ |= 0x00000020;
3734               multipleResponses_ = input.readBool();
3735               break;
3736             }
3737             case 57: {
3738               bitField0_ |= 0x00000040;
3739               frequency_ = input.readDouble();
3740               break;
3741             }
3742             case 66: {
3743               bitField0_ |= 0x00000080;
3744               name_ = input.readBytes();
3745               break;
3746             }
3747             case 72: {
3748               int rawValue = input.readEnum();
3749               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
3750               if (value == null) {
3751                 unknownFields.mergeVarintField(9, rawValue);
3752               } else {
3753                 bitField0_ |= 0x00000100;
3754                 decodedType_ = value;
3755               }
3756               break;
3757             }
3758           }
3759         }
3760       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3761         throw e.setUnfinishedMessage(this);
3762       } catch (java.io.IOException e) {
3763         throw new com.google.protobuf.InvalidProtocolBufferException(
3764             e.getMessage()).setUnfinishedMessage(this);
3765       } finally {
3766         this.unknownFields = unknownFields.build();
3767         makeExtensionsImmutable();
3768       }
3769     }
3770     public static final com.google.protobuf.Descriptors.Descriptor
3771         getDescriptor() {
3772       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
3773     }
3774
3775     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3776         internalGetFieldAccessorTable() {
3777       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
3778           .ensureFieldAccessorsInitialized(
3779               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
3780     }
3781
3782     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
3783         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
3784       public DiagnosticRequest parsePartialFrom(
3785           com.google.protobuf.CodedInputStream input,
3786           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3787           throws com.google.protobuf.InvalidProtocolBufferException {
3788         return new DiagnosticRequest(input, extensionRegistry);
3789       }
3790     };
3791
3792     @java.lang.Override
3793     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
3794       return PARSER;
3795     }
3796
3797     /**
3798      * Protobuf enum {@code openxc.DiagnosticRequest.DecodedType}
3799      */
3800     public enum DecodedType
3801         implements com.google.protobuf.ProtocolMessageEnum {
3802       /**
3803        * <code>NONE = 1;</code>
3804        */
3805       NONE(0, 1),
3806       /**
3807        * <code>OBD2 = 2;</code>
3808        */
3809       OBD2(1, 2),
3810       ;
3811
3812       /**
3813        * <code>NONE = 1;</code>
3814        */
3815       public static final int NONE_VALUE = 1;
3816       /**
3817        * <code>OBD2 = 2;</code>
3818        */
3819       public static final int OBD2_VALUE = 2;
3820
3821
3822       public final int getNumber() { return value; }
3823
3824       public static DecodedType valueOf(int value) {
3825         switch (value) {
3826           case 1: return NONE;
3827           case 2: return OBD2;
3828           default: return null;
3829         }
3830       }
3831
3832       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
3833           internalGetValueMap() {
3834         return internalValueMap;
3835       }
3836       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
3837           internalValueMap =
3838             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
3839               public DecodedType findValueByNumber(int number) {
3840                 return DecodedType.valueOf(number);
3841               }
3842             };
3843
3844       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3845           getValueDescriptor() {
3846         return getDescriptor().getValues().get(index);
3847       }
3848       public final com.google.protobuf.Descriptors.EnumDescriptor
3849           getDescriptorForType() {
3850         return getDescriptor();
3851       }
3852       public static final com.google.protobuf.Descriptors.EnumDescriptor
3853           getDescriptor() {
3854         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
3855       }
3856
3857       private static final DecodedType[] VALUES = values();
3858
3859       public static DecodedType valueOf(
3860           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3861         if (desc.getType() != getDescriptor()) {
3862           throw new java.lang.IllegalArgumentException(
3863             "EnumValueDescriptor is not for this type.");
3864         }
3865         return VALUES[desc.getIndex()];
3866       }
3867
3868       private final int index;
3869       private final int value;
3870
3871       private DecodedType(int index, int value) {
3872         this.index = index;
3873         this.value = value;
3874       }
3875
3876       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
3877     }
3878
3879     private int bitField0_;
3880     // optional int32 bus = 1;
3881     public static final int BUS_FIELD_NUMBER = 1;
3882     private int bus_;
3883     /**
3884      * <code>optional int32 bus = 1;</code>
3885      */
3886     public boolean hasBus() {
3887       return ((bitField0_ & 0x00000001) == 0x00000001);
3888     }
3889     /**
3890      * <code>optional int32 bus = 1;</code>
3891      */
3892     public int getBus() {
3893       return bus_;
3894     }
3895
3896     // optional uint32 message_id = 2;
3897     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
3898     private int messageId_;
3899     /**
3900      * <code>optional uint32 message_id = 2;</code>
3901      */
3902     public boolean hasMessageId() {
3903       return ((bitField0_ & 0x00000002) == 0x00000002);
3904     }
3905     /**
3906      * <code>optional uint32 message_id = 2;</code>
3907      */
3908     public int getMessageId() {
3909       return messageId_;
3910     }
3911
3912     // optional uint32 mode = 3;
3913     public static final int MODE_FIELD_NUMBER = 3;
3914     private int mode_;
3915     /**
3916      * <code>optional uint32 mode = 3;</code>
3917      */
3918     public boolean hasMode() {
3919       return ((bitField0_ & 0x00000004) == 0x00000004);
3920     }
3921     /**
3922      * <code>optional uint32 mode = 3;</code>
3923      */
3924     public int getMode() {
3925       return mode_;
3926     }
3927
3928     // optional uint32 pid = 4;
3929     public static final int PID_FIELD_NUMBER = 4;
3930     private int pid_;
3931     /**
3932      * <code>optional uint32 pid = 4;</code>
3933      */
3934     public boolean hasPid() {
3935       return ((bitField0_ & 0x00000008) == 0x00000008);
3936     }
3937     /**
3938      * <code>optional uint32 pid = 4;</code>
3939      */
3940     public int getPid() {
3941       return pid_;
3942     }
3943
3944     // optional bytes payload = 5;
3945     public static final int PAYLOAD_FIELD_NUMBER = 5;
3946     private com.google.protobuf.ByteString payload_;
3947     /**
3948      * <code>optional bytes payload = 5;</code>
3949      *
3950      * <pre>
3951      * TODO we are capping this at 8 bytes for now - need to change when we
3952      * support multi-frame responses
3953      * </pre>
3954      */
3955     public boolean hasPayload() {
3956       return ((bitField0_ & 0x00000010) == 0x00000010);
3957     }
3958     /**
3959      * <code>optional bytes payload = 5;</code>
3960      *
3961      * <pre>
3962      * TODO we are capping this at 8 bytes for now - need to change when we
3963      * support multi-frame responses
3964      * </pre>
3965      */
3966     public com.google.protobuf.ByteString getPayload() {
3967       return payload_;
3968     }
3969
3970     // optional bool multiple_responses = 6;
3971     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
3972     private boolean multipleResponses_;
3973     /**
3974      * <code>optional bool multiple_responses = 6;</code>
3975      */
3976     public boolean hasMultipleResponses() {
3977       return ((bitField0_ & 0x00000020) == 0x00000020);
3978     }
3979     /**
3980      * <code>optional bool multiple_responses = 6;</code>
3981      */
3982     public boolean getMultipleResponses() {
3983       return multipleResponses_;
3984     }
3985
3986     // optional double frequency = 7;
3987     public static final int FREQUENCY_FIELD_NUMBER = 7;
3988     private double frequency_;
3989     /**
3990      * <code>optional double frequency = 7;</code>
3991      */
3992     public boolean hasFrequency() {
3993       return ((bitField0_ & 0x00000040) == 0x00000040);
3994     }
3995     /**
3996      * <code>optional double frequency = 7;</code>
3997      */
3998     public double getFrequency() {
3999       return frequency_;
4000     }
4001
4002     // optional string name = 8;
4003     public static final int NAME_FIELD_NUMBER = 8;
4004     private java.lang.Object name_;
4005     /**
4006      * <code>optional string name = 8;</code>
4007      */
4008     public boolean hasName() {
4009       return ((bitField0_ & 0x00000080) == 0x00000080);
4010     }
4011     /**
4012      * <code>optional string name = 8;</code>
4013      */
4014     public java.lang.String getName() {
4015       java.lang.Object ref = name_;
4016       if (ref instanceof java.lang.String) {
4017         return (java.lang.String) ref;
4018       } else {
4019         com.google.protobuf.ByteString bs =
4020             (com.google.protobuf.ByteString) ref;
4021         java.lang.String s = bs.toStringUtf8();
4022         if (bs.isValidUtf8()) {
4023           name_ = s;
4024         }
4025         return s;
4026       }
4027     }
4028     /**
4029      * <code>optional string name = 8;</code>
4030      */
4031     public com.google.protobuf.ByteString
4032         getNameBytes() {
4033       java.lang.Object ref = name_;
4034       if (ref instanceof java.lang.String) {
4035         com.google.protobuf.ByteString b =
4036             com.google.protobuf.ByteString.copyFromUtf8(
4037                 (java.lang.String) ref);
4038         name_ = b;
4039         return b;
4040       } else {
4041         return (com.google.protobuf.ByteString) ref;
4042       }
4043     }
4044
4045     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
4046     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
4047     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
4048     /**
4049      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4050      */
4051     public boolean hasDecodedType() {
4052       return ((bitField0_ & 0x00000100) == 0x00000100);
4053     }
4054     /**
4055      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4056      */
4057     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
4058       return decodedType_;
4059     }
4060
4061     private void initFields() {
4062       bus_ = 0;
4063       messageId_ = 0;
4064       mode_ = 0;
4065       pid_ = 0;
4066       payload_ = com.google.protobuf.ByteString.EMPTY;
4067       multipleResponses_ = false;
4068       frequency_ = 0D;
4069       name_ = "";
4070       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4071     }
4072     private byte memoizedIsInitialized = -1;
4073     public final boolean isInitialized() {
4074       byte isInitialized = memoizedIsInitialized;
4075       if (isInitialized != -1) return isInitialized == 1;
4076
4077       memoizedIsInitialized = 1;
4078       return true;
4079     }
4080
4081     public void writeTo(com.google.protobuf.CodedOutputStream output)
4082                         throws java.io.IOException {
4083       getSerializedSize();
4084       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4085         output.writeInt32(1, bus_);
4086       }
4087       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4088         output.writeUInt32(2, messageId_);
4089       }
4090       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4091         output.writeUInt32(3, mode_);
4092       }
4093       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4094         output.writeUInt32(4, pid_);
4095       }
4096       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4097         output.writeBytes(5, payload_);
4098       }
4099       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4100         output.writeBool(6, multipleResponses_);
4101       }
4102       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4103         output.writeDouble(7, frequency_);
4104       }
4105       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4106         output.writeBytes(8, getNameBytes());
4107       }
4108       if (((bitField0_ & 0x00000100) == 0x00000100)) {
4109         output.writeEnum(9, decodedType_.getNumber());
4110       }
4111       getUnknownFields().writeTo(output);
4112     }
4113
4114     private int memoizedSerializedSize = -1;
4115     public int getSerializedSize() {
4116       int size = memoizedSerializedSize;
4117       if (size != -1) return size;
4118
4119       size = 0;
4120       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4121         size += com.google.protobuf.CodedOutputStream
4122           .computeInt32Size(1, bus_);
4123       }
4124       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4125         size += com.google.protobuf.CodedOutputStream
4126           .computeUInt32Size(2, messageId_);
4127       }
4128       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4129         size += com.google.protobuf.CodedOutputStream
4130           .computeUInt32Size(3, mode_);
4131       }
4132       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4133         size += com.google.protobuf.CodedOutputStream
4134           .computeUInt32Size(4, pid_);
4135       }
4136       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4137         size += com.google.protobuf.CodedOutputStream
4138           .computeBytesSize(5, payload_);
4139       }
4140       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4141         size += com.google.protobuf.CodedOutputStream
4142           .computeBoolSize(6, multipleResponses_);
4143       }
4144       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4145         size += com.google.protobuf.CodedOutputStream
4146           .computeDoubleSize(7, frequency_);
4147       }
4148       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4149         size += com.google.protobuf.CodedOutputStream
4150           .computeBytesSize(8, getNameBytes());
4151       }
4152       if (((bitField0_ & 0x00000100) == 0x00000100)) {
4153         size += com.google.protobuf.CodedOutputStream
4154           .computeEnumSize(9, decodedType_.getNumber());
4155       }
4156       size += getUnknownFields().getSerializedSize();
4157       memoizedSerializedSize = size;
4158       return size;
4159     }
4160
4161     private static final long serialVersionUID = 0L;
4162     @java.lang.Override
4163     protected java.lang.Object writeReplace()
4164         throws java.io.ObjectStreamException {
4165       return super.writeReplace();
4166     }
4167
4168     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4169         com.google.protobuf.ByteString data)
4170         throws com.google.protobuf.InvalidProtocolBufferException {
4171       return PARSER.parseFrom(data);
4172     }
4173     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4174         com.google.protobuf.ByteString data,
4175         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4176         throws com.google.protobuf.InvalidProtocolBufferException {
4177       return PARSER.parseFrom(data, extensionRegistry);
4178     }
4179     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
4180         throws com.google.protobuf.InvalidProtocolBufferException {
4181       return PARSER.parseFrom(data);
4182     }
4183     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4184         byte[] data,
4185         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4186         throws com.google.protobuf.InvalidProtocolBufferException {
4187       return PARSER.parseFrom(data, extensionRegistry);
4188     }
4189     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
4190         throws java.io.IOException {
4191       return PARSER.parseFrom(input);
4192     }
4193     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4194         java.io.InputStream input,
4195         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4196         throws java.io.IOException {
4197       return PARSER.parseFrom(input, extensionRegistry);
4198     }
4199     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
4200         throws java.io.IOException {
4201       return PARSER.parseDelimitedFrom(input);
4202     }
4203     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
4204         java.io.InputStream input,
4205         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4206         throws java.io.IOException {
4207       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4208     }
4209     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4210         com.google.protobuf.CodedInputStream input)
4211         throws java.io.IOException {
4212       return PARSER.parseFrom(input);
4213     }
4214     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4215         com.google.protobuf.CodedInputStream input,
4216         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4217         throws java.io.IOException {
4218       return PARSER.parseFrom(input, extensionRegistry);
4219     }
4220
4221     public static Builder newBuilder() { return Builder.create(); }
4222     public Builder newBuilderForType() { return newBuilder(); }
4223     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
4224       return newBuilder().mergeFrom(prototype);
4225     }
4226     public Builder toBuilder() { return newBuilder(this); }
4227
4228     @java.lang.Override
4229     protected Builder newBuilderForType(
4230         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4231       Builder builder = new Builder(parent);
4232       return builder;
4233     }
4234     /**
4235      * Protobuf type {@code openxc.DiagnosticRequest}
4236      */
4237     public static final class Builder extends
4238         com.google.protobuf.GeneratedMessage.Builder<Builder>
4239        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
4240       public static final com.google.protobuf.Descriptors.Descriptor
4241           getDescriptor() {
4242         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4243       }
4244
4245       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4246           internalGetFieldAccessorTable() {
4247         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
4248             .ensureFieldAccessorsInitialized(
4249                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
4250       }
4251
4252       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
4253       private Builder() {
4254         maybeForceBuilderInitialization();
4255       }
4256
4257       private Builder(
4258           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4259         super(parent);
4260         maybeForceBuilderInitialization();
4261       }
4262       private void maybeForceBuilderInitialization() {
4263         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4264         }
4265       }
4266       private static Builder create() {
4267         return new Builder();
4268       }
4269
4270       public Builder clear() {
4271         super.clear();
4272         bus_ = 0;
4273         bitField0_ = (bitField0_ & ~0x00000001);
4274         messageId_ = 0;
4275         bitField0_ = (bitField0_ & ~0x00000002);
4276         mode_ = 0;
4277         bitField0_ = (bitField0_ & ~0x00000004);
4278         pid_ = 0;
4279         bitField0_ = (bitField0_ & ~0x00000008);
4280         payload_ = com.google.protobuf.ByteString.EMPTY;
4281         bitField0_ = (bitField0_ & ~0x00000010);
4282         multipleResponses_ = false;
4283         bitField0_ = (bitField0_ & ~0x00000020);
4284         frequency_ = 0D;
4285         bitField0_ = (bitField0_ & ~0x00000040);
4286         name_ = "";
4287         bitField0_ = (bitField0_ & ~0x00000080);
4288         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4289         bitField0_ = (bitField0_ & ~0x00000100);
4290         return this;
4291       }
4292
4293       public Builder clone() {
4294         return create().mergeFrom(buildPartial());
4295       }
4296
4297       public com.google.protobuf.Descriptors.Descriptor
4298           getDescriptorForType() {
4299         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4300       }
4301
4302       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
4303         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4304       }
4305
4306       public com.openxc.BinaryMessages.DiagnosticRequest build() {
4307         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
4308         if (!result.isInitialized()) {
4309           throw newUninitializedMessageException(result);
4310         }
4311         return result;
4312       }
4313
4314       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
4315         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
4316         int from_bitField0_ = bitField0_;
4317         int to_bitField0_ = 0;
4318         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4319           to_bitField0_ |= 0x00000001;
4320         }
4321         result.bus_ = bus_;
4322         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4323           to_bitField0_ |= 0x00000002;
4324         }
4325         result.messageId_ = messageId_;
4326         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4327           to_bitField0_ |= 0x00000004;
4328         }
4329         result.mode_ = mode_;
4330         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
4331           to_bitField0_ |= 0x00000008;
4332         }
4333         result.pid_ = pid_;
4334         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
4335           to_bitField0_ |= 0x00000010;
4336         }
4337         result.payload_ = payload_;
4338         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
4339           to_bitField0_ |= 0x00000020;
4340         }
4341         result.multipleResponses_ = multipleResponses_;
4342         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
4343           to_bitField0_ |= 0x00000040;
4344         }
4345         result.frequency_ = frequency_;
4346         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
4347           to_bitField0_ |= 0x00000080;
4348         }
4349         result.name_ = name_;
4350         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
4351           to_bitField0_ |= 0x00000100;
4352         }
4353         result.decodedType_ = decodedType_;
4354         result.bitField0_ = to_bitField0_;
4355         onBuilt();
4356         return result;
4357       }
4358
4359       public Builder mergeFrom(com.google.protobuf.Message other) {
4360         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
4361           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
4362         } else {
4363           super.mergeFrom(other);
4364           return this;
4365         }
4366       }
4367
4368       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
4369         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
4370         if (other.hasBus()) {
4371           setBus(other.getBus());
4372         }
4373         if (other.hasMessageId()) {
4374           setMessageId(other.getMessageId());
4375         }
4376         if (other.hasMode()) {
4377           setMode(other.getMode());
4378         }
4379         if (other.hasPid()) {
4380           setPid(other.getPid());
4381         }
4382         if (other.hasPayload()) {
4383           setPayload(other.getPayload());
4384         }
4385         if (other.hasMultipleResponses()) {
4386           setMultipleResponses(other.getMultipleResponses());
4387         }
4388         if (other.hasFrequency()) {
4389           setFrequency(other.getFrequency());
4390         }
4391         if (other.hasName()) {
4392           bitField0_ |= 0x00000080;
4393           name_ = other.name_;
4394           onChanged();
4395         }
4396         if (other.hasDecodedType()) {
4397           setDecodedType(other.getDecodedType());
4398         }
4399         this.mergeUnknownFields(other.getUnknownFields());
4400         return this;
4401       }
4402
4403       public final boolean isInitialized() {
4404         return true;
4405       }
4406
4407       public Builder mergeFrom(
4408           com.google.protobuf.CodedInputStream input,
4409           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4410           throws java.io.IOException {
4411         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
4412         try {
4413           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4414         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4415           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
4416           throw e;
4417         } finally {
4418           if (parsedMessage != null) {
4419             mergeFrom(parsedMessage);
4420           }
4421         }
4422         return this;
4423       }
4424       private int bitField0_;
4425
4426       // optional int32 bus = 1;
4427       private int bus_ ;
4428       /**
4429        * <code>optional int32 bus = 1;</code>
4430        */
4431       public boolean hasBus() {
4432         return ((bitField0_ & 0x00000001) == 0x00000001);
4433       }
4434       /**
4435        * <code>optional int32 bus = 1;</code>
4436        */
4437       public int getBus() {
4438         return bus_;
4439       }
4440       /**
4441        * <code>optional int32 bus = 1;</code>
4442        */
4443       public Builder setBus(int value) {
4444         bitField0_ |= 0x00000001;
4445         bus_ = value;
4446         onChanged();
4447         return this;
4448       }
4449       /**
4450        * <code>optional int32 bus = 1;</code>
4451        */
4452       public Builder clearBus() {
4453         bitField0_ = (bitField0_ & ~0x00000001);
4454         bus_ = 0;
4455         onChanged();
4456         return this;
4457       }
4458
4459       // optional uint32 message_id = 2;
4460       private int messageId_ ;
4461       /**
4462        * <code>optional uint32 message_id = 2;</code>
4463        */
4464       public boolean hasMessageId() {
4465         return ((bitField0_ & 0x00000002) == 0x00000002);
4466       }
4467       /**
4468        * <code>optional uint32 message_id = 2;</code>
4469        */
4470       public int getMessageId() {
4471         return messageId_;
4472       }
4473       /**
4474        * <code>optional uint32 message_id = 2;</code>
4475        */
4476       public Builder setMessageId(int value) {
4477         bitField0_ |= 0x00000002;
4478         messageId_ = value;
4479         onChanged();
4480         return this;
4481       }
4482       /**
4483        * <code>optional uint32 message_id = 2;</code>
4484        */
4485       public Builder clearMessageId() {
4486         bitField0_ = (bitField0_ & ~0x00000002);
4487         messageId_ = 0;
4488         onChanged();
4489         return this;
4490       }
4491
4492       // optional uint32 mode = 3;
4493       private int mode_ ;
4494       /**
4495        * <code>optional uint32 mode = 3;</code>
4496        */
4497       public boolean hasMode() {
4498         return ((bitField0_ & 0x00000004) == 0x00000004);
4499       }
4500       /**
4501        * <code>optional uint32 mode = 3;</code>
4502        */
4503       public int getMode() {
4504         return mode_;
4505       }
4506       /**
4507        * <code>optional uint32 mode = 3;</code>
4508        */
4509       public Builder setMode(int value) {
4510         bitField0_ |= 0x00000004;
4511         mode_ = value;
4512         onChanged();
4513         return this;
4514       }
4515       /**
4516        * <code>optional uint32 mode = 3;</code>
4517        */
4518       public Builder clearMode() {
4519         bitField0_ = (bitField0_ & ~0x00000004);
4520         mode_ = 0;
4521         onChanged();
4522         return this;
4523       }
4524
4525       // optional uint32 pid = 4;
4526       private int pid_ ;
4527       /**
4528        * <code>optional uint32 pid = 4;</code>
4529        */
4530       public boolean hasPid() {
4531         return ((bitField0_ & 0x00000008) == 0x00000008);
4532       }
4533       /**
4534        * <code>optional uint32 pid = 4;</code>
4535        */
4536       public int getPid() {
4537         return pid_;
4538       }
4539       /**
4540        * <code>optional uint32 pid = 4;</code>
4541        */
4542       public Builder setPid(int value) {
4543         bitField0_ |= 0x00000008;
4544         pid_ = value;
4545         onChanged();
4546         return this;
4547       }
4548       /**
4549        * <code>optional uint32 pid = 4;</code>
4550        */
4551       public Builder clearPid() {
4552         bitField0_ = (bitField0_ & ~0x00000008);
4553         pid_ = 0;
4554         onChanged();
4555         return this;
4556       }
4557
4558       // optional bytes payload = 5;
4559       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
4560       /**
4561        * <code>optional bytes payload = 5;</code>
4562        *
4563        * <pre>
4564        * TODO we are capping this at 8 bytes for now - need to change when we
4565        * support multi-frame responses
4566        * </pre>
4567        */
4568       public boolean hasPayload() {
4569         return ((bitField0_ & 0x00000010) == 0x00000010);
4570       }
4571       /**
4572        * <code>optional bytes payload = 5;</code>
4573        *
4574        * <pre>
4575        * TODO we are capping this at 8 bytes for now - need to change when we
4576        * support multi-frame responses
4577        * </pre>
4578        */
4579       public com.google.protobuf.ByteString getPayload() {
4580         return payload_;
4581       }
4582       /**
4583        * <code>optional bytes payload = 5;</code>
4584        *
4585        * <pre>
4586        * TODO we are capping this at 8 bytes for now - need to change when we
4587        * support multi-frame responses
4588        * </pre>
4589        */
4590       public Builder setPayload(com.google.protobuf.ByteString value) {
4591         if (value == null) {
4592     throw new NullPointerException();
4593   }
4594   bitField0_ |= 0x00000010;
4595         payload_ = value;
4596         onChanged();
4597         return this;
4598       }
4599       /**
4600        * <code>optional bytes payload = 5;</code>
4601        *
4602        * <pre>
4603        * TODO we are capping this at 8 bytes for now - need to change when we
4604        * support multi-frame responses
4605        * </pre>
4606        */
4607       public Builder clearPayload() {
4608         bitField0_ = (bitField0_ & ~0x00000010);
4609         payload_ = getDefaultInstance().getPayload();
4610         onChanged();
4611         return this;
4612       }
4613
4614       // optional bool multiple_responses = 6;
4615       private boolean multipleResponses_ ;
4616       /**
4617        * <code>optional bool multiple_responses = 6;</code>
4618        */
4619       public boolean hasMultipleResponses() {
4620         return ((bitField0_ & 0x00000020) == 0x00000020);
4621       }
4622       /**
4623        * <code>optional bool multiple_responses = 6;</code>
4624        */
4625       public boolean getMultipleResponses() {
4626         return multipleResponses_;
4627       }
4628       /**
4629        * <code>optional bool multiple_responses = 6;</code>
4630        */
4631       public Builder setMultipleResponses(boolean value) {
4632         bitField0_ |= 0x00000020;
4633         multipleResponses_ = value;
4634         onChanged();
4635         return this;
4636       }
4637       /**
4638        * <code>optional bool multiple_responses = 6;</code>
4639        */
4640       public Builder clearMultipleResponses() {
4641         bitField0_ = (bitField0_ & ~0x00000020);
4642         multipleResponses_ = false;
4643         onChanged();
4644         return this;
4645       }
4646
4647       // optional double frequency = 7;
4648       private double frequency_ ;
4649       /**
4650        * <code>optional double frequency = 7;</code>
4651        */
4652       public boolean hasFrequency() {
4653         return ((bitField0_ & 0x00000040) == 0x00000040);
4654       }
4655       /**
4656        * <code>optional double frequency = 7;</code>
4657        */
4658       public double getFrequency() {
4659         return frequency_;
4660       }
4661       /**
4662        * <code>optional double frequency = 7;</code>
4663        */
4664       public Builder setFrequency(double value) {
4665         bitField0_ |= 0x00000040;
4666         frequency_ = value;
4667         onChanged();
4668         return this;
4669       }
4670       /**
4671        * <code>optional double frequency = 7;</code>
4672        */
4673       public Builder clearFrequency() {
4674         bitField0_ = (bitField0_ & ~0x00000040);
4675         frequency_ = 0D;
4676         onChanged();
4677         return this;
4678       }
4679
4680       // optional string name = 8;
4681       private java.lang.Object name_ = "";
4682       /**
4683        * <code>optional string name = 8;</code>
4684        */
4685       public boolean hasName() {
4686         return ((bitField0_ & 0x00000080) == 0x00000080);
4687       }
4688       /**
4689        * <code>optional string name = 8;</code>
4690        */
4691       public java.lang.String getName() {
4692         java.lang.Object ref = name_;
4693         if (!(ref instanceof java.lang.String)) {
4694           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4695               .toStringUtf8();
4696           name_ = s;
4697           return s;
4698         } else {
4699           return (java.lang.String) ref;
4700         }
4701       }
4702       /**
4703        * <code>optional string name = 8;</code>
4704        */
4705       public com.google.protobuf.ByteString
4706           getNameBytes() {
4707         java.lang.Object ref = name_;
4708         if (ref instanceof String) {
4709           com.google.protobuf.ByteString b =
4710               com.google.protobuf.ByteString.copyFromUtf8(
4711                   (java.lang.String) ref);
4712           name_ = b;
4713           return b;
4714         } else {
4715           return (com.google.protobuf.ByteString) ref;
4716         }
4717       }
4718       /**
4719        * <code>optional string name = 8;</code>
4720        */
4721       public Builder setName(
4722           java.lang.String value) {
4723         if (value == null) {
4724     throw new NullPointerException();
4725   }
4726   bitField0_ |= 0x00000080;
4727         name_ = value;
4728         onChanged();
4729         return this;
4730       }
4731       /**
4732        * <code>optional string name = 8;</code>
4733        */
4734       public Builder clearName() {
4735         bitField0_ = (bitField0_ & ~0x00000080);
4736         name_ = getDefaultInstance().getName();
4737         onChanged();
4738         return this;
4739       }
4740       /**
4741        * <code>optional string name = 8;</code>
4742        */
4743       public Builder setNameBytes(
4744           com.google.protobuf.ByteString value) {
4745         if (value == null) {
4746     throw new NullPointerException();
4747   }
4748   bitField0_ |= 0x00000080;
4749         name_ = value;
4750         onChanged();
4751         return this;
4752       }
4753
4754       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
4755       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4756       /**
4757        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4758        */
4759       public boolean hasDecodedType() {
4760         return ((bitField0_ & 0x00000100) == 0x00000100);
4761       }
4762       /**
4763        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4764        */
4765       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
4766         return decodedType_;
4767       }
4768       /**
4769        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4770        */
4771       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
4772         if (value == null) {
4773           throw new NullPointerException();
4774         }
4775         bitField0_ |= 0x00000100;
4776         decodedType_ = value;
4777         onChanged();
4778         return this;
4779       }
4780       /**
4781        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4782        */
4783       public Builder clearDecodedType() {
4784         bitField0_ = (bitField0_ & ~0x00000100);
4785         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4786         onChanged();
4787         return this;
4788       }
4789
4790       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
4791     }
4792
4793     static {
4794       defaultInstance = new DiagnosticRequest(true);
4795       defaultInstance.initFields();
4796     }
4797
4798     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
4799   }
4800
4801   public interface DiagnosticResponseOrBuilder
4802       extends com.google.protobuf.MessageOrBuilder {
4803
4804     // optional int32 bus = 1;
4805     /**
4806      * <code>optional int32 bus = 1;</code>
4807      */
4808     boolean hasBus();
4809     /**
4810      * <code>optional int32 bus = 1;</code>
4811      */
4812     int getBus();
4813
4814     // optional uint32 message_id = 2;
4815     /**
4816      * <code>optional uint32 message_id = 2;</code>
4817      */
4818     boolean hasMessageId();
4819     /**
4820      * <code>optional uint32 message_id = 2;</code>
4821      */
4822     int getMessageId();
4823
4824     // optional uint32 mode = 3;
4825     /**
4826      * <code>optional uint32 mode = 3;</code>
4827      */
4828     boolean hasMode();
4829     /**
4830      * <code>optional uint32 mode = 3;</code>
4831      */
4832     int getMode();
4833
4834     // optional uint32 pid = 4;
4835     /**
4836      * <code>optional uint32 pid = 4;</code>
4837      */
4838     boolean hasPid();
4839     /**
4840      * <code>optional uint32 pid = 4;</code>
4841      */
4842     int getPid();
4843
4844     // optional bool success = 5;
4845     /**
4846      * <code>optional bool success = 5;</code>
4847      */
4848     boolean hasSuccess();
4849     /**
4850      * <code>optional bool success = 5;</code>
4851      */
4852     boolean getSuccess();
4853
4854     // optional uint32 negative_response_code = 6;
4855     /**
4856      * <code>optional uint32 negative_response_code = 6;</code>
4857      */
4858     boolean hasNegativeResponseCode();
4859     /**
4860      * <code>optional uint32 negative_response_code = 6;</code>
4861      */
4862     int getNegativeResponseCode();
4863
4864     // optional bytes payload = 7;
4865     /**
4866      * <code>optional bytes payload = 7;</code>
4867      *
4868      * <pre>
4869      * TODO we are capping this at 8 bytes for now - need to change when we
4870      * support multi-frame responses
4871      * </pre>
4872      */
4873     boolean hasPayload();
4874     /**
4875      * <code>optional bytes payload = 7;</code>
4876      *
4877      * <pre>
4878      * TODO we are capping this at 8 bytes for now - need to change when we
4879      * support multi-frame responses
4880      * </pre>
4881      */
4882     com.google.protobuf.ByteString getPayload();
4883
4884     // optional double value = 8;
4885     /**
4886      * <code>optional double value = 8;</code>
4887      */
4888     boolean hasValue();
4889     /**
4890      * <code>optional double value = 8;</code>
4891      */
4892     double getValue();
4893   }
4894   /**
4895    * Protobuf type {@code openxc.DiagnosticResponse}
4896    */
4897   public static final class DiagnosticResponse extends
4898       com.google.protobuf.GeneratedMessage
4899       implements DiagnosticResponseOrBuilder {
4900     // Use DiagnosticResponse.newBuilder() to construct.
4901     private DiagnosticResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4902       super(builder);
4903       this.unknownFields = builder.getUnknownFields();
4904     }
4905     private DiagnosticResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4906
4907     private static final DiagnosticResponse defaultInstance;
4908     public static DiagnosticResponse getDefaultInstance() {
4909       return defaultInstance;
4910     }
4911
4912     public DiagnosticResponse getDefaultInstanceForType() {
4913       return defaultInstance;
4914     }
4915
4916     private final com.google.protobuf.UnknownFieldSet unknownFields;
4917     @java.lang.Override
4918     public final com.google.protobuf.UnknownFieldSet
4919         getUnknownFields() {
4920       return this.unknownFields;
4921     }
4922     private DiagnosticResponse(
4923         com.google.protobuf.CodedInputStream input,
4924         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4925         throws com.google.protobuf.InvalidProtocolBufferException {
4926       initFields();
4927       int mutable_bitField0_ = 0;
4928       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4929           com.google.protobuf.UnknownFieldSet.newBuilder();
4930       try {
4931         boolean done = false;
4932         while (!done) {
4933           int tag = input.readTag();
4934           switch (tag) {
4935             case 0:
4936               done = true;
4937               break;
4938             default: {
4939               if (!parseUnknownField(input, unknownFields,
4940                                      extensionRegistry, tag)) {
4941                 done = true;
4942               }
4943               break;
4944             }
4945             case 8: {
4946               bitField0_ |= 0x00000001;
4947               bus_ = input.readInt32();
4948               break;
4949             }
4950             case 16: {
4951               bitField0_ |= 0x00000002;
4952               messageId_ = input.readUInt32();
4953               break;
4954             }
4955             case 24: {
4956               bitField0_ |= 0x00000004;
4957               mode_ = input.readUInt32();
4958               break;
4959             }
4960             case 32: {
4961               bitField0_ |= 0x00000008;
4962               pid_ = input.readUInt32();
4963               break;
4964             }
4965             case 40: {
4966               bitField0_ |= 0x00000010;
4967               success_ = input.readBool();
4968               break;
4969             }
4970             case 48: {
4971               bitField0_ |= 0x00000020;
4972               negativeResponseCode_ = input.readUInt32();
4973               break;
4974             }
4975             case 58: {
4976               bitField0_ |= 0x00000040;
4977               payload_ = input.readBytes();
4978               break;
4979             }
4980             case 65: {
4981               bitField0_ |= 0x00000080;
4982               value_ = input.readDouble();
4983               break;
4984             }
4985           }
4986         }
4987       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4988         throw e.setUnfinishedMessage(this);
4989       } catch (java.io.IOException e) {
4990         throw new com.google.protobuf.InvalidProtocolBufferException(
4991             e.getMessage()).setUnfinishedMessage(this);
4992       } finally {
4993         this.unknownFields = unknownFields.build();
4994         makeExtensionsImmutable();
4995       }
4996     }
4997     public static final com.google.protobuf.Descriptors.Descriptor
4998         getDescriptor() {
4999       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5000     }
5001
5002     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5003         internalGetFieldAccessorTable() {
5004       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
5005           .ensureFieldAccessorsInitialized(
5006               com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
5007     }
5008
5009     public static com.google.protobuf.Parser<DiagnosticResponse> PARSER =
5010         new com.google.protobuf.AbstractParser<DiagnosticResponse>() {
5011       public DiagnosticResponse parsePartialFrom(
5012           com.google.protobuf.CodedInputStream input,
5013           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5014           throws com.google.protobuf.InvalidProtocolBufferException {
5015         return new DiagnosticResponse(input, extensionRegistry);
5016       }
5017     };
5018
5019     @java.lang.Override
5020     public com.google.protobuf.Parser<DiagnosticResponse> getParserForType() {
5021       return PARSER;
5022     }
5023
5024     private int bitField0_;
5025     // optional int32 bus = 1;
5026     public static final int BUS_FIELD_NUMBER = 1;
5027     private int bus_;
5028     /**
5029      * <code>optional int32 bus = 1;</code>
5030      */
5031     public boolean hasBus() {
5032       return ((bitField0_ & 0x00000001) == 0x00000001);
5033     }
5034     /**
5035      * <code>optional int32 bus = 1;</code>
5036      */
5037     public int getBus() {
5038       return bus_;
5039     }
5040
5041     // optional uint32 message_id = 2;
5042     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
5043     private int messageId_;
5044     /**
5045      * <code>optional uint32 message_id = 2;</code>
5046      */
5047     public boolean hasMessageId() {
5048       return ((bitField0_ & 0x00000002) == 0x00000002);
5049     }
5050     /**
5051      * <code>optional uint32 message_id = 2;</code>
5052      */
5053     public int getMessageId() {
5054       return messageId_;
5055     }
5056
5057     // optional uint32 mode = 3;
5058     public static final int MODE_FIELD_NUMBER = 3;
5059     private int mode_;
5060     /**
5061      * <code>optional uint32 mode = 3;</code>
5062      */
5063     public boolean hasMode() {
5064       return ((bitField0_ & 0x00000004) == 0x00000004);
5065     }
5066     /**
5067      * <code>optional uint32 mode = 3;</code>
5068      */
5069     public int getMode() {
5070       return mode_;
5071     }
5072
5073     // optional uint32 pid = 4;
5074     public static final int PID_FIELD_NUMBER = 4;
5075     private int pid_;
5076     /**
5077      * <code>optional uint32 pid = 4;</code>
5078      */
5079     public boolean hasPid() {
5080       return ((bitField0_ & 0x00000008) == 0x00000008);
5081     }
5082     /**
5083      * <code>optional uint32 pid = 4;</code>
5084      */
5085     public int getPid() {
5086       return pid_;
5087     }
5088
5089     // optional bool success = 5;
5090     public static final int SUCCESS_FIELD_NUMBER = 5;
5091     private boolean success_;
5092     /**
5093      * <code>optional bool success = 5;</code>
5094      */
5095     public boolean hasSuccess() {
5096       return ((bitField0_ & 0x00000010) == 0x00000010);
5097     }
5098     /**
5099      * <code>optional bool success = 5;</code>
5100      */
5101     public boolean getSuccess() {
5102       return success_;
5103     }
5104
5105     // optional uint32 negative_response_code = 6;
5106     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
5107     private int negativeResponseCode_;
5108     /**
5109      * <code>optional uint32 negative_response_code = 6;</code>
5110      */
5111     public boolean hasNegativeResponseCode() {
5112       return ((bitField0_ & 0x00000020) == 0x00000020);
5113     }
5114     /**
5115      * <code>optional uint32 negative_response_code = 6;</code>
5116      */
5117     public int getNegativeResponseCode() {
5118       return negativeResponseCode_;
5119     }
5120
5121     // optional bytes payload = 7;
5122     public static final int PAYLOAD_FIELD_NUMBER = 7;
5123     private com.google.protobuf.ByteString payload_;
5124     /**
5125      * <code>optional bytes payload = 7;</code>
5126      *
5127      * <pre>
5128      * TODO we are capping this at 8 bytes for now - need to change when we
5129      * support multi-frame responses
5130      * </pre>
5131      */
5132     public boolean hasPayload() {
5133       return ((bitField0_ & 0x00000040) == 0x00000040);
5134     }
5135     /**
5136      * <code>optional bytes payload = 7;</code>
5137      *
5138      * <pre>
5139      * TODO we are capping this at 8 bytes for now - need to change when we
5140      * support multi-frame responses
5141      * </pre>
5142      */
5143     public com.google.protobuf.ByteString getPayload() {
5144       return payload_;
5145     }
5146
5147     // optional double value = 8;
5148     public static final int VALUE_FIELD_NUMBER = 8;
5149     private double value_;
5150     /**
5151      * <code>optional double value = 8;</code>
5152      */
5153     public boolean hasValue() {
5154       return ((bitField0_ & 0x00000080) == 0x00000080);
5155     }
5156     /**
5157      * <code>optional double value = 8;</code>
5158      */
5159     public double getValue() {
5160       return value_;
5161     }
5162
5163     private void initFields() {
5164       bus_ = 0;
5165       messageId_ = 0;
5166       mode_ = 0;
5167       pid_ = 0;
5168       success_ = false;
5169       negativeResponseCode_ = 0;
5170       payload_ = com.google.protobuf.ByteString.EMPTY;
5171       value_ = 0D;
5172     }
5173     private byte memoizedIsInitialized = -1;
5174     public final boolean isInitialized() {
5175       byte isInitialized = memoizedIsInitialized;
5176       if (isInitialized != -1) return isInitialized == 1;
5177
5178       memoizedIsInitialized = 1;
5179       return true;
5180     }
5181
5182     public void writeTo(com.google.protobuf.CodedOutputStream output)
5183                         throws java.io.IOException {
5184       getSerializedSize();
5185       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5186         output.writeInt32(1, bus_);
5187       }
5188       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5189         output.writeUInt32(2, messageId_);
5190       }
5191       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5192         output.writeUInt32(3, mode_);
5193       }
5194       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5195         output.writeUInt32(4, pid_);
5196       }
5197       if (((bitField0_ & 0x00000010) == 0x00000010)) {
5198         output.writeBool(5, success_);
5199       }
5200       if (((bitField0_ & 0x00000020) == 0x00000020)) {
5201         output.writeUInt32(6, negativeResponseCode_);
5202       }
5203       if (((bitField0_ & 0x00000040) == 0x00000040)) {
5204         output.writeBytes(7, payload_);
5205       }
5206       if (((bitField0_ & 0x00000080) == 0x00000080)) {
5207         output.writeDouble(8, value_);
5208       }
5209       getUnknownFields().writeTo(output);
5210     }
5211
5212     private int memoizedSerializedSize = -1;
5213     public int getSerializedSize() {
5214       int size = memoizedSerializedSize;
5215       if (size != -1) return size;
5216
5217       size = 0;
5218       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5219         size += com.google.protobuf.CodedOutputStream
5220           .computeInt32Size(1, bus_);
5221       }
5222       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5223         size += com.google.protobuf.CodedOutputStream
5224           .computeUInt32Size(2, messageId_);
5225       }
5226       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5227         size += com.google.protobuf.CodedOutputStream
5228           .computeUInt32Size(3, mode_);
5229       }
5230       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5231         size += com.google.protobuf.CodedOutputStream
5232           .computeUInt32Size(4, pid_);
5233       }
5234       if (((bitField0_ & 0x00000010) == 0x00000010)) {
5235         size += com.google.protobuf.CodedOutputStream
5236           .computeBoolSize(5, success_);
5237       }
5238       if (((bitField0_ & 0x00000020) == 0x00000020)) {
5239         size += com.google.protobuf.CodedOutputStream
5240           .computeUInt32Size(6, negativeResponseCode_);
5241       }
5242       if (((bitField0_ & 0x00000040) == 0x00000040)) {
5243         size += com.google.protobuf.CodedOutputStream
5244           .computeBytesSize(7, payload_);
5245       }
5246       if (((bitField0_ & 0x00000080) == 0x00000080)) {
5247         size += com.google.protobuf.CodedOutputStream
5248           .computeDoubleSize(8, value_);
5249       }
5250       size += getUnknownFields().getSerializedSize();
5251       memoizedSerializedSize = size;
5252       return size;
5253     }
5254
5255     private static final long serialVersionUID = 0L;
5256     @java.lang.Override
5257     protected java.lang.Object writeReplace()
5258         throws java.io.ObjectStreamException {
5259       return super.writeReplace();
5260     }
5261
5262     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5263         com.google.protobuf.ByteString data)
5264         throws com.google.protobuf.InvalidProtocolBufferException {
5265       return PARSER.parseFrom(data);
5266     }
5267     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5268         com.google.protobuf.ByteString data,
5269         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5270         throws com.google.protobuf.InvalidProtocolBufferException {
5271       return PARSER.parseFrom(data, extensionRegistry);
5272     }
5273     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
5274         throws com.google.protobuf.InvalidProtocolBufferException {
5275       return PARSER.parseFrom(data);
5276     }
5277     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5278         byte[] data,
5279         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5280         throws com.google.protobuf.InvalidProtocolBufferException {
5281       return PARSER.parseFrom(data, extensionRegistry);
5282     }
5283     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
5284         throws java.io.IOException {
5285       return PARSER.parseFrom(input);
5286     }
5287     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5288         java.io.InputStream input,
5289         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5290         throws java.io.IOException {
5291       return PARSER.parseFrom(input, extensionRegistry);
5292     }
5293     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
5294         throws java.io.IOException {
5295       return PARSER.parseDelimitedFrom(input);
5296     }
5297     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
5298         java.io.InputStream input,
5299         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5300         throws java.io.IOException {
5301       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5302     }
5303     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5304         com.google.protobuf.CodedInputStream input)
5305         throws java.io.IOException {
5306       return PARSER.parseFrom(input);
5307     }
5308     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5309         com.google.protobuf.CodedInputStream input,
5310         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5311         throws java.io.IOException {
5312       return PARSER.parseFrom(input, extensionRegistry);
5313     }
5314
5315     public static Builder newBuilder() { return Builder.create(); }
5316     public Builder newBuilderForType() { return newBuilder(); }
5317     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
5318       return newBuilder().mergeFrom(prototype);
5319     }
5320     public Builder toBuilder() { return newBuilder(this); }
5321
5322     @java.lang.Override
5323     protected Builder newBuilderForType(
5324         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5325       Builder builder = new Builder(parent);
5326       return builder;
5327     }
5328     /**
5329      * Protobuf type {@code openxc.DiagnosticResponse}
5330      */
5331     public static final class Builder extends
5332         com.google.protobuf.GeneratedMessage.Builder<Builder>
5333        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
5334       public static final com.google.protobuf.Descriptors.Descriptor
5335           getDescriptor() {
5336         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5337       }
5338
5339       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5340           internalGetFieldAccessorTable() {
5341         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
5342             .ensureFieldAccessorsInitialized(
5343                 com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
5344       }
5345
5346       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
5347       private Builder() {
5348         maybeForceBuilderInitialization();
5349       }
5350
5351       private Builder(
5352           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5353         super(parent);
5354         maybeForceBuilderInitialization();
5355       }
5356       private void maybeForceBuilderInitialization() {
5357         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5358         }
5359       }
5360       private static Builder create() {
5361         return new Builder();
5362       }
5363
5364       public Builder clear() {
5365         super.clear();
5366         bus_ = 0;
5367         bitField0_ = (bitField0_ & ~0x00000001);
5368         messageId_ = 0;
5369         bitField0_ = (bitField0_ & ~0x00000002);
5370         mode_ = 0;
5371         bitField0_ = (bitField0_ & ~0x00000004);
5372         pid_ = 0;
5373         bitField0_ = (bitField0_ & ~0x00000008);
5374         success_ = false;
5375         bitField0_ = (bitField0_ & ~0x00000010);
5376         negativeResponseCode_ = 0;
5377         bitField0_ = (bitField0_ & ~0x00000020);
5378         payload_ = com.google.protobuf.ByteString.EMPTY;
5379         bitField0_ = (bitField0_ & ~0x00000040);
5380         value_ = 0D;
5381         bitField0_ = (bitField0_ & ~0x00000080);
5382         return this;
5383       }
5384
5385       public Builder clone() {
5386         return create().mergeFrom(buildPartial());
5387       }
5388
5389       public com.google.protobuf.Descriptors.Descriptor
5390           getDescriptorForType() {
5391         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5392       }
5393
5394       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
5395         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
5396       }
5397
5398       public com.openxc.BinaryMessages.DiagnosticResponse build() {
5399         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
5400         if (!result.isInitialized()) {
5401           throw newUninitializedMessageException(result);
5402         }
5403         return result;
5404       }
5405
5406       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
5407         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
5408         int from_bitField0_ = bitField0_;
5409         int to_bitField0_ = 0;
5410         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5411           to_bitField0_ |= 0x00000001;
5412         }
5413         result.bus_ = bus_;
5414         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5415           to_bitField0_ |= 0x00000002;
5416         }
5417         result.messageId_ = messageId_;
5418         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5419           to_bitField0_ |= 0x00000004;
5420         }
5421         result.mode_ = mode_;
5422         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
5423           to_bitField0_ |= 0x00000008;
5424         }
5425         result.pid_ = pid_;
5426         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
5427           to_bitField0_ |= 0x00000010;
5428         }
5429         result.success_ = success_;
5430         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
5431           to_bitField0_ |= 0x00000020;
5432         }
5433         result.negativeResponseCode_ = negativeResponseCode_;
5434         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
5435           to_bitField0_ |= 0x00000040;
5436         }
5437         result.payload_ = payload_;
5438         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
5439           to_bitField0_ |= 0x00000080;
5440         }
5441         result.value_ = value_;
5442         result.bitField0_ = to_bitField0_;
5443         onBuilt();
5444         return result;
5445       }
5446
5447       public Builder mergeFrom(com.google.protobuf.Message other) {
5448         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
5449           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
5450         } else {
5451           super.mergeFrom(other);
5452           return this;
5453         }
5454       }
5455
5456       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
5457         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
5458         if (other.hasBus()) {
5459           setBus(other.getBus());
5460         }
5461         if (other.hasMessageId()) {
5462           setMessageId(other.getMessageId());
5463         }
5464         if (other.hasMode()) {
5465           setMode(other.getMode());
5466         }
5467         if (other.hasPid()) {
5468           setPid(other.getPid());
5469         }
5470         if (other.hasSuccess()) {
5471           setSuccess(other.getSuccess());
5472         }
5473         if (other.hasNegativeResponseCode()) {
5474           setNegativeResponseCode(other.getNegativeResponseCode());
5475         }
5476         if (other.hasPayload()) {
5477           setPayload(other.getPayload());
5478         }
5479         if (other.hasValue()) {
5480           setValue(other.getValue());
5481         }
5482         this.mergeUnknownFields(other.getUnknownFields());
5483         return this;
5484       }
5485
5486       public final boolean isInitialized() {
5487         return true;
5488       }
5489
5490       public Builder mergeFrom(
5491           com.google.protobuf.CodedInputStream input,
5492           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5493           throws java.io.IOException {
5494         com.openxc.BinaryMessages.DiagnosticResponse parsedMessage = null;
5495         try {
5496           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5497         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5498           parsedMessage = (com.openxc.BinaryMessages.DiagnosticResponse) e.getUnfinishedMessage();
5499           throw e;
5500         } finally {
5501           if (parsedMessage != null) {
5502             mergeFrom(parsedMessage);
5503           }
5504         }
5505         return this;
5506       }
5507       private int bitField0_;
5508
5509       // optional int32 bus = 1;
5510       private int bus_ ;
5511       /**
5512        * <code>optional int32 bus = 1;</code>
5513        */
5514       public boolean hasBus() {
5515         return ((bitField0_ & 0x00000001) == 0x00000001);
5516       }
5517       /**
5518        * <code>optional int32 bus = 1;</code>
5519        */
5520       public int getBus() {
5521         return bus_;
5522       }
5523       /**
5524        * <code>optional int32 bus = 1;</code>
5525        */
5526       public Builder setBus(int value) {
5527         bitField0_ |= 0x00000001;
5528         bus_ = value;
5529         onChanged();
5530         return this;
5531       }
5532       /**
5533        * <code>optional int32 bus = 1;</code>
5534        */
5535       public Builder clearBus() {
5536         bitField0_ = (bitField0_ & ~0x00000001);
5537         bus_ = 0;
5538         onChanged();
5539         return this;
5540       }
5541
5542       // optional uint32 message_id = 2;
5543       private int messageId_ ;
5544       /**
5545        * <code>optional uint32 message_id = 2;</code>
5546        */
5547       public boolean hasMessageId() {
5548         return ((bitField0_ & 0x00000002) == 0x00000002);
5549       }
5550       /**
5551        * <code>optional uint32 message_id = 2;</code>
5552        */
5553       public int getMessageId() {
5554         return messageId_;
5555       }
5556       /**
5557        * <code>optional uint32 message_id = 2;</code>
5558        */
5559       public Builder setMessageId(int value) {
5560         bitField0_ |= 0x00000002;
5561         messageId_ = value;
5562         onChanged();
5563         return this;
5564       }
5565       /**
5566        * <code>optional uint32 message_id = 2;</code>
5567        */
5568       public Builder clearMessageId() {
5569         bitField0_ = (bitField0_ & ~0x00000002);
5570         messageId_ = 0;
5571         onChanged();
5572         return this;
5573       }
5574
5575       // optional uint32 mode = 3;
5576       private int mode_ ;
5577       /**
5578        * <code>optional uint32 mode = 3;</code>
5579        */
5580       public boolean hasMode() {
5581         return ((bitField0_ & 0x00000004) == 0x00000004);
5582       }
5583       /**
5584        * <code>optional uint32 mode = 3;</code>
5585        */
5586       public int getMode() {
5587         return mode_;
5588       }
5589       /**
5590        * <code>optional uint32 mode = 3;</code>
5591        */
5592       public Builder setMode(int value) {
5593         bitField0_ |= 0x00000004;
5594         mode_ = value;
5595         onChanged();
5596         return this;
5597       }
5598       /**
5599        * <code>optional uint32 mode = 3;</code>
5600        */
5601       public Builder clearMode() {
5602         bitField0_ = (bitField0_ & ~0x00000004);
5603         mode_ = 0;
5604         onChanged();
5605         return this;
5606       }
5607
5608       // optional uint32 pid = 4;
5609       private int pid_ ;
5610       /**
5611        * <code>optional uint32 pid = 4;</code>
5612        */
5613       public boolean hasPid() {
5614         return ((bitField0_ & 0x00000008) == 0x00000008);
5615       }
5616       /**
5617        * <code>optional uint32 pid = 4;</code>
5618        */
5619       public int getPid() {
5620         return pid_;
5621       }
5622       /**
5623        * <code>optional uint32 pid = 4;</code>
5624        */
5625       public Builder setPid(int value) {
5626         bitField0_ |= 0x00000008;
5627         pid_ = value;
5628         onChanged();
5629         return this;
5630       }
5631       /**
5632        * <code>optional uint32 pid = 4;</code>
5633        */
5634       public Builder clearPid() {
5635         bitField0_ = (bitField0_ & ~0x00000008);
5636         pid_ = 0;
5637         onChanged();
5638         return this;
5639       }
5640
5641       // optional bool success = 5;
5642       private boolean success_ ;
5643       /**
5644        * <code>optional bool success = 5;</code>
5645        */
5646       public boolean hasSuccess() {
5647         return ((bitField0_ & 0x00000010) == 0x00000010);
5648       }
5649       /**
5650        * <code>optional bool success = 5;</code>
5651        */
5652       public boolean getSuccess() {
5653         return success_;
5654       }
5655       /**
5656        * <code>optional bool success = 5;</code>
5657        */
5658       public Builder setSuccess(boolean value) {
5659         bitField0_ |= 0x00000010;
5660         success_ = value;
5661         onChanged();
5662         return this;
5663       }
5664       /**
5665        * <code>optional bool success = 5;</code>
5666        */
5667       public Builder clearSuccess() {
5668         bitField0_ = (bitField0_ & ~0x00000010);
5669         success_ = false;
5670         onChanged();
5671         return this;
5672       }
5673
5674       // optional uint32 negative_response_code = 6;
5675       private int negativeResponseCode_ ;
5676       /**
5677        * <code>optional uint32 negative_response_code = 6;</code>
5678        */
5679       public boolean hasNegativeResponseCode() {
5680         return ((bitField0_ & 0x00000020) == 0x00000020);
5681       }
5682       /**
5683        * <code>optional uint32 negative_response_code = 6;</code>
5684        */
5685       public int getNegativeResponseCode() {
5686         return negativeResponseCode_;
5687       }
5688       /**
5689        * <code>optional uint32 negative_response_code = 6;</code>
5690        */
5691       public Builder setNegativeResponseCode(int value) {
5692         bitField0_ |= 0x00000020;
5693         negativeResponseCode_ = value;
5694         onChanged();
5695         return this;
5696       }
5697       /**
5698        * <code>optional uint32 negative_response_code = 6;</code>
5699        */
5700       public Builder clearNegativeResponseCode() {
5701         bitField0_ = (bitField0_ & ~0x00000020);
5702         negativeResponseCode_ = 0;
5703         onChanged();
5704         return this;
5705       }
5706
5707       // optional bytes payload = 7;
5708       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
5709       /**
5710        * <code>optional bytes payload = 7;</code>
5711        *
5712        * <pre>
5713        * TODO we are capping this at 8 bytes for now - need to change when we
5714        * support multi-frame responses
5715        * </pre>
5716        */
5717       public boolean hasPayload() {
5718         return ((bitField0_ & 0x00000040) == 0x00000040);
5719       }
5720       /**
5721        * <code>optional bytes payload = 7;</code>
5722        *
5723        * <pre>
5724        * TODO we are capping this at 8 bytes for now - need to change when we
5725        * support multi-frame responses
5726        * </pre>
5727        */
5728       public com.google.protobuf.ByteString getPayload() {
5729         return payload_;
5730       }
5731       /**
5732        * <code>optional bytes payload = 7;</code>
5733        *
5734        * <pre>
5735        * TODO we are capping this at 8 bytes for now - need to change when we
5736        * support multi-frame responses
5737        * </pre>
5738        */
5739       public Builder setPayload(com.google.protobuf.ByteString value) {
5740         if (value == null) {
5741     throw new NullPointerException();
5742   }
5743   bitField0_ |= 0x00000040;
5744         payload_ = value;
5745         onChanged();
5746         return this;
5747       }
5748       /**
5749        * <code>optional bytes payload = 7;</code>
5750        *
5751        * <pre>
5752        * TODO we are capping this at 8 bytes for now - need to change when we
5753        * support multi-frame responses
5754        * </pre>
5755        */
5756       public Builder clearPayload() {
5757         bitField0_ = (bitField0_ & ~0x00000040);
5758         payload_ = getDefaultInstance().getPayload();
5759         onChanged();
5760         return this;
5761       }
5762
5763       // optional double value = 8;
5764       private double value_ ;
5765       /**
5766        * <code>optional double value = 8;</code>
5767        */
5768       public boolean hasValue() {
5769         return ((bitField0_ & 0x00000080) == 0x00000080);
5770       }
5771       /**
5772        * <code>optional double value = 8;</code>
5773        */
5774       public double getValue() {
5775         return value_;
5776       }
5777       /**
5778        * <code>optional double value = 8;</code>
5779        */
5780       public Builder setValue(double value) {
5781         bitField0_ |= 0x00000080;
5782         value_ = value;
5783         onChanged();
5784         return this;
5785       }
5786       /**
5787        * <code>optional double value = 8;</code>
5788        */
5789       public Builder clearValue() {
5790         bitField0_ = (bitField0_ & ~0x00000080);
5791         value_ = 0D;
5792         onChanged();
5793         return this;
5794       }
5795
5796       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
5797     }
5798
5799     static {
5800       defaultInstance = new DiagnosticResponse(true);
5801       defaultInstance.initFields();
5802     }
5803
5804     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
5805   }
5806
5807   public interface DynamicFieldOrBuilder
5808       extends com.google.protobuf.MessageOrBuilder {
5809
5810     // optional .openxc.DynamicField.Type type = 1;
5811     /**
5812      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5813      */
5814     boolean hasType();
5815     /**
5816      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5817      */
5818     com.openxc.BinaryMessages.DynamicField.Type getType();
5819
5820     // optional string string_value = 2;
5821     /**
5822      * <code>optional string string_value = 2;</code>
5823      */
5824     boolean hasStringValue();
5825     /**
5826      * <code>optional string string_value = 2;</code>
5827      */
5828     java.lang.String getStringValue();
5829     /**
5830      * <code>optional string string_value = 2;</code>
5831      */
5832     com.google.protobuf.ByteString
5833         getStringValueBytes();
5834
5835     // optional double numeric_value = 3;
5836     /**
5837      * <code>optional double numeric_value = 3;</code>
5838      */
5839     boolean hasNumericValue();
5840     /**
5841      * <code>optional double numeric_value = 3;</code>
5842      */
5843     double getNumericValue();
5844
5845     // optional bool boolean_value = 4;
5846     /**
5847      * <code>optional bool boolean_value = 4;</code>
5848      */
5849     boolean hasBooleanValue();
5850     /**
5851      * <code>optional bool boolean_value = 4;</code>
5852      */
5853     boolean getBooleanValue();
5854   }
5855   /**
5856    * Protobuf type {@code openxc.DynamicField}
5857    */
5858   public static final class DynamicField extends
5859       com.google.protobuf.GeneratedMessage
5860       implements DynamicFieldOrBuilder {
5861     // Use DynamicField.newBuilder() to construct.
5862     private DynamicField(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5863       super(builder);
5864       this.unknownFields = builder.getUnknownFields();
5865     }
5866     private DynamicField(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5867
5868     private static final DynamicField defaultInstance;
5869     public static DynamicField getDefaultInstance() {
5870       return defaultInstance;
5871     }
5872
5873     public DynamicField getDefaultInstanceForType() {
5874       return defaultInstance;
5875     }
5876
5877     private final com.google.protobuf.UnknownFieldSet unknownFields;
5878     @java.lang.Override
5879     public final com.google.protobuf.UnknownFieldSet
5880         getUnknownFields() {
5881       return this.unknownFields;
5882     }
5883     private DynamicField(
5884         com.google.protobuf.CodedInputStream input,
5885         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5886         throws com.google.protobuf.InvalidProtocolBufferException {
5887       initFields();
5888       int mutable_bitField0_ = 0;
5889       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5890           com.google.protobuf.UnknownFieldSet.newBuilder();
5891       try {
5892         boolean done = false;
5893         while (!done) {
5894           int tag = input.readTag();
5895           switch (tag) {
5896             case 0:
5897               done = true;
5898               break;
5899             default: {
5900               if (!parseUnknownField(input, unknownFields,
5901                                      extensionRegistry, tag)) {
5902                 done = true;
5903               }
5904               break;
5905             }
5906             case 8: {
5907               int rawValue = input.readEnum();
5908               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
5909               if (value == null) {
5910                 unknownFields.mergeVarintField(1, rawValue);
5911               } else {
5912                 bitField0_ |= 0x00000001;
5913                 type_ = value;
5914               }
5915               break;
5916             }
5917             case 18: {
5918               bitField0_ |= 0x00000002;
5919               stringValue_ = input.readBytes();
5920               break;
5921             }
5922             case 25: {
5923               bitField0_ |= 0x00000004;
5924               numericValue_ = input.readDouble();
5925               break;
5926             }
5927             case 32: {
5928               bitField0_ |= 0x00000008;
5929               booleanValue_ = input.readBool();
5930               break;
5931             }
5932           }
5933         }
5934       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5935         throw e.setUnfinishedMessage(this);
5936       } catch (java.io.IOException e) {
5937         throw new com.google.protobuf.InvalidProtocolBufferException(
5938             e.getMessage()).setUnfinishedMessage(this);
5939       } finally {
5940         this.unknownFields = unknownFields.build();
5941         makeExtensionsImmutable();
5942       }
5943     }
5944     public static final com.google.protobuf.Descriptors.Descriptor
5945         getDescriptor() {
5946       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
5947     }
5948
5949     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5950         internalGetFieldAccessorTable() {
5951       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
5952           .ensureFieldAccessorsInitialized(
5953               com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
5954     }
5955
5956     public static com.google.protobuf.Parser<DynamicField> PARSER =
5957         new com.google.protobuf.AbstractParser<DynamicField>() {
5958       public DynamicField parsePartialFrom(
5959           com.google.protobuf.CodedInputStream input,
5960           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5961           throws com.google.protobuf.InvalidProtocolBufferException {
5962         return new DynamicField(input, extensionRegistry);
5963       }
5964     };
5965
5966     @java.lang.Override
5967     public com.google.protobuf.Parser<DynamicField> getParserForType() {
5968       return PARSER;
5969     }
5970
5971     /**
5972      * Protobuf enum {@code openxc.DynamicField.Type}
5973      */
5974     public enum Type
5975         implements com.google.protobuf.ProtocolMessageEnum {
5976       /**
5977        * <code>STRING = 1;</code>
5978        */
5979       STRING(0, 1),
5980       /**
5981        * <code>NUM = 2;</code>
5982        */
5983       NUM(1, 2),
5984       /**
5985        * <code>BOOL = 3;</code>
5986        */
5987       BOOL(2, 3),
5988       ;
5989
5990       /**
5991        * <code>STRING = 1;</code>
5992        */
5993       public static final int STRING_VALUE = 1;
5994       /**
5995        * <code>NUM = 2;</code>
5996        */
5997       public static final int NUM_VALUE = 2;
5998       /**
5999        * <code>BOOL = 3;</code>
6000        */
6001       public static final int BOOL_VALUE = 3;
6002
6003
6004       public final int getNumber() { return value; }
6005
6006       public static Type valueOf(int value) {
6007         switch (value) {
6008           case 1: return STRING;
6009           case 2: return NUM;
6010           case 3: return BOOL;
6011           default: return null;
6012         }
6013       }
6014
6015       public static com.google.protobuf.Internal.EnumLiteMap<Type>
6016           internalGetValueMap() {
6017         return internalValueMap;
6018       }
6019       private static com.google.protobuf.Internal.EnumLiteMap<Type>
6020           internalValueMap =
6021             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
6022               public Type findValueByNumber(int number) {
6023                 return Type.valueOf(number);
6024               }
6025             };
6026
6027       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6028           getValueDescriptor() {
6029         return getDescriptor().getValues().get(index);
6030       }
6031       public final com.google.protobuf.Descriptors.EnumDescriptor
6032           getDescriptorForType() {
6033         return getDescriptor();
6034       }
6035       public static final com.google.protobuf.Descriptors.EnumDescriptor
6036           getDescriptor() {
6037         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
6038       }
6039
6040       private static final Type[] VALUES = values();
6041
6042       public static Type valueOf(
6043           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6044         if (desc.getType() != getDescriptor()) {
6045           throw new java.lang.IllegalArgumentException(
6046             "EnumValueDescriptor is not for this type.");
6047         }
6048         return VALUES[desc.getIndex()];
6049       }
6050
6051       private final int index;
6052       private final int value;
6053
6054       private Type(int index, int value) {
6055         this.index = index;
6056         this.value = value;
6057       }
6058
6059       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
6060     }
6061
6062     private int bitField0_;
6063     // optional .openxc.DynamicField.Type type = 1;
6064     public static final int TYPE_FIELD_NUMBER = 1;
6065     private com.openxc.BinaryMessages.DynamicField.Type type_;
6066     /**
6067      * <code>optional .openxc.DynamicField.Type type = 1;</code>
6068      */
6069     public boolean hasType() {
6070       return ((bitField0_ & 0x00000001) == 0x00000001);
6071     }
6072     /**
6073      * <code>optional .openxc.DynamicField.Type type = 1;</code>
6074      */
6075     public com.openxc.BinaryMessages.DynamicField.Type getType() {
6076       return type_;
6077     }
6078
6079     // optional string string_value = 2;
6080     public static final int STRING_VALUE_FIELD_NUMBER = 2;
6081     private java.lang.Object stringValue_;
6082     /**
6083      * <code>optional string string_value = 2;</code>
6084      */
6085     public boolean hasStringValue() {
6086       return ((bitField0_ & 0x00000002) == 0x00000002);
6087     }
6088     /**
6089      * <code>optional string string_value = 2;</code>
6090      */
6091     public java.lang.String getStringValue() {
6092       java.lang.Object ref = stringValue_;
6093       if (ref instanceof java.lang.String) {
6094         return (java.lang.String) ref;
6095       } else {
6096         com.google.protobuf.ByteString bs =
6097             (com.google.protobuf.ByteString) ref;
6098         java.lang.String s = bs.toStringUtf8();
6099         if (bs.isValidUtf8()) {
6100           stringValue_ = s;
6101         }
6102         return s;
6103       }
6104     }
6105     /**
6106      * <code>optional string string_value = 2;</code>
6107      */
6108     public com.google.protobuf.ByteString
6109         getStringValueBytes() {
6110       java.lang.Object ref = stringValue_;
6111       if (ref instanceof java.lang.String) {
6112         com.google.protobuf.ByteString b =
6113             com.google.protobuf.ByteString.copyFromUtf8(
6114                 (java.lang.String) ref);
6115         stringValue_ = b;
6116         return b;
6117       } else {
6118         return (com.google.protobuf.ByteString) ref;
6119       }
6120     }
6121
6122     // optional double numeric_value = 3;
6123     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
6124     private double numericValue_;
6125     /**
6126      * <code>optional double numeric_value = 3;</code>
6127      */
6128     public boolean hasNumericValue() {
6129       return ((bitField0_ & 0x00000004) == 0x00000004);
6130     }
6131     /**
6132      * <code>optional double numeric_value = 3;</code>
6133      */
6134     public double getNumericValue() {
6135       return numericValue_;
6136     }
6137
6138     // optional bool boolean_value = 4;
6139     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
6140     private boolean booleanValue_;
6141     /**
6142      * <code>optional bool boolean_value = 4;</code>
6143      */
6144     public boolean hasBooleanValue() {
6145       return ((bitField0_ & 0x00000008) == 0x00000008);
6146     }
6147     /**
6148      * <code>optional bool boolean_value = 4;</code>
6149      */
6150     public boolean getBooleanValue() {
6151       return booleanValue_;
6152     }
6153
6154     private void initFields() {
6155       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6156       stringValue_ = "";
6157       numericValue_ = 0D;
6158       booleanValue_ = false;
6159     }
6160     private byte memoizedIsInitialized = -1;
6161     public final boolean isInitialized() {
6162       byte isInitialized = memoizedIsInitialized;
6163       if (isInitialized != -1) return isInitialized == 1;
6164
6165       memoizedIsInitialized = 1;
6166       return true;
6167     }
6168
6169     public void writeTo(com.google.protobuf.CodedOutputStream output)
6170                         throws java.io.IOException {
6171       getSerializedSize();
6172       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6173         output.writeEnum(1, type_.getNumber());
6174       }
6175       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6176         output.writeBytes(2, getStringValueBytes());
6177       }
6178       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6179         output.writeDouble(3, numericValue_);
6180       }
6181       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6182         output.writeBool(4, booleanValue_);
6183       }
6184       getUnknownFields().writeTo(output);
6185     }
6186
6187     private int memoizedSerializedSize = -1;
6188     public int getSerializedSize() {
6189       int size = memoizedSerializedSize;
6190       if (size != -1) return size;
6191
6192       size = 0;
6193       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6194         size += com.google.protobuf.CodedOutputStream
6195           .computeEnumSize(1, type_.getNumber());
6196       }
6197       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6198         size += com.google.protobuf.CodedOutputStream
6199           .computeBytesSize(2, getStringValueBytes());
6200       }
6201       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6202         size += com.google.protobuf.CodedOutputStream
6203           .computeDoubleSize(3, numericValue_);
6204       }
6205       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6206         size += com.google.protobuf.CodedOutputStream
6207           .computeBoolSize(4, booleanValue_);
6208       }
6209       size += getUnknownFields().getSerializedSize();
6210       memoizedSerializedSize = size;
6211       return size;
6212     }
6213
6214     private static final long serialVersionUID = 0L;
6215     @java.lang.Override
6216     protected java.lang.Object writeReplace()
6217         throws java.io.ObjectStreamException {
6218       return super.writeReplace();
6219     }
6220
6221     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6222         com.google.protobuf.ByteString data)
6223         throws com.google.protobuf.InvalidProtocolBufferException {
6224       return PARSER.parseFrom(data);
6225     }
6226     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6227         com.google.protobuf.ByteString data,
6228         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6229         throws com.google.protobuf.InvalidProtocolBufferException {
6230       return PARSER.parseFrom(data, extensionRegistry);
6231     }
6232     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
6233         throws com.google.protobuf.InvalidProtocolBufferException {
6234       return PARSER.parseFrom(data);
6235     }
6236     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6237         byte[] data,
6238         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6239         throws com.google.protobuf.InvalidProtocolBufferException {
6240       return PARSER.parseFrom(data, extensionRegistry);
6241     }
6242     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
6243         throws java.io.IOException {
6244       return PARSER.parseFrom(input);
6245     }
6246     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6247         java.io.InputStream input,
6248         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6249         throws java.io.IOException {
6250       return PARSER.parseFrom(input, extensionRegistry);
6251     }
6252     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
6253         throws java.io.IOException {
6254       return PARSER.parseDelimitedFrom(input);
6255     }
6256     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
6257         java.io.InputStream input,
6258         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6259         throws java.io.IOException {
6260       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6261     }
6262     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6263         com.google.protobuf.CodedInputStream input)
6264         throws java.io.IOException {
6265       return PARSER.parseFrom(input);
6266     }
6267     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6268         com.google.protobuf.CodedInputStream input,
6269         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6270         throws java.io.IOException {
6271       return PARSER.parseFrom(input, extensionRegistry);
6272     }
6273
6274     public static Builder newBuilder() { return Builder.create(); }
6275     public Builder newBuilderForType() { return newBuilder(); }
6276     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
6277       return newBuilder().mergeFrom(prototype);
6278     }
6279     public Builder toBuilder() { return newBuilder(this); }
6280
6281     @java.lang.Override
6282     protected Builder newBuilderForType(
6283         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6284       Builder builder = new Builder(parent);
6285       return builder;
6286     }
6287     /**
6288      * Protobuf type {@code openxc.DynamicField}
6289      */
6290     public static final class Builder extends
6291         com.google.protobuf.GeneratedMessage.Builder<Builder>
6292        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
6293       public static final com.google.protobuf.Descriptors.Descriptor
6294           getDescriptor() {
6295         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
6296       }
6297
6298       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6299           internalGetFieldAccessorTable() {
6300         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
6301             .ensureFieldAccessorsInitialized(
6302                 com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
6303       }
6304
6305       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
6306       private Builder() {
6307         maybeForceBuilderInitialization();
6308       }
6309
6310       private Builder(
6311           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6312         super(parent);
6313         maybeForceBuilderInitialization();
6314       }
6315       private void maybeForceBuilderInitialization() {
6316         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6317         }
6318       }
6319       private static Builder create() {
6320         return new Builder();
6321       }
6322
6323       public Builder clear() {
6324         super.clear();
6325         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6326         bitField0_ = (bitField0_ & ~0x00000001);
6327         stringValue_ = "";
6328         bitField0_ = (bitField0_ & ~0x00000002);
6329         numericValue_ = 0D;
6330         bitField0_ = (bitField0_ & ~0x00000004);
6331         booleanValue_ = false;
6332         bitField0_ = (bitField0_ & ~0x00000008);
6333         return this;
6334       }
6335
6336       public Builder clone() {
6337         return create().mergeFrom(buildPartial());
6338       }
6339
6340       public com.google.protobuf.Descriptors.Descriptor
6341           getDescriptorForType() {
6342         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
6343       }
6344
6345       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
6346         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6347       }
6348
6349       public com.openxc.BinaryMessages.DynamicField build() {
6350         com.openxc.BinaryMessages.DynamicField result = buildPartial();
6351         if (!result.isInitialized()) {
6352           throw newUninitializedMessageException(result);
6353         }
6354         return result;
6355       }
6356
6357       public com.openxc.BinaryMessages.DynamicField buildPartial() {
6358         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
6359         int from_bitField0_ = bitField0_;
6360         int to_bitField0_ = 0;
6361         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6362           to_bitField0_ |= 0x00000001;
6363         }
6364         result.type_ = type_;
6365         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6366           to_bitField0_ |= 0x00000002;
6367         }
6368         result.stringValue_ = stringValue_;
6369         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6370           to_bitField0_ |= 0x00000004;
6371         }
6372         result.numericValue_ = numericValue_;
6373         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
6374           to_bitField0_ |= 0x00000008;
6375         }
6376         result.booleanValue_ = booleanValue_;
6377         result.bitField0_ = to_bitField0_;
6378         onBuilt();
6379         return result;
6380       }
6381
6382       public Builder mergeFrom(com.google.protobuf.Message other) {
6383         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
6384           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
6385         } else {
6386           super.mergeFrom(other);
6387           return this;
6388         }
6389       }
6390
6391       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
6392         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
6393         if (other.hasType()) {
6394           setType(other.getType());
6395         }
6396         if (other.hasStringValue()) {
6397           bitField0_ |= 0x00000002;
6398           stringValue_ = other.stringValue_;
6399           onChanged();
6400         }
6401         if (other.hasNumericValue()) {
6402           setNumericValue(other.getNumericValue());
6403         }
6404         if (other.hasBooleanValue()) {
6405           setBooleanValue(other.getBooleanValue());
6406         }
6407         this.mergeUnknownFields(other.getUnknownFields());
6408         return this;
6409       }
6410
6411       public final boolean isInitialized() {
6412         return true;
6413       }
6414
6415       public Builder mergeFrom(
6416           com.google.protobuf.CodedInputStream input,
6417           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6418           throws java.io.IOException {
6419         com.openxc.BinaryMessages.DynamicField parsedMessage = null;
6420         try {
6421           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6422         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6423           parsedMessage = (com.openxc.BinaryMessages.DynamicField) e.getUnfinishedMessage();
6424           throw e;
6425         } finally {
6426           if (parsedMessage != null) {
6427             mergeFrom(parsedMessage);
6428           }
6429         }
6430         return this;
6431       }
6432       private int bitField0_;
6433
6434       // optional .openxc.DynamicField.Type type = 1;
6435       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6436       /**
6437        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6438        */
6439       public boolean hasType() {
6440         return ((bitField0_ & 0x00000001) == 0x00000001);
6441       }
6442       /**
6443        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6444        */
6445       public com.openxc.BinaryMessages.DynamicField.Type getType() {
6446         return type_;
6447       }
6448       /**
6449        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6450        */
6451       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
6452         if (value == null) {
6453           throw new NullPointerException();
6454         }
6455         bitField0_ |= 0x00000001;
6456         type_ = value;
6457         onChanged();
6458         return this;
6459       }
6460       /**
6461        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6462        */
6463       public Builder clearType() {
6464         bitField0_ = (bitField0_ & ~0x00000001);
6465         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6466         onChanged();
6467         return this;
6468       }
6469
6470       // optional string string_value = 2;
6471       private java.lang.Object stringValue_ = "";
6472       /**
6473        * <code>optional string string_value = 2;</code>
6474        */
6475       public boolean hasStringValue() {
6476         return ((bitField0_ & 0x00000002) == 0x00000002);
6477       }
6478       /**
6479        * <code>optional string string_value = 2;</code>
6480        */
6481       public java.lang.String getStringValue() {
6482         java.lang.Object ref = stringValue_;
6483         if (!(ref instanceof java.lang.String)) {
6484           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6485               .toStringUtf8();
6486           stringValue_ = s;
6487           return s;
6488         } else {
6489           return (java.lang.String) ref;
6490         }
6491       }
6492       /**
6493        * <code>optional string string_value = 2;</code>
6494        */
6495       public com.google.protobuf.ByteString
6496           getStringValueBytes() {
6497         java.lang.Object ref = stringValue_;
6498         if (ref instanceof String) {
6499           com.google.protobuf.ByteString b =
6500               com.google.protobuf.ByteString.copyFromUtf8(
6501                   (java.lang.String) ref);
6502           stringValue_ = b;
6503           return b;
6504         } else {
6505           return (com.google.protobuf.ByteString) ref;
6506         }
6507       }
6508       /**
6509        * <code>optional string string_value = 2;</code>
6510        */
6511       public Builder setStringValue(
6512           java.lang.String value) {
6513         if (value == null) {
6514     throw new NullPointerException();
6515   }
6516   bitField0_ |= 0x00000002;
6517         stringValue_ = value;
6518         onChanged();
6519         return this;
6520       }
6521       /**
6522        * <code>optional string string_value = 2;</code>
6523        */
6524       public Builder clearStringValue() {
6525         bitField0_ = (bitField0_ & ~0x00000002);
6526         stringValue_ = getDefaultInstance().getStringValue();
6527         onChanged();
6528         return this;
6529       }
6530       /**
6531        * <code>optional string string_value = 2;</code>
6532        */
6533       public Builder setStringValueBytes(
6534           com.google.protobuf.ByteString value) {
6535         if (value == null) {
6536     throw new NullPointerException();
6537   }
6538   bitField0_ |= 0x00000002;
6539         stringValue_ = value;
6540         onChanged();
6541         return this;
6542       }
6543
6544       // optional double numeric_value = 3;
6545       private double numericValue_ ;
6546       /**
6547        * <code>optional double numeric_value = 3;</code>
6548        */
6549       public boolean hasNumericValue() {
6550         return ((bitField0_ & 0x00000004) == 0x00000004);
6551       }
6552       /**
6553        * <code>optional double numeric_value = 3;</code>
6554        */
6555       public double getNumericValue() {
6556         return numericValue_;
6557       }
6558       /**
6559        * <code>optional double numeric_value = 3;</code>
6560        */
6561       public Builder setNumericValue(double value) {
6562         bitField0_ |= 0x00000004;
6563         numericValue_ = value;
6564         onChanged();
6565         return this;
6566       }
6567       /**
6568        * <code>optional double numeric_value = 3;</code>
6569        */
6570       public Builder clearNumericValue() {
6571         bitField0_ = (bitField0_ & ~0x00000004);
6572         numericValue_ = 0D;
6573         onChanged();
6574         return this;
6575       }
6576
6577       // optional bool boolean_value = 4;
6578       private boolean booleanValue_ ;
6579       /**
6580        * <code>optional bool boolean_value = 4;</code>
6581        */
6582       public boolean hasBooleanValue() {
6583         return ((bitField0_ & 0x00000008) == 0x00000008);
6584       }
6585       /**
6586        * <code>optional bool boolean_value = 4;</code>
6587        */
6588       public boolean getBooleanValue() {
6589         return booleanValue_;
6590       }
6591       /**
6592        * <code>optional bool boolean_value = 4;</code>
6593        */
6594       public Builder setBooleanValue(boolean value) {
6595         bitField0_ |= 0x00000008;
6596         booleanValue_ = value;
6597         onChanged();
6598         return this;
6599       }
6600       /**
6601        * <code>optional bool boolean_value = 4;</code>
6602        */
6603       public Builder clearBooleanValue() {
6604         bitField0_ = (bitField0_ & ~0x00000008);
6605         booleanValue_ = false;
6606         onChanged();
6607         return this;
6608       }
6609
6610       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
6611     }
6612
6613     static {
6614       defaultInstance = new DynamicField(true);
6615       defaultInstance.initFields();
6616     }
6617
6618     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
6619   }
6620
6621   public interface TranslatedMessageOrBuilder
6622       extends com.google.protobuf.MessageOrBuilder {
6623
6624     // optional .openxc.TranslatedMessage.Type type = 1;
6625     /**
6626      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6627      */
6628     boolean hasType();
6629     /**
6630      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6631      */
6632     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
6633
6634     // optional string name = 2;
6635     /**
6636      * <code>optional string name = 2;</code>
6637      */
6638     boolean hasName();
6639     /**
6640      * <code>optional string name = 2;</code>
6641      */
6642     java.lang.String getName();
6643     /**
6644      * <code>optional string name = 2;</code>
6645      */
6646     com.google.protobuf.ByteString
6647         getNameBytes();
6648
6649     // optional .openxc.DynamicField value = 3;
6650     /**
6651      * <code>optional .openxc.DynamicField value = 3;</code>
6652      */
6653     boolean hasValue();
6654     /**
6655      * <code>optional .openxc.DynamicField value = 3;</code>
6656      */
6657     com.openxc.BinaryMessages.DynamicField getValue();
6658     /**
6659      * <code>optional .openxc.DynamicField value = 3;</code>
6660      */
6661     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
6662
6663     // optional .openxc.DynamicField event = 4;
6664     /**
6665      * <code>optional .openxc.DynamicField event = 4;</code>
6666      */
6667     boolean hasEvent();
6668     /**
6669      * <code>optional .openxc.DynamicField event = 4;</code>
6670      */
6671     com.openxc.BinaryMessages.DynamicField getEvent();
6672     /**
6673      * <code>optional .openxc.DynamicField event = 4;</code>
6674      */
6675     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
6676   }
6677   /**
6678    * Protobuf type {@code openxc.TranslatedMessage}
6679    */
6680   public static final class TranslatedMessage extends
6681       com.google.protobuf.GeneratedMessage
6682       implements TranslatedMessageOrBuilder {
6683     // Use TranslatedMessage.newBuilder() to construct.
6684     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6685       super(builder);
6686       this.unknownFields = builder.getUnknownFields();
6687     }
6688     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6689
6690     private static final TranslatedMessage defaultInstance;
6691     public static TranslatedMessage getDefaultInstance() {
6692       return defaultInstance;
6693     }
6694
6695     public TranslatedMessage getDefaultInstanceForType() {
6696       return defaultInstance;
6697     }
6698
6699     private final com.google.protobuf.UnknownFieldSet unknownFields;
6700     @java.lang.Override
6701     public final com.google.protobuf.UnknownFieldSet
6702         getUnknownFields() {
6703       return this.unknownFields;
6704     }
6705     private TranslatedMessage(
6706         com.google.protobuf.CodedInputStream input,
6707         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6708         throws com.google.protobuf.InvalidProtocolBufferException {
6709       initFields();
6710       int mutable_bitField0_ = 0;
6711       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6712           com.google.protobuf.UnknownFieldSet.newBuilder();
6713       try {
6714         boolean done = false;
6715         while (!done) {
6716           int tag = input.readTag();
6717           switch (tag) {
6718             case 0:
6719               done = true;
6720               break;
6721             default: {
6722               if (!parseUnknownField(input, unknownFields,
6723                                      extensionRegistry, tag)) {
6724                 done = true;
6725               }
6726               break;
6727             }
6728             case 8: {
6729               int rawValue = input.readEnum();
6730               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
6731               if (value == null) {
6732                 unknownFields.mergeVarintField(1, rawValue);
6733               } else {
6734                 bitField0_ |= 0x00000001;
6735                 type_ = value;
6736               }
6737               break;
6738             }
6739             case 18: {
6740               bitField0_ |= 0x00000002;
6741               name_ = input.readBytes();
6742               break;
6743             }
6744             case 26: {
6745               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
6746               if (((bitField0_ & 0x00000004) == 0x00000004)) {
6747                 subBuilder = value_.toBuilder();
6748               }
6749               value_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
6750               if (subBuilder != null) {
6751                 subBuilder.mergeFrom(value_);
6752                 value_ = subBuilder.buildPartial();
6753               }
6754               bitField0_ |= 0x00000004;
6755               break;
6756             }
6757             case 34: {
6758               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
6759               if (((bitField0_ & 0x00000008) == 0x00000008)) {
6760                 subBuilder = event_.toBuilder();
6761               }
6762               event_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
6763               if (subBuilder != null) {
6764                 subBuilder.mergeFrom(event_);
6765                 event_ = subBuilder.buildPartial();
6766               }
6767               bitField0_ |= 0x00000008;
6768               break;
6769             }
6770           }
6771         }
6772       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6773         throw e.setUnfinishedMessage(this);
6774       } catch (java.io.IOException e) {
6775         throw new com.google.protobuf.InvalidProtocolBufferException(
6776             e.getMessage()).setUnfinishedMessage(this);
6777       } finally {
6778         this.unknownFields = unknownFields.build();
6779         makeExtensionsImmutable();
6780       }
6781     }
6782     public static final com.google.protobuf.Descriptors.Descriptor
6783         getDescriptor() {
6784       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
6785     }
6786
6787     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6788         internalGetFieldAccessorTable() {
6789       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
6790           .ensureFieldAccessorsInitialized(
6791               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
6792     }
6793
6794     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
6795         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
6796       public TranslatedMessage parsePartialFrom(
6797           com.google.protobuf.CodedInputStream input,
6798           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6799           throws com.google.protobuf.InvalidProtocolBufferException {
6800         return new TranslatedMessage(input, extensionRegistry);
6801       }
6802     };
6803
6804     @java.lang.Override
6805     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
6806       return PARSER;
6807     }
6808
6809     /**
6810      * Protobuf enum {@code openxc.TranslatedMessage.Type}
6811      */
6812     public enum Type
6813         implements com.google.protobuf.ProtocolMessageEnum {
6814       /**
6815        * <code>STRING = 1;</code>
6816        */
6817       STRING(0, 1),
6818       /**
6819        * <code>NUM = 2;</code>
6820        */
6821       NUM(1, 2),
6822       /**
6823        * <code>BOOL = 3;</code>
6824        */
6825       BOOL(2, 3),
6826       /**
6827        * <code>EVENTED_STRING = 4;</code>
6828        */
6829       EVENTED_STRING(3, 4),
6830       /**
6831        * <code>EVENTED_NUM = 5;</code>
6832        */
6833       EVENTED_NUM(4, 5),
6834       /**
6835        * <code>EVENTED_BOOL = 6;</code>
6836        */
6837       EVENTED_BOOL(5, 6),
6838       ;
6839
6840       /**
6841        * <code>STRING = 1;</code>
6842        */
6843       public static final int STRING_VALUE = 1;
6844       /**
6845        * <code>NUM = 2;</code>
6846        */
6847       public static final int NUM_VALUE = 2;
6848       /**
6849        * <code>BOOL = 3;</code>
6850        */
6851       public static final int BOOL_VALUE = 3;
6852       /**
6853        * <code>EVENTED_STRING = 4;</code>
6854        */
6855       public static final int EVENTED_STRING_VALUE = 4;
6856       /**
6857        * <code>EVENTED_NUM = 5;</code>
6858        */
6859       public static final int EVENTED_NUM_VALUE = 5;
6860       /**
6861        * <code>EVENTED_BOOL = 6;</code>
6862        */
6863       public static final int EVENTED_BOOL_VALUE = 6;
6864
6865
6866       public final int getNumber() { return value; }
6867
6868       public static Type valueOf(int value) {
6869         switch (value) {
6870           case 1: return STRING;
6871           case 2: return NUM;
6872           case 3: return BOOL;
6873           case 4: return EVENTED_STRING;
6874           case 5: return EVENTED_NUM;
6875           case 6: return EVENTED_BOOL;
6876           default: return null;
6877         }
6878       }
6879
6880       public static com.google.protobuf.Internal.EnumLiteMap<Type>
6881           internalGetValueMap() {
6882         return internalValueMap;
6883       }
6884       private static com.google.protobuf.Internal.EnumLiteMap<Type>
6885           internalValueMap =
6886             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
6887               public Type findValueByNumber(int number) {
6888                 return Type.valueOf(number);
6889               }
6890             };
6891
6892       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6893           getValueDescriptor() {
6894         return getDescriptor().getValues().get(index);
6895       }
6896       public final com.google.protobuf.Descriptors.EnumDescriptor
6897           getDescriptorForType() {
6898         return getDescriptor();
6899       }
6900       public static final com.google.protobuf.Descriptors.EnumDescriptor
6901           getDescriptor() {
6902         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
6903       }
6904
6905       private static final Type[] VALUES = values();
6906
6907       public static Type valueOf(
6908           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6909         if (desc.getType() != getDescriptor()) {
6910           throw new java.lang.IllegalArgumentException(
6911             "EnumValueDescriptor is not for this type.");
6912         }
6913         return VALUES[desc.getIndex()];
6914       }
6915
6916       private final int index;
6917       private final int value;
6918
6919       private Type(int index, int value) {
6920         this.index = index;
6921         this.value = value;
6922       }
6923
6924       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
6925     }
6926
6927     private int bitField0_;
6928     // optional .openxc.TranslatedMessage.Type type = 1;
6929     public static final int TYPE_FIELD_NUMBER = 1;
6930     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
6931     /**
6932      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6933      */
6934     public boolean hasType() {
6935       return ((bitField0_ & 0x00000001) == 0x00000001);
6936     }
6937     /**
6938      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6939      */
6940     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
6941       return type_;
6942     }
6943
6944     // optional string name = 2;
6945     public static final int NAME_FIELD_NUMBER = 2;
6946     private java.lang.Object name_;
6947     /**
6948      * <code>optional string name = 2;</code>
6949      */
6950     public boolean hasName() {
6951       return ((bitField0_ & 0x00000002) == 0x00000002);
6952     }
6953     /**
6954      * <code>optional string name = 2;</code>
6955      */
6956     public java.lang.String getName() {
6957       java.lang.Object ref = name_;
6958       if (ref instanceof java.lang.String) {
6959         return (java.lang.String) ref;
6960       } else {
6961         com.google.protobuf.ByteString bs =
6962             (com.google.protobuf.ByteString) ref;
6963         java.lang.String s = bs.toStringUtf8();
6964         if (bs.isValidUtf8()) {
6965           name_ = s;
6966         }
6967         return s;
6968       }
6969     }
6970     /**
6971      * <code>optional string name = 2;</code>
6972      */
6973     public com.google.protobuf.ByteString
6974         getNameBytes() {
6975       java.lang.Object ref = name_;
6976       if (ref instanceof java.lang.String) {
6977         com.google.protobuf.ByteString b =
6978             com.google.protobuf.ByteString.copyFromUtf8(
6979                 (java.lang.String) ref);
6980         name_ = b;
6981         return b;
6982       } else {
6983         return (com.google.protobuf.ByteString) ref;
6984       }
6985     }
6986
6987     // optional .openxc.DynamicField value = 3;
6988     public static final int VALUE_FIELD_NUMBER = 3;
6989     private com.openxc.BinaryMessages.DynamicField value_;
6990     /**
6991      * <code>optional .openxc.DynamicField value = 3;</code>
6992      */
6993     public boolean hasValue() {
6994       return ((bitField0_ & 0x00000004) == 0x00000004);
6995     }
6996     /**
6997      * <code>optional .openxc.DynamicField value = 3;</code>
6998      */
6999     public com.openxc.BinaryMessages.DynamicField getValue() {
7000       return value_;
7001     }
7002     /**
7003      * <code>optional .openxc.DynamicField value = 3;</code>
7004      */
7005     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
7006       return value_;
7007     }
7008
7009     // optional .openxc.DynamicField event = 4;
7010     public static final int EVENT_FIELD_NUMBER = 4;
7011     private com.openxc.BinaryMessages.DynamicField event_;
7012     /**
7013      * <code>optional .openxc.DynamicField event = 4;</code>
7014      */
7015     public boolean hasEvent() {
7016       return ((bitField0_ & 0x00000008) == 0x00000008);
7017     }
7018     /**
7019      * <code>optional .openxc.DynamicField event = 4;</code>
7020      */
7021     public com.openxc.BinaryMessages.DynamicField getEvent() {
7022       return event_;
7023     }
7024     /**
7025      * <code>optional .openxc.DynamicField event = 4;</code>
7026      */
7027     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
7028       return event_;
7029     }
7030
7031     private void initFields() {
7032       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7033       name_ = "";
7034       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7035       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7036     }
7037     private byte memoizedIsInitialized = -1;
7038     public final boolean isInitialized() {
7039       byte isInitialized = memoizedIsInitialized;
7040       if (isInitialized != -1) return isInitialized == 1;
7041
7042       memoizedIsInitialized = 1;
7043       return true;
7044     }
7045
7046     public void writeTo(com.google.protobuf.CodedOutputStream output)
7047                         throws java.io.IOException {
7048       getSerializedSize();
7049       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7050         output.writeEnum(1, type_.getNumber());
7051       }
7052       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7053         output.writeBytes(2, getNameBytes());
7054       }
7055       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7056         output.writeMessage(3, value_);
7057       }
7058       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7059         output.writeMessage(4, event_);
7060       }
7061       getUnknownFields().writeTo(output);
7062     }
7063
7064     private int memoizedSerializedSize = -1;
7065     public int getSerializedSize() {
7066       int size = memoizedSerializedSize;
7067       if (size != -1) return size;
7068
7069       size = 0;
7070       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7071         size += com.google.protobuf.CodedOutputStream
7072           .computeEnumSize(1, type_.getNumber());
7073       }
7074       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7075         size += com.google.protobuf.CodedOutputStream
7076           .computeBytesSize(2, getNameBytes());
7077       }
7078       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7079         size += com.google.protobuf.CodedOutputStream
7080           .computeMessageSize(3, value_);
7081       }
7082       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7083         size += com.google.protobuf.CodedOutputStream
7084           .computeMessageSize(4, event_);
7085       }
7086       size += getUnknownFields().getSerializedSize();
7087       memoizedSerializedSize = size;
7088       return size;
7089     }
7090
7091     private static final long serialVersionUID = 0L;
7092     @java.lang.Override
7093     protected java.lang.Object writeReplace()
7094         throws java.io.ObjectStreamException {
7095       return super.writeReplace();
7096     }
7097
7098     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7099         com.google.protobuf.ByteString data)
7100         throws com.google.protobuf.InvalidProtocolBufferException {
7101       return PARSER.parseFrom(data);
7102     }
7103     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7104         com.google.protobuf.ByteString data,
7105         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7106         throws com.google.protobuf.InvalidProtocolBufferException {
7107       return PARSER.parseFrom(data, extensionRegistry);
7108     }
7109     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
7110         throws com.google.protobuf.InvalidProtocolBufferException {
7111       return PARSER.parseFrom(data);
7112     }
7113     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7114         byte[] data,
7115         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7116         throws com.google.protobuf.InvalidProtocolBufferException {
7117       return PARSER.parseFrom(data, extensionRegistry);
7118     }
7119     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
7120         throws java.io.IOException {
7121       return PARSER.parseFrom(input);
7122     }
7123     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7124         java.io.InputStream input,
7125         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7126         throws java.io.IOException {
7127       return PARSER.parseFrom(input, extensionRegistry);
7128     }
7129     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
7130         throws java.io.IOException {
7131       return PARSER.parseDelimitedFrom(input);
7132     }
7133     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
7134         java.io.InputStream input,
7135         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7136         throws java.io.IOException {
7137       return PARSER.parseDelimitedFrom(input, extensionRegistry);
7138     }
7139     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7140         com.google.protobuf.CodedInputStream input)
7141         throws java.io.IOException {
7142       return PARSER.parseFrom(input);
7143     }
7144     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7145         com.google.protobuf.CodedInputStream input,
7146         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7147         throws java.io.IOException {
7148       return PARSER.parseFrom(input, extensionRegistry);
7149     }
7150
7151     public static Builder newBuilder() { return Builder.create(); }
7152     public Builder newBuilderForType() { return newBuilder(); }
7153     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
7154       return newBuilder().mergeFrom(prototype);
7155     }
7156     public Builder toBuilder() { return newBuilder(this); }
7157
7158     @java.lang.Override
7159     protected Builder newBuilderForType(
7160         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7161       Builder builder = new Builder(parent);
7162       return builder;
7163     }
7164     /**
7165      * Protobuf type {@code openxc.TranslatedMessage}
7166      */
7167     public static final class Builder extends
7168         com.google.protobuf.GeneratedMessage.Builder<Builder>
7169        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
7170       public static final com.google.protobuf.Descriptors.Descriptor
7171           getDescriptor() {
7172         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
7173       }
7174
7175       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7176           internalGetFieldAccessorTable() {
7177         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
7178             .ensureFieldAccessorsInitialized(
7179                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
7180       }
7181
7182       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
7183       private Builder() {
7184         maybeForceBuilderInitialization();
7185       }
7186
7187       private Builder(
7188           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7189         super(parent);
7190         maybeForceBuilderInitialization();
7191       }
7192       private void maybeForceBuilderInitialization() {
7193         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7194           getValueFieldBuilder();
7195           getEventFieldBuilder();
7196         }
7197       }
7198       private static Builder create() {
7199         return new Builder();
7200       }
7201
7202       public Builder clear() {
7203         super.clear();
7204         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7205         bitField0_ = (bitField0_ & ~0x00000001);
7206         name_ = "";
7207         bitField0_ = (bitField0_ & ~0x00000002);
7208         if (valueBuilder_ == null) {
7209           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7210         } else {
7211           valueBuilder_.clear();
7212         }
7213         bitField0_ = (bitField0_ & ~0x00000004);
7214         if (eventBuilder_ == null) {
7215           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7216         } else {
7217           eventBuilder_.clear();
7218         }
7219         bitField0_ = (bitField0_ & ~0x00000008);
7220         return this;
7221       }
7222
7223       public Builder clone() {
7224         return create().mergeFrom(buildPartial());
7225       }
7226
7227       public com.google.protobuf.Descriptors.Descriptor
7228           getDescriptorForType() {
7229         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
7230       }
7231
7232       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
7233         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
7234       }
7235
7236       public com.openxc.BinaryMessages.TranslatedMessage build() {
7237         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
7238         if (!result.isInitialized()) {
7239           throw newUninitializedMessageException(result);
7240         }
7241         return result;
7242       }
7243
7244       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
7245         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
7246         int from_bitField0_ = bitField0_;
7247         int to_bitField0_ = 0;
7248         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7249           to_bitField0_ |= 0x00000001;
7250         }
7251         result.type_ = type_;
7252         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7253           to_bitField0_ |= 0x00000002;
7254         }
7255         result.name_ = name_;
7256         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
7257           to_bitField0_ |= 0x00000004;
7258         }
7259         if (valueBuilder_ == null) {
7260           result.value_ = value_;
7261         } else {
7262           result.value_ = valueBuilder_.build();
7263         }
7264         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
7265           to_bitField0_ |= 0x00000008;
7266         }
7267         if (eventBuilder_ == null) {
7268           result.event_ = event_;
7269         } else {
7270           result.event_ = eventBuilder_.build();
7271         }
7272         result.bitField0_ = to_bitField0_;
7273         onBuilt();
7274         return result;
7275       }
7276
7277       public Builder mergeFrom(com.google.protobuf.Message other) {
7278         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
7279           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
7280         } else {
7281           super.mergeFrom(other);
7282           return this;
7283         }
7284       }
7285
7286       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
7287         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
7288         if (other.hasType()) {
7289           setType(other.getType());
7290         }
7291         if (other.hasName()) {
7292           bitField0_ |= 0x00000002;
7293           name_ = other.name_;
7294           onChanged();
7295         }
7296         if (other.hasValue()) {
7297           mergeValue(other.getValue());
7298         }
7299         if (other.hasEvent()) {
7300           mergeEvent(other.getEvent());
7301         }
7302         this.mergeUnknownFields(other.getUnknownFields());
7303         return this;
7304       }
7305
7306       public final boolean isInitialized() {
7307         return true;
7308       }
7309
7310       public Builder mergeFrom(
7311           com.google.protobuf.CodedInputStream input,
7312           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7313           throws java.io.IOException {
7314         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
7315         try {
7316           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
7317         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7318           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
7319           throw e;
7320         } finally {
7321           if (parsedMessage != null) {
7322             mergeFrom(parsedMessage);
7323           }
7324         }
7325         return this;
7326       }
7327       private int bitField0_;
7328
7329       // optional .openxc.TranslatedMessage.Type type = 1;
7330       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7331       /**
7332        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7333        */
7334       public boolean hasType() {
7335         return ((bitField0_ & 0x00000001) == 0x00000001);
7336       }
7337       /**
7338        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7339        */
7340       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
7341         return type_;
7342       }
7343       /**
7344        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7345        */
7346       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
7347         if (value == null) {
7348           throw new NullPointerException();
7349         }
7350         bitField0_ |= 0x00000001;
7351         type_ = value;
7352         onChanged();
7353         return this;
7354       }
7355       /**
7356        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7357        */
7358       public Builder clearType() {
7359         bitField0_ = (bitField0_ & ~0x00000001);
7360         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7361         onChanged();
7362         return this;
7363       }
7364
7365       // optional string name = 2;
7366       private java.lang.Object name_ = "";
7367       /**
7368        * <code>optional string name = 2;</code>
7369        */
7370       public boolean hasName() {
7371         return ((bitField0_ & 0x00000002) == 0x00000002);
7372       }
7373       /**
7374        * <code>optional string name = 2;</code>
7375        */
7376       public java.lang.String getName() {
7377         java.lang.Object ref = name_;
7378         if (!(ref instanceof java.lang.String)) {
7379           java.lang.String s = ((com.google.protobuf.ByteString) ref)
7380               .toStringUtf8();
7381           name_ = s;
7382           return s;
7383         } else {
7384           return (java.lang.String) ref;
7385         }
7386       }
7387       /**
7388        * <code>optional string name = 2;</code>
7389        */
7390       public com.google.protobuf.ByteString
7391           getNameBytes() {
7392         java.lang.Object ref = name_;
7393         if (ref instanceof String) {
7394           com.google.protobuf.ByteString b =
7395               com.google.protobuf.ByteString.copyFromUtf8(
7396                   (java.lang.String) ref);
7397           name_ = b;
7398           return b;
7399         } else {
7400           return (com.google.protobuf.ByteString) ref;
7401         }
7402       }
7403       /**
7404        * <code>optional string name = 2;</code>
7405        */
7406       public Builder setName(
7407           java.lang.String value) {
7408         if (value == null) {
7409     throw new NullPointerException();
7410   }
7411   bitField0_ |= 0x00000002;
7412         name_ = value;
7413         onChanged();
7414         return this;
7415       }
7416       /**
7417        * <code>optional string name = 2;</code>
7418        */
7419       public Builder clearName() {
7420         bitField0_ = (bitField0_ & ~0x00000002);
7421         name_ = getDefaultInstance().getName();
7422         onChanged();
7423         return this;
7424       }
7425       /**
7426        * <code>optional string name = 2;</code>
7427        */
7428       public Builder setNameBytes(
7429           com.google.protobuf.ByteString value) {
7430         if (value == null) {
7431     throw new NullPointerException();
7432   }
7433   bitField0_ |= 0x00000002;
7434         name_ = value;
7435         onChanged();
7436         return this;
7437       }
7438
7439       // optional .openxc.DynamicField value = 3;
7440       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7441       private com.google.protobuf.SingleFieldBuilder<
7442           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
7443       /**
7444        * <code>optional .openxc.DynamicField value = 3;</code>
7445        */
7446       public boolean hasValue() {
7447         return ((bitField0_ & 0x00000004) == 0x00000004);
7448       }
7449       /**
7450        * <code>optional .openxc.DynamicField value = 3;</code>
7451        */
7452       public com.openxc.BinaryMessages.DynamicField getValue() {
7453         if (valueBuilder_ == null) {
7454           return value_;
7455         } else {
7456           return valueBuilder_.getMessage();
7457         }
7458       }
7459       /**
7460        * <code>optional .openxc.DynamicField value = 3;</code>
7461        */
7462       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
7463         if (valueBuilder_ == null) {
7464           if (value == null) {
7465             throw new NullPointerException();
7466           }
7467           value_ = value;
7468           onChanged();
7469         } else {
7470           valueBuilder_.setMessage(value);
7471         }
7472         bitField0_ |= 0x00000004;
7473         return this;
7474       }
7475       /**
7476        * <code>optional .openxc.DynamicField value = 3;</code>
7477        */
7478       public Builder setValue(
7479           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
7480         if (valueBuilder_ == null) {
7481           value_ = builderForValue.build();
7482           onChanged();
7483         } else {
7484           valueBuilder_.setMessage(builderForValue.build());
7485         }
7486         bitField0_ |= 0x00000004;
7487         return this;
7488       }
7489       /**
7490        * <code>optional .openxc.DynamicField value = 3;</code>
7491        */
7492       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
7493         if (valueBuilder_ == null) {
7494           if (((bitField0_ & 0x00000004) == 0x00000004) &&
7495               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
7496             value_ =
7497               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
7498           } else {
7499             value_ = value;
7500           }
7501           onChanged();
7502         } else {
7503           valueBuilder_.mergeFrom(value);
7504         }
7505         bitField0_ |= 0x00000004;
7506         return this;
7507       }
7508       /**
7509        * <code>optional .openxc.DynamicField value = 3;</code>
7510        */
7511       public Builder clearValue() {
7512         if (valueBuilder_ == null) {
7513           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7514           onChanged();
7515         } else {
7516           valueBuilder_.clear();
7517         }
7518         bitField0_ = (bitField0_ & ~0x00000004);
7519         return this;
7520       }
7521       /**
7522        * <code>optional .openxc.DynamicField value = 3;</code>
7523        */
7524       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
7525         bitField0_ |= 0x00000004;
7526         onChanged();
7527         return getValueFieldBuilder().getBuilder();
7528       }
7529       /**
7530        * <code>optional .openxc.DynamicField value = 3;</code>
7531        */
7532       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
7533         if (valueBuilder_ != null) {
7534           return valueBuilder_.getMessageOrBuilder();
7535         } else {
7536           return value_;
7537         }
7538       }
7539       /**
7540        * <code>optional .openxc.DynamicField value = 3;</code>
7541        */
7542       private com.google.protobuf.SingleFieldBuilder<
7543           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
7544           getValueFieldBuilder() {
7545         if (valueBuilder_ == null) {
7546           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7547               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
7548                   value_,
7549                   getParentForChildren(),
7550                   isClean());
7551           value_ = null;
7552         }
7553         return valueBuilder_;
7554       }
7555
7556       // optional .openxc.DynamicField event = 4;
7557       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7558       private com.google.protobuf.SingleFieldBuilder<
7559           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
7560       /**
7561        * <code>optional .openxc.DynamicField event = 4;</code>
7562        */
7563       public boolean hasEvent() {
7564         return ((bitField0_ & 0x00000008) == 0x00000008);
7565       }
7566       /**
7567        * <code>optional .openxc.DynamicField event = 4;</code>
7568        */
7569       public com.openxc.BinaryMessages.DynamicField getEvent() {
7570         if (eventBuilder_ == null) {
7571           return event_;
7572         } else {
7573           return eventBuilder_.getMessage();
7574         }
7575       }
7576       /**
7577        * <code>optional .openxc.DynamicField event = 4;</code>
7578        */
7579       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
7580         if (eventBuilder_ == null) {
7581           if (value == null) {
7582             throw new NullPointerException();
7583           }
7584           event_ = value;
7585           onChanged();
7586         } else {
7587           eventBuilder_.setMessage(value);
7588         }
7589         bitField0_ |= 0x00000008;
7590         return this;
7591       }
7592       /**
7593        * <code>optional .openxc.DynamicField event = 4;</code>
7594        */
7595       public Builder setEvent(
7596           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
7597         if (eventBuilder_ == null) {
7598           event_ = builderForValue.build();
7599           onChanged();
7600         } else {
7601           eventBuilder_.setMessage(builderForValue.build());
7602         }
7603         bitField0_ |= 0x00000008;
7604         return this;
7605       }
7606       /**
7607        * <code>optional .openxc.DynamicField event = 4;</code>
7608        */
7609       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
7610         if (eventBuilder_ == null) {
7611           if (((bitField0_ & 0x00000008) == 0x00000008) &&
7612               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
7613             event_ =
7614               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
7615           } else {
7616             event_ = value;
7617           }
7618           onChanged();
7619         } else {
7620           eventBuilder_.mergeFrom(value);
7621         }
7622         bitField0_ |= 0x00000008;
7623         return this;
7624       }
7625       /**
7626        * <code>optional .openxc.DynamicField event = 4;</code>
7627        */
7628       public Builder clearEvent() {
7629         if (eventBuilder_ == null) {
7630           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7631           onChanged();
7632         } else {
7633           eventBuilder_.clear();
7634         }
7635         bitField0_ = (bitField0_ & ~0x00000008);
7636         return this;
7637       }
7638       /**
7639        * <code>optional .openxc.DynamicField event = 4;</code>
7640        */
7641       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
7642         bitField0_ |= 0x00000008;
7643         onChanged();
7644         return getEventFieldBuilder().getBuilder();
7645       }
7646       /**
7647        * <code>optional .openxc.DynamicField event = 4;</code>
7648        */
7649       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
7650         if (eventBuilder_ != null) {
7651           return eventBuilder_.getMessageOrBuilder();
7652         } else {
7653           return event_;
7654         }
7655       }
7656       /**
7657        * <code>optional .openxc.DynamicField event = 4;</code>
7658        */
7659       private com.google.protobuf.SingleFieldBuilder<
7660           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
7661           getEventFieldBuilder() {
7662         if (eventBuilder_ == null) {
7663           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7664               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
7665                   event_,
7666                   getParentForChildren(),
7667                   isClean());
7668           event_ = null;
7669         }
7670         return eventBuilder_;
7671       }
7672
7673       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
7674     }
7675
7676     static {
7677       defaultInstance = new TranslatedMessage(true);
7678       defaultInstance.initFields();
7679     }
7680
7681     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
7682   }
7683
7684   private static com.google.protobuf.Descriptors.Descriptor
7685     internal_static_openxc_VehicleMessage_descriptor;
7686   private static
7687     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7688       internal_static_openxc_VehicleMessage_fieldAccessorTable;
7689   private static com.google.protobuf.Descriptors.Descriptor
7690     internal_static_openxc_RawMessage_descriptor;
7691   private static
7692     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7693       internal_static_openxc_RawMessage_fieldAccessorTable;
7694   private static com.google.protobuf.Descriptors.Descriptor
7695     internal_static_openxc_ControlCommand_descriptor;
7696   private static
7697     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7698       internal_static_openxc_ControlCommand_fieldAccessorTable;
7699   private static com.google.protobuf.Descriptors.Descriptor
7700     internal_static_openxc_CommandResponse_descriptor;
7701   private static
7702     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7703       internal_static_openxc_CommandResponse_fieldAccessorTable;
7704   private static com.google.protobuf.Descriptors.Descriptor
7705     internal_static_openxc_DiagnosticRequest_descriptor;
7706   private static
7707     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7708       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
7709   private static com.google.protobuf.Descriptors.Descriptor
7710     internal_static_openxc_DiagnosticResponse_descriptor;
7711   private static
7712     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7713       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
7714   private static com.google.protobuf.Descriptors.Descriptor
7715     internal_static_openxc_DynamicField_descriptor;
7716   private static
7717     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7718       internal_static_openxc_DynamicField_fieldAccessorTable;
7719   private static com.google.protobuf.Descriptors.Descriptor
7720     internal_static_openxc_TranslatedMessage_descriptor;
7721   private static
7722     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7723       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
7724
7725   public static com.google.protobuf.Descriptors.FileDescriptor
7726       getDescriptor() {
7727     return descriptor;
7728   }
7729   private static com.google.protobuf.Descriptors.FileDescriptor
7730       descriptor;
7731   static {
7732     java.lang.String[] descriptorData = {
7733       "\n\014openxc.proto\022\006openxc\"\224\003\n\016VehicleMessag" +
7734       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
7735       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
7736       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
7737       "xc.TranslatedMessage\0227\n\023diagnostic_respo" +
7738       "nse\030\004 \001(\0132\032.openxc.DiagnosticResponse\022/\n" +
7739       "\017control_command\030\005 \001(\0132\026.openxc.ControlC" +
7740       "ommand\0221\n\020command_response\030\006 \001(\0132\027.openx" +
7741       "c.CommandResponse\"Z\n\004Type\022\007\n\003RAW\020\001\022\016\n\nTR" +
7742       "ANSLATED\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CONTROL_CO",
7743       "MMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\";\n\nRawMess" +
7744       "age\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004" +
7745       "data\030\003 \001(\014\"\364\001\n\016ControlCommand\022)\n\004type\030\001 " +
7746       "\001(\0162\033.openxc.ControlCommand.Type\0225\n\022diag" +
7747       "nostic_request\030\002 \001(\0132\031.openxc.Diagnostic" +
7748       "Request\022-\n\006action\030\003 \001(\0162\035.openxc.Control" +
7749       "Command.Action\"2\n\004Type\022\013\n\007VERSION\020\001\022\r\n\tD" +
7750       "EVICE_ID\020\002\022\016\n\nDIAGNOSTIC\020\003\"\035\n\006Action\022\007\n\003" +
7751       "ADD\020\001\022\n\n\006CANCEL\020\002\"]\n\017CommandResponse\022)\n\004" +
7752       "type\030\001 \001(\0162\033.openxc.ControlCommand.Type\022",
7753       "\017\n\007message\030\002 \001(\t\022\016\n\006status\030\003 \001(\010\"\375\001\n\021Dia" +
7754       "gnosticRequest\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_i" +
7755       "d\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007pa" +
7756       "yload\030\005 \001(\014\022\032\n\022multiple_responses\030\006 \001(\010\022" +
7757       "\021\n\tfrequency\030\007 \001(\001\022\014\n\004name\030\010 \001(\t\022;\n\014deco" +
7758       "ded_type\030\t \001(\0162%.openxc.DiagnosticReques" +
7759       "t.DecodedType\"!\n\013DecodedType\022\010\n\004NONE\020\001\022\010" +
7760       "\n\004OBD2\020\002\"\241\001\n\022DiagnosticResponse\022\013\n\003bus\030\001" +
7761       " \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013" +
7762       "\n\003pid\030\004 \001(\r\022\017\n\007success\030\005 \001(\010\022\036\n\026negative",
7763       "_response_code\030\006 \001(\r\022\017\n\007payload\030\007 \001(\014\022\r\n" +
7764       "\005value\030\010 \001(\001\"\242\001\n\014DynamicField\022\'\n\004type\030\001 " +
7765       "\001(\0162\031.openxc.DynamicField.Type\022\024\n\014string" +
7766       "_value\030\002 \001(\t\022\025\n\rnumeric_value\030\003 \001(\001\022\025\n\rb" +
7767       "oolean_value\030\004 \001(\010\"%\n\004Type\022\n\n\006STRING\020\001\022\007" +
7768       "\n\003NUM\020\002\022\010\n\004BOOL\020\003\"\367\001\n\021TranslatedMessage\022" +
7769       ",\n\004type\030\001 \001(\0162\036.openxc.TranslatedMessage" +
7770       ".Type\022\014\n\004name\030\002 \001(\t\022#\n\005value\030\003 \001(\0132\024.ope" +
7771       "nxc.DynamicField\022#\n\005event\030\004 \001(\0132\024.openxc" +
7772       ".DynamicField\"\\\n\004Type\022\n\n\006STRING\020\001\022\007\n\003NUM",
7773       "\020\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTED_STRING\020\004\022\017\n\013EVEN" +
7774       "TED_NUM\020\005\022\020\n\014EVENTED_BOOL\020\006B\034\n\ncom.openx" +
7775       "cB\016BinaryMessages"
7776     };
7777     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
7778       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
7779         public com.google.protobuf.ExtensionRegistry assignDescriptors(
7780             com.google.protobuf.Descriptors.FileDescriptor root) {
7781           descriptor = root;
7782           internal_static_openxc_VehicleMessage_descriptor =
7783             getDescriptor().getMessageTypes().get(0);
7784           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
7785             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7786               internal_static_openxc_VehicleMessage_descriptor,
7787               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", });
7788           internal_static_openxc_RawMessage_descriptor =
7789             getDescriptor().getMessageTypes().get(1);
7790           internal_static_openxc_RawMessage_fieldAccessorTable = new
7791             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7792               internal_static_openxc_RawMessage_descriptor,
7793               new java.lang.String[] { "Bus", "MessageId", "Data", });
7794           internal_static_openxc_ControlCommand_descriptor =
7795             getDescriptor().getMessageTypes().get(2);
7796           internal_static_openxc_ControlCommand_fieldAccessorTable = new
7797             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7798               internal_static_openxc_ControlCommand_descriptor,
7799               new java.lang.String[] { "Type", "DiagnosticRequest", "Action", });
7800           internal_static_openxc_CommandResponse_descriptor =
7801             getDescriptor().getMessageTypes().get(3);
7802           internal_static_openxc_CommandResponse_fieldAccessorTable = new
7803             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7804               internal_static_openxc_CommandResponse_descriptor,
7805               new java.lang.String[] { "Type", "Message", "Status", });
7806           internal_static_openxc_DiagnosticRequest_descriptor =
7807             getDescriptor().getMessageTypes().get(4);
7808           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
7809             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7810               internal_static_openxc_DiagnosticRequest_descriptor,
7811               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Frequency", "Name", "DecodedType", });
7812           internal_static_openxc_DiagnosticResponse_descriptor =
7813             getDescriptor().getMessageTypes().get(5);
7814           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
7815             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7816               internal_static_openxc_DiagnosticResponse_descriptor,
7817               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", });
7818           internal_static_openxc_DynamicField_descriptor =
7819             getDescriptor().getMessageTypes().get(6);
7820           internal_static_openxc_DynamicField_fieldAccessorTable = new
7821             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7822               internal_static_openxc_DynamicField_descriptor,
7823               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", });
7824           internal_static_openxc_TranslatedMessage_descriptor =
7825             getDescriptor().getMessageTypes().get(7);
7826           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
7827             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7828               internal_static_openxc_TranslatedMessage_descriptor,
7829               new java.lang.String[] { "Type", "Name", "Value", "Event", });
7830           return null;
7831         }
7832       };
7833     com.google.protobuf.Descriptors.FileDescriptor
7834       .internalBuildGeneratedFileFrom(descriptorData,
7835         new com.google.protobuf.Descriptors.FileDescriptor[] {
7836         }, assigner);
7837   }
7838
7839   // @@protoc_insertion_point(outer_class_scope)
7840 }