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   /**
2074    * Protobuf type {@code openxc.ControlCommand}
2075    */
2076   public static final class ControlCommand extends
2077       com.google.protobuf.GeneratedMessage
2078       implements ControlCommandOrBuilder {
2079     // Use ControlCommand.newBuilder() to construct.
2080     private ControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2081       super(builder);
2082       this.unknownFields = builder.getUnknownFields();
2083     }
2084     private ControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2085
2086     private static final ControlCommand defaultInstance;
2087     public static ControlCommand getDefaultInstance() {
2088       return defaultInstance;
2089     }
2090
2091     public ControlCommand getDefaultInstanceForType() {
2092       return defaultInstance;
2093     }
2094
2095     private final com.google.protobuf.UnknownFieldSet unknownFields;
2096     @java.lang.Override
2097     public final com.google.protobuf.UnknownFieldSet
2098         getUnknownFields() {
2099       return this.unknownFields;
2100     }
2101     private ControlCommand(
2102         com.google.protobuf.CodedInputStream input,
2103         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2104         throws com.google.protobuf.InvalidProtocolBufferException {
2105       initFields();
2106       int mutable_bitField0_ = 0;
2107       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2108           com.google.protobuf.UnknownFieldSet.newBuilder();
2109       try {
2110         boolean done = false;
2111         while (!done) {
2112           int tag = input.readTag();
2113           switch (tag) {
2114             case 0:
2115               done = true;
2116               break;
2117             default: {
2118               if (!parseUnknownField(input, unknownFields,
2119                                      extensionRegistry, tag)) {
2120                 done = true;
2121               }
2122               break;
2123             }
2124             case 8: {
2125               int rawValue = input.readEnum();
2126               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2127               if (value == null) {
2128                 unknownFields.mergeVarintField(1, rawValue);
2129               } else {
2130                 bitField0_ |= 0x00000001;
2131                 type_ = value;
2132               }
2133               break;
2134             }
2135             case 18: {
2136               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = null;
2137               if (((bitField0_ & 0x00000002) == 0x00000002)) {
2138                 subBuilder = diagnosticRequest_.toBuilder();
2139               }
2140               diagnosticRequest_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticRequest.PARSER, extensionRegistry);
2141               if (subBuilder != null) {
2142                 subBuilder.mergeFrom(diagnosticRequest_);
2143                 diagnosticRequest_ = subBuilder.buildPartial();
2144               }
2145               bitField0_ |= 0x00000002;
2146               break;
2147             }
2148           }
2149         }
2150       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2151         throw e.setUnfinishedMessage(this);
2152       } catch (java.io.IOException e) {
2153         throw new com.google.protobuf.InvalidProtocolBufferException(
2154             e.getMessage()).setUnfinishedMessage(this);
2155       } finally {
2156         this.unknownFields = unknownFields.build();
2157         makeExtensionsImmutable();
2158       }
2159     }
2160     public static final com.google.protobuf.Descriptors.Descriptor
2161         getDescriptor() {
2162       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2163     }
2164
2165     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2166         internalGetFieldAccessorTable() {
2167       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2168           .ensureFieldAccessorsInitialized(
2169               com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2170     }
2171
2172     public static com.google.protobuf.Parser<ControlCommand> PARSER =
2173         new com.google.protobuf.AbstractParser<ControlCommand>() {
2174       public ControlCommand parsePartialFrom(
2175           com.google.protobuf.CodedInputStream input,
2176           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2177           throws com.google.protobuf.InvalidProtocolBufferException {
2178         return new ControlCommand(input, extensionRegistry);
2179       }
2180     };
2181
2182     @java.lang.Override
2183     public com.google.protobuf.Parser<ControlCommand> getParserForType() {
2184       return PARSER;
2185     }
2186
2187     /**
2188      * Protobuf enum {@code openxc.ControlCommand.Type}
2189      */
2190     public enum Type
2191         implements com.google.protobuf.ProtocolMessageEnum {
2192       /**
2193        * <code>VERSION = 1;</code>
2194        */
2195       VERSION(0, 1),
2196       /**
2197        * <code>DEVICE_ID = 2;</code>
2198        */
2199       DEVICE_ID(1, 2),
2200       /**
2201        * <code>DIAGNOSTIC = 3;</code>
2202        */
2203       DIAGNOSTIC(2, 3),
2204       ;
2205
2206       /**
2207        * <code>VERSION = 1;</code>
2208        */
2209       public static final int VERSION_VALUE = 1;
2210       /**
2211        * <code>DEVICE_ID = 2;</code>
2212        */
2213       public static final int DEVICE_ID_VALUE = 2;
2214       /**
2215        * <code>DIAGNOSTIC = 3;</code>
2216        */
2217       public static final int DIAGNOSTIC_VALUE = 3;
2218
2219
2220       public final int getNumber() { return value; }
2221
2222       public static Type valueOf(int value) {
2223         switch (value) {
2224           case 1: return VERSION;
2225           case 2: return DEVICE_ID;
2226           case 3: return DIAGNOSTIC;
2227           default: return null;
2228         }
2229       }
2230
2231       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2232           internalGetValueMap() {
2233         return internalValueMap;
2234       }
2235       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2236           internalValueMap =
2237             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2238               public Type findValueByNumber(int number) {
2239                 return Type.valueOf(number);
2240               }
2241             };
2242
2243       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2244           getValueDescriptor() {
2245         return getDescriptor().getValues().get(index);
2246       }
2247       public final com.google.protobuf.Descriptors.EnumDescriptor
2248           getDescriptorForType() {
2249         return getDescriptor();
2250       }
2251       public static final com.google.protobuf.Descriptors.EnumDescriptor
2252           getDescriptor() {
2253         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
2254       }
2255
2256       private static final Type[] VALUES = values();
2257
2258       public static Type valueOf(
2259           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2260         if (desc.getType() != getDescriptor()) {
2261           throw new java.lang.IllegalArgumentException(
2262             "EnumValueDescriptor is not for this type.");
2263         }
2264         return VALUES[desc.getIndex()];
2265       }
2266
2267       private final int index;
2268       private final int value;
2269
2270       private Type(int index, int value) {
2271         this.index = index;
2272         this.value = value;
2273       }
2274
2275       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
2276     }
2277
2278     private int bitField0_;
2279     // optional .openxc.ControlCommand.Type type = 1;
2280     public static final int TYPE_FIELD_NUMBER = 1;
2281     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2282     /**
2283      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2284      */
2285     public boolean hasType() {
2286       return ((bitField0_ & 0x00000001) == 0x00000001);
2287     }
2288     /**
2289      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2290      */
2291     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2292       return type_;
2293     }
2294
2295     // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2296     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
2297     private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_;
2298     /**
2299      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2300      */
2301     public boolean hasDiagnosticRequest() {
2302       return ((bitField0_ & 0x00000002) == 0x00000002);
2303     }
2304     /**
2305      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2306      */
2307     public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2308       return diagnosticRequest_;
2309     }
2310     /**
2311      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2312      */
2313     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2314       return diagnosticRequest_;
2315     }
2316
2317     private void initFields() {
2318       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2319       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2320     }
2321     private byte memoizedIsInitialized = -1;
2322     public final boolean isInitialized() {
2323       byte isInitialized = memoizedIsInitialized;
2324       if (isInitialized != -1) return isInitialized == 1;
2325
2326       memoizedIsInitialized = 1;
2327       return true;
2328     }
2329
2330     public void writeTo(com.google.protobuf.CodedOutputStream output)
2331                         throws java.io.IOException {
2332       getSerializedSize();
2333       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2334         output.writeEnum(1, type_.getNumber());
2335       }
2336       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2337         output.writeMessage(2, diagnosticRequest_);
2338       }
2339       getUnknownFields().writeTo(output);
2340     }
2341
2342     private int memoizedSerializedSize = -1;
2343     public int getSerializedSize() {
2344       int size = memoizedSerializedSize;
2345       if (size != -1) return size;
2346
2347       size = 0;
2348       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2349         size += com.google.protobuf.CodedOutputStream
2350           .computeEnumSize(1, type_.getNumber());
2351       }
2352       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2353         size += com.google.protobuf.CodedOutputStream
2354           .computeMessageSize(2, diagnosticRequest_);
2355       }
2356       size += getUnknownFields().getSerializedSize();
2357       memoizedSerializedSize = size;
2358       return size;
2359     }
2360
2361     private static final long serialVersionUID = 0L;
2362     @java.lang.Override
2363     protected java.lang.Object writeReplace()
2364         throws java.io.ObjectStreamException {
2365       return super.writeReplace();
2366     }
2367
2368     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2369         com.google.protobuf.ByteString data)
2370         throws com.google.protobuf.InvalidProtocolBufferException {
2371       return PARSER.parseFrom(data);
2372     }
2373     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2374         com.google.protobuf.ByteString data,
2375         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2376         throws com.google.protobuf.InvalidProtocolBufferException {
2377       return PARSER.parseFrom(data, extensionRegistry);
2378     }
2379     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
2380         throws com.google.protobuf.InvalidProtocolBufferException {
2381       return PARSER.parseFrom(data);
2382     }
2383     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2384         byte[] data,
2385         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2386         throws com.google.protobuf.InvalidProtocolBufferException {
2387       return PARSER.parseFrom(data, extensionRegistry);
2388     }
2389     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
2390         throws java.io.IOException {
2391       return PARSER.parseFrom(input);
2392     }
2393     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2394         java.io.InputStream input,
2395         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2396         throws java.io.IOException {
2397       return PARSER.parseFrom(input, extensionRegistry);
2398     }
2399     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
2400         throws java.io.IOException {
2401       return PARSER.parseDelimitedFrom(input);
2402     }
2403     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
2404         java.io.InputStream input,
2405         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2406         throws java.io.IOException {
2407       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2408     }
2409     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2410         com.google.protobuf.CodedInputStream input)
2411         throws java.io.IOException {
2412       return PARSER.parseFrom(input);
2413     }
2414     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2415         com.google.protobuf.CodedInputStream input,
2416         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2417         throws java.io.IOException {
2418       return PARSER.parseFrom(input, extensionRegistry);
2419     }
2420
2421     public static Builder newBuilder() { return Builder.create(); }
2422     public Builder newBuilderForType() { return newBuilder(); }
2423     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
2424       return newBuilder().mergeFrom(prototype);
2425     }
2426     public Builder toBuilder() { return newBuilder(this); }
2427
2428     @java.lang.Override
2429     protected Builder newBuilderForType(
2430         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2431       Builder builder = new Builder(parent);
2432       return builder;
2433     }
2434     /**
2435      * Protobuf type {@code openxc.ControlCommand}
2436      */
2437     public static final class Builder extends
2438         com.google.protobuf.GeneratedMessage.Builder<Builder>
2439        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
2440       public static final com.google.protobuf.Descriptors.Descriptor
2441           getDescriptor() {
2442         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2443       }
2444
2445       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2446           internalGetFieldAccessorTable() {
2447         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2448             .ensureFieldAccessorsInitialized(
2449                 com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2450       }
2451
2452       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
2453       private Builder() {
2454         maybeForceBuilderInitialization();
2455       }
2456
2457       private Builder(
2458           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2459         super(parent);
2460         maybeForceBuilderInitialization();
2461       }
2462       private void maybeForceBuilderInitialization() {
2463         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2464           getDiagnosticRequestFieldBuilder();
2465         }
2466       }
2467       private static Builder create() {
2468         return new Builder();
2469       }
2470
2471       public Builder clear() {
2472         super.clear();
2473         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2474         bitField0_ = (bitField0_ & ~0x00000001);
2475         if (diagnosticRequestBuilder_ == null) {
2476           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2477         } else {
2478           diagnosticRequestBuilder_.clear();
2479         }
2480         bitField0_ = (bitField0_ & ~0x00000002);
2481         return this;
2482       }
2483
2484       public Builder clone() {
2485         return create().mergeFrom(buildPartial());
2486       }
2487
2488       public com.google.protobuf.Descriptors.Descriptor
2489           getDescriptorForType() {
2490         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2491       }
2492
2493       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
2494         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
2495       }
2496
2497       public com.openxc.BinaryMessages.ControlCommand build() {
2498         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2499         if (!result.isInitialized()) {
2500           throw newUninitializedMessageException(result);
2501         }
2502         return result;
2503       }
2504
2505       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
2506         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
2507         int from_bitField0_ = bitField0_;
2508         int to_bitField0_ = 0;
2509         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2510           to_bitField0_ |= 0x00000001;
2511         }
2512         result.type_ = type_;
2513         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2514           to_bitField0_ |= 0x00000002;
2515         }
2516         if (diagnosticRequestBuilder_ == null) {
2517           result.diagnosticRequest_ = diagnosticRequest_;
2518         } else {
2519           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
2520         }
2521         result.bitField0_ = to_bitField0_;
2522         onBuilt();
2523         return result;
2524       }
2525
2526       public Builder mergeFrom(com.google.protobuf.Message other) {
2527         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
2528           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
2529         } else {
2530           super.mergeFrom(other);
2531           return this;
2532         }
2533       }
2534
2535       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
2536         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
2537         if (other.hasType()) {
2538           setType(other.getType());
2539         }
2540         if (other.hasDiagnosticRequest()) {
2541           mergeDiagnosticRequest(other.getDiagnosticRequest());
2542         }
2543         this.mergeUnknownFields(other.getUnknownFields());
2544         return this;
2545       }
2546
2547       public final boolean isInitialized() {
2548         return true;
2549       }
2550
2551       public Builder mergeFrom(
2552           com.google.protobuf.CodedInputStream input,
2553           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2554           throws java.io.IOException {
2555         com.openxc.BinaryMessages.ControlCommand parsedMessage = null;
2556         try {
2557           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2558         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2559           parsedMessage = (com.openxc.BinaryMessages.ControlCommand) e.getUnfinishedMessage();
2560           throw e;
2561         } finally {
2562           if (parsedMessage != null) {
2563             mergeFrom(parsedMessage);
2564           }
2565         }
2566         return this;
2567       }
2568       private int bitField0_;
2569
2570       // optional .openxc.ControlCommand.Type type = 1;
2571       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2572       /**
2573        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2574        */
2575       public boolean hasType() {
2576         return ((bitField0_ & 0x00000001) == 0x00000001);
2577       }
2578       /**
2579        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2580        */
2581       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2582         return type_;
2583       }
2584       /**
2585        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2586        */
2587       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
2588         if (value == null) {
2589           throw new NullPointerException();
2590         }
2591         bitField0_ |= 0x00000001;
2592         type_ = value;
2593         onChanged();
2594         return this;
2595       }
2596       /**
2597        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2598        */
2599       public Builder clearType() {
2600         bitField0_ = (bitField0_ & ~0x00000001);
2601         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2602         onChanged();
2603         return this;
2604       }
2605
2606       // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2607       private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2608       private com.google.protobuf.SingleFieldBuilder<
2609           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> diagnosticRequestBuilder_;
2610       /**
2611        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2612        */
2613       public boolean hasDiagnosticRequest() {
2614         return ((bitField0_ & 0x00000002) == 0x00000002);
2615       }
2616       /**
2617        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2618        */
2619       public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2620         if (diagnosticRequestBuilder_ == null) {
2621           return diagnosticRequest_;
2622         } else {
2623           return diagnosticRequestBuilder_.getMessage();
2624         }
2625       }
2626       /**
2627        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2628        */
2629       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2630         if (diagnosticRequestBuilder_ == null) {
2631           if (value == null) {
2632             throw new NullPointerException();
2633           }
2634           diagnosticRequest_ = value;
2635           onChanged();
2636         } else {
2637           diagnosticRequestBuilder_.setMessage(value);
2638         }
2639         bitField0_ |= 0x00000002;
2640         return this;
2641       }
2642       /**
2643        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2644        */
2645       public Builder setDiagnosticRequest(
2646           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
2647         if (diagnosticRequestBuilder_ == null) {
2648           diagnosticRequest_ = builderForValue.build();
2649           onChanged();
2650         } else {
2651           diagnosticRequestBuilder_.setMessage(builderForValue.build());
2652         }
2653         bitField0_ |= 0x00000002;
2654         return this;
2655       }
2656       /**
2657        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2658        */
2659       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2660         if (diagnosticRequestBuilder_ == null) {
2661           if (((bitField0_ & 0x00000002) == 0x00000002) &&
2662               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
2663             diagnosticRequest_ =
2664               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
2665           } else {
2666             diagnosticRequest_ = value;
2667           }
2668           onChanged();
2669         } else {
2670           diagnosticRequestBuilder_.mergeFrom(value);
2671         }
2672         bitField0_ |= 0x00000002;
2673         return this;
2674       }
2675       /**
2676        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2677        */
2678       public Builder clearDiagnosticRequest() {
2679         if (diagnosticRequestBuilder_ == null) {
2680           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2681           onChanged();
2682         } else {
2683           diagnosticRequestBuilder_.clear();
2684         }
2685         bitField0_ = (bitField0_ & ~0x00000002);
2686         return this;
2687       }
2688       /**
2689        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2690        */
2691       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getDiagnosticRequestBuilder() {
2692         bitField0_ |= 0x00000002;
2693         onChanged();
2694         return getDiagnosticRequestFieldBuilder().getBuilder();
2695       }
2696       /**
2697        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2698        */
2699       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2700         if (diagnosticRequestBuilder_ != null) {
2701           return diagnosticRequestBuilder_.getMessageOrBuilder();
2702         } else {
2703           return diagnosticRequest_;
2704         }
2705       }
2706       /**
2707        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2708        */
2709       private com.google.protobuf.SingleFieldBuilder<
2710           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>
2711           getDiagnosticRequestFieldBuilder() {
2712         if (diagnosticRequestBuilder_ == null) {
2713           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2714               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
2715                   diagnosticRequest_,
2716                   getParentForChildren(),
2717                   isClean());
2718           diagnosticRequest_ = null;
2719         }
2720         return diagnosticRequestBuilder_;
2721       }
2722
2723       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
2724     }
2725
2726     static {
2727       defaultInstance = new ControlCommand(true);
2728       defaultInstance.initFields();
2729     }
2730
2731     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
2732   }
2733
2734   public interface CommandResponseOrBuilder
2735       extends com.google.protobuf.MessageOrBuilder {
2736
2737     // optional .openxc.ControlCommand.Type type = 1;
2738     /**
2739      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2740      */
2741     boolean hasType();
2742     /**
2743      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2744      */
2745     com.openxc.BinaryMessages.ControlCommand.Type getType();
2746
2747     // optional string message = 2;
2748     /**
2749      * <code>optional string message = 2;</code>
2750      */
2751     boolean hasMessage();
2752     /**
2753      * <code>optional string message = 2;</code>
2754      */
2755     java.lang.String getMessage();
2756     /**
2757      * <code>optional string message = 2;</code>
2758      */
2759     com.google.protobuf.ByteString
2760         getMessageBytes();
2761
2762     // optional bool status = 3;
2763     /**
2764      * <code>optional bool status = 3;</code>
2765      */
2766     boolean hasStatus();
2767     /**
2768      * <code>optional bool status = 3;</code>
2769      */
2770     boolean getStatus();
2771   }
2772   /**
2773    * Protobuf type {@code openxc.CommandResponse}
2774    */
2775   public static final class CommandResponse extends
2776       com.google.protobuf.GeneratedMessage
2777       implements CommandResponseOrBuilder {
2778     // Use CommandResponse.newBuilder() to construct.
2779     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2780       super(builder);
2781       this.unknownFields = builder.getUnknownFields();
2782     }
2783     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2784
2785     private static final CommandResponse defaultInstance;
2786     public static CommandResponse getDefaultInstance() {
2787       return defaultInstance;
2788     }
2789
2790     public CommandResponse getDefaultInstanceForType() {
2791       return defaultInstance;
2792     }
2793
2794     private final com.google.protobuf.UnknownFieldSet unknownFields;
2795     @java.lang.Override
2796     public final com.google.protobuf.UnknownFieldSet
2797         getUnknownFields() {
2798       return this.unknownFields;
2799     }
2800     private CommandResponse(
2801         com.google.protobuf.CodedInputStream input,
2802         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2803         throws com.google.protobuf.InvalidProtocolBufferException {
2804       initFields();
2805       int mutable_bitField0_ = 0;
2806       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2807           com.google.protobuf.UnknownFieldSet.newBuilder();
2808       try {
2809         boolean done = false;
2810         while (!done) {
2811           int tag = input.readTag();
2812           switch (tag) {
2813             case 0:
2814               done = true;
2815               break;
2816             default: {
2817               if (!parseUnknownField(input, unknownFields,
2818                                      extensionRegistry, tag)) {
2819                 done = true;
2820               }
2821               break;
2822             }
2823             case 8: {
2824               int rawValue = input.readEnum();
2825               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2826               if (value == null) {
2827                 unknownFields.mergeVarintField(1, rawValue);
2828               } else {
2829                 bitField0_ |= 0x00000001;
2830                 type_ = value;
2831               }
2832               break;
2833             }
2834             case 18: {
2835               bitField0_ |= 0x00000002;
2836               message_ = input.readBytes();
2837               break;
2838             }
2839             case 24: {
2840               bitField0_ |= 0x00000004;
2841               status_ = input.readBool();
2842               break;
2843             }
2844           }
2845         }
2846       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2847         throw e.setUnfinishedMessage(this);
2848       } catch (java.io.IOException e) {
2849         throw new com.google.protobuf.InvalidProtocolBufferException(
2850             e.getMessage()).setUnfinishedMessage(this);
2851       } finally {
2852         this.unknownFields = unknownFields.build();
2853         makeExtensionsImmutable();
2854       }
2855     }
2856     public static final com.google.protobuf.Descriptors.Descriptor
2857         getDescriptor() {
2858       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
2859     }
2860
2861     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2862         internalGetFieldAccessorTable() {
2863       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
2864           .ensureFieldAccessorsInitialized(
2865               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
2866     }
2867
2868     public static com.google.protobuf.Parser<CommandResponse> PARSER =
2869         new com.google.protobuf.AbstractParser<CommandResponse>() {
2870       public CommandResponse parsePartialFrom(
2871           com.google.protobuf.CodedInputStream input,
2872           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2873           throws com.google.protobuf.InvalidProtocolBufferException {
2874         return new CommandResponse(input, extensionRegistry);
2875       }
2876     };
2877
2878     @java.lang.Override
2879     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
2880       return PARSER;
2881     }
2882
2883     private int bitField0_;
2884     // optional .openxc.ControlCommand.Type type = 1;
2885     public static final int TYPE_FIELD_NUMBER = 1;
2886     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2887     /**
2888      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2889      */
2890     public boolean hasType() {
2891       return ((bitField0_ & 0x00000001) == 0x00000001);
2892     }
2893     /**
2894      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2895      */
2896     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2897       return type_;
2898     }
2899
2900     // optional string message = 2;
2901     public static final int MESSAGE_FIELD_NUMBER = 2;
2902     private java.lang.Object message_;
2903     /**
2904      * <code>optional string message = 2;</code>
2905      */
2906     public boolean hasMessage() {
2907       return ((bitField0_ & 0x00000002) == 0x00000002);
2908     }
2909     /**
2910      * <code>optional string message = 2;</code>
2911      */
2912     public java.lang.String getMessage() {
2913       java.lang.Object ref = message_;
2914       if (ref instanceof java.lang.String) {
2915         return (java.lang.String) ref;
2916       } else {
2917         com.google.protobuf.ByteString bs =
2918             (com.google.protobuf.ByteString) ref;
2919         java.lang.String s = bs.toStringUtf8();
2920         if (bs.isValidUtf8()) {
2921           message_ = s;
2922         }
2923         return s;
2924       }
2925     }
2926     /**
2927      * <code>optional string message = 2;</code>
2928      */
2929     public com.google.protobuf.ByteString
2930         getMessageBytes() {
2931       java.lang.Object ref = message_;
2932       if (ref instanceof java.lang.String) {
2933         com.google.protobuf.ByteString b =
2934             com.google.protobuf.ByteString.copyFromUtf8(
2935                 (java.lang.String) ref);
2936         message_ = b;
2937         return b;
2938       } else {
2939         return (com.google.protobuf.ByteString) ref;
2940       }
2941     }
2942
2943     // optional bool status = 3;
2944     public static final int STATUS_FIELD_NUMBER = 3;
2945     private boolean status_;
2946     /**
2947      * <code>optional bool status = 3;</code>
2948      */
2949     public boolean hasStatus() {
2950       return ((bitField0_ & 0x00000004) == 0x00000004);
2951     }
2952     /**
2953      * <code>optional bool status = 3;</code>
2954      */
2955     public boolean getStatus() {
2956       return status_;
2957     }
2958
2959     private void initFields() {
2960       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2961       message_ = "";
2962       status_ = false;
2963     }
2964     private byte memoizedIsInitialized = -1;
2965     public final boolean isInitialized() {
2966       byte isInitialized = memoizedIsInitialized;
2967       if (isInitialized != -1) return isInitialized == 1;
2968
2969       memoizedIsInitialized = 1;
2970       return true;
2971     }
2972
2973     public void writeTo(com.google.protobuf.CodedOutputStream output)
2974                         throws java.io.IOException {
2975       getSerializedSize();
2976       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2977         output.writeEnum(1, type_.getNumber());
2978       }
2979       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2980         output.writeBytes(2, getMessageBytes());
2981       }
2982       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2983         output.writeBool(3, status_);
2984       }
2985       getUnknownFields().writeTo(output);
2986     }
2987
2988     private int memoizedSerializedSize = -1;
2989     public int getSerializedSize() {
2990       int size = memoizedSerializedSize;
2991       if (size != -1) return size;
2992
2993       size = 0;
2994       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2995         size += com.google.protobuf.CodedOutputStream
2996           .computeEnumSize(1, type_.getNumber());
2997       }
2998       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2999         size += com.google.protobuf.CodedOutputStream
3000           .computeBytesSize(2, getMessageBytes());
3001       }
3002       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3003         size += com.google.protobuf.CodedOutputStream
3004           .computeBoolSize(3, status_);
3005       }
3006       size += getUnknownFields().getSerializedSize();
3007       memoizedSerializedSize = size;
3008       return size;
3009     }
3010
3011     private static final long serialVersionUID = 0L;
3012     @java.lang.Override
3013     protected java.lang.Object writeReplace()
3014         throws java.io.ObjectStreamException {
3015       return super.writeReplace();
3016     }
3017
3018     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3019         com.google.protobuf.ByteString data)
3020         throws com.google.protobuf.InvalidProtocolBufferException {
3021       return PARSER.parseFrom(data);
3022     }
3023     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3024         com.google.protobuf.ByteString data,
3025         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3026         throws com.google.protobuf.InvalidProtocolBufferException {
3027       return PARSER.parseFrom(data, extensionRegistry);
3028     }
3029     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
3030         throws com.google.protobuf.InvalidProtocolBufferException {
3031       return PARSER.parseFrom(data);
3032     }
3033     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3034         byte[] data,
3035         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3036         throws com.google.protobuf.InvalidProtocolBufferException {
3037       return PARSER.parseFrom(data, extensionRegistry);
3038     }
3039     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
3040         throws java.io.IOException {
3041       return PARSER.parseFrom(input);
3042     }
3043     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3044         java.io.InputStream input,
3045         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3046         throws java.io.IOException {
3047       return PARSER.parseFrom(input, extensionRegistry);
3048     }
3049     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
3050         throws java.io.IOException {
3051       return PARSER.parseDelimitedFrom(input);
3052     }
3053     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
3054         java.io.InputStream input,
3055         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3056         throws java.io.IOException {
3057       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3058     }
3059     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3060         com.google.protobuf.CodedInputStream input)
3061         throws java.io.IOException {
3062       return PARSER.parseFrom(input);
3063     }
3064     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3065         com.google.protobuf.CodedInputStream input,
3066         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3067         throws java.io.IOException {
3068       return PARSER.parseFrom(input, extensionRegistry);
3069     }
3070
3071     public static Builder newBuilder() { return Builder.create(); }
3072     public Builder newBuilderForType() { return newBuilder(); }
3073     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
3074       return newBuilder().mergeFrom(prototype);
3075     }
3076     public Builder toBuilder() { return newBuilder(this); }
3077
3078     @java.lang.Override
3079     protected Builder newBuilderForType(
3080         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3081       Builder builder = new Builder(parent);
3082       return builder;
3083     }
3084     /**
3085      * Protobuf type {@code openxc.CommandResponse}
3086      */
3087     public static final class Builder extends
3088         com.google.protobuf.GeneratedMessage.Builder<Builder>
3089        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
3090       public static final com.google.protobuf.Descriptors.Descriptor
3091           getDescriptor() {
3092         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3093       }
3094
3095       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3096           internalGetFieldAccessorTable() {
3097         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
3098             .ensureFieldAccessorsInitialized(
3099                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
3100       }
3101
3102       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
3103       private Builder() {
3104         maybeForceBuilderInitialization();
3105       }
3106
3107       private Builder(
3108           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3109         super(parent);
3110         maybeForceBuilderInitialization();
3111       }
3112       private void maybeForceBuilderInitialization() {
3113         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3114         }
3115       }
3116       private static Builder create() {
3117         return new Builder();
3118       }
3119
3120       public Builder clear() {
3121         super.clear();
3122         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3123         bitField0_ = (bitField0_ & ~0x00000001);
3124         message_ = "";
3125         bitField0_ = (bitField0_ & ~0x00000002);
3126         status_ = false;
3127         bitField0_ = (bitField0_ & ~0x00000004);
3128         return this;
3129       }
3130
3131       public Builder clone() {
3132         return create().mergeFrom(buildPartial());
3133       }
3134
3135       public com.google.protobuf.Descriptors.Descriptor
3136           getDescriptorForType() {
3137         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3138       }
3139
3140       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
3141         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
3142       }
3143
3144       public com.openxc.BinaryMessages.CommandResponse build() {
3145         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
3146         if (!result.isInitialized()) {
3147           throw newUninitializedMessageException(result);
3148         }
3149         return result;
3150       }
3151
3152       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
3153         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
3154         int from_bitField0_ = bitField0_;
3155         int to_bitField0_ = 0;
3156         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3157           to_bitField0_ |= 0x00000001;
3158         }
3159         result.type_ = type_;
3160         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3161           to_bitField0_ |= 0x00000002;
3162         }
3163         result.message_ = message_;
3164         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
3165           to_bitField0_ |= 0x00000004;
3166         }
3167         result.status_ = status_;
3168         result.bitField0_ = to_bitField0_;
3169         onBuilt();
3170         return result;
3171       }
3172
3173       public Builder mergeFrom(com.google.protobuf.Message other) {
3174         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
3175           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
3176         } else {
3177           super.mergeFrom(other);
3178           return this;
3179         }
3180       }
3181
3182       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
3183         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
3184         if (other.hasType()) {
3185           setType(other.getType());
3186         }
3187         if (other.hasMessage()) {
3188           bitField0_ |= 0x00000002;
3189           message_ = other.message_;
3190           onChanged();
3191         }
3192         if (other.hasStatus()) {
3193           setStatus(other.getStatus());
3194         }
3195         this.mergeUnknownFields(other.getUnknownFields());
3196         return this;
3197       }
3198
3199       public final boolean isInitialized() {
3200         return true;
3201       }
3202
3203       public Builder mergeFrom(
3204           com.google.protobuf.CodedInputStream input,
3205           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3206           throws java.io.IOException {
3207         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
3208         try {
3209           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3210         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3211           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
3212           throw e;
3213         } finally {
3214           if (parsedMessage != null) {
3215             mergeFrom(parsedMessage);
3216           }
3217         }
3218         return this;
3219       }
3220       private int bitField0_;
3221
3222       // optional .openxc.ControlCommand.Type type = 1;
3223       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3224       /**
3225        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3226        */
3227       public boolean hasType() {
3228         return ((bitField0_ & 0x00000001) == 0x00000001);
3229       }
3230       /**
3231        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3232        */
3233       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
3234         return type_;
3235       }
3236       /**
3237        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3238        */
3239       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
3240         if (value == null) {
3241           throw new NullPointerException();
3242         }
3243         bitField0_ |= 0x00000001;
3244         type_ = value;
3245         onChanged();
3246         return this;
3247       }
3248       /**
3249        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3250        */
3251       public Builder clearType() {
3252         bitField0_ = (bitField0_ & ~0x00000001);
3253         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3254         onChanged();
3255         return this;
3256       }
3257
3258       // optional string message = 2;
3259       private java.lang.Object message_ = "";
3260       /**
3261        * <code>optional string message = 2;</code>
3262        */
3263       public boolean hasMessage() {
3264         return ((bitField0_ & 0x00000002) == 0x00000002);
3265       }
3266       /**
3267        * <code>optional string message = 2;</code>
3268        */
3269       public java.lang.String getMessage() {
3270         java.lang.Object ref = message_;
3271         if (!(ref instanceof java.lang.String)) {
3272           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3273               .toStringUtf8();
3274           message_ = s;
3275           return s;
3276         } else {
3277           return (java.lang.String) ref;
3278         }
3279       }
3280       /**
3281        * <code>optional string message = 2;</code>
3282        */
3283       public com.google.protobuf.ByteString
3284           getMessageBytes() {
3285         java.lang.Object ref = message_;
3286         if (ref instanceof String) {
3287           com.google.protobuf.ByteString b =
3288               com.google.protobuf.ByteString.copyFromUtf8(
3289                   (java.lang.String) ref);
3290           message_ = b;
3291           return b;
3292         } else {
3293           return (com.google.protobuf.ByteString) ref;
3294         }
3295       }
3296       /**
3297        * <code>optional string message = 2;</code>
3298        */
3299       public Builder setMessage(
3300           java.lang.String value) {
3301         if (value == null) {
3302     throw new NullPointerException();
3303   }
3304   bitField0_ |= 0x00000002;
3305         message_ = value;
3306         onChanged();
3307         return this;
3308       }
3309       /**
3310        * <code>optional string message = 2;</code>
3311        */
3312       public Builder clearMessage() {
3313         bitField0_ = (bitField0_ & ~0x00000002);
3314         message_ = getDefaultInstance().getMessage();
3315         onChanged();
3316         return this;
3317       }
3318       /**
3319        * <code>optional string message = 2;</code>
3320        */
3321       public Builder setMessageBytes(
3322           com.google.protobuf.ByteString value) {
3323         if (value == null) {
3324     throw new NullPointerException();
3325   }
3326   bitField0_ |= 0x00000002;
3327         message_ = value;
3328         onChanged();
3329         return this;
3330       }
3331
3332       // optional bool status = 3;
3333       private boolean status_ ;
3334       /**
3335        * <code>optional bool status = 3;</code>
3336        */
3337       public boolean hasStatus() {
3338         return ((bitField0_ & 0x00000004) == 0x00000004);
3339       }
3340       /**
3341        * <code>optional bool status = 3;</code>
3342        */
3343       public boolean getStatus() {
3344         return status_;
3345       }
3346       /**
3347        * <code>optional bool status = 3;</code>
3348        */
3349       public Builder setStatus(boolean value) {
3350         bitField0_ |= 0x00000004;
3351         status_ = value;
3352         onChanged();
3353         return this;
3354       }
3355       /**
3356        * <code>optional bool status = 3;</code>
3357        */
3358       public Builder clearStatus() {
3359         bitField0_ = (bitField0_ & ~0x00000004);
3360         status_ = false;
3361         onChanged();
3362         return this;
3363       }
3364
3365       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
3366     }
3367
3368     static {
3369       defaultInstance = new CommandResponse(true);
3370       defaultInstance.initFields();
3371     }
3372
3373     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
3374   }
3375
3376   public interface DiagnosticRequestOrBuilder
3377       extends com.google.protobuf.MessageOrBuilder {
3378
3379     // optional int32 bus = 1;
3380     /**
3381      * <code>optional int32 bus = 1;</code>
3382      */
3383     boolean hasBus();
3384     /**
3385      * <code>optional int32 bus = 1;</code>
3386      */
3387     int getBus();
3388
3389     // optional uint32 message_id = 2;
3390     /**
3391      * <code>optional uint32 message_id = 2;</code>
3392      */
3393     boolean hasMessageId();
3394     /**
3395      * <code>optional uint32 message_id = 2;</code>
3396      */
3397     int getMessageId();
3398
3399     // optional uint32 mode = 3;
3400     /**
3401      * <code>optional uint32 mode = 3;</code>
3402      */
3403     boolean hasMode();
3404     /**
3405      * <code>optional uint32 mode = 3;</code>
3406      */
3407     int getMode();
3408
3409     // optional uint32 pid = 4;
3410     /**
3411      * <code>optional uint32 pid = 4;</code>
3412      */
3413     boolean hasPid();
3414     /**
3415      * <code>optional uint32 pid = 4;</code>
3416      */
3417     int getPid();
3418
3419     // optional bytes payload = 5;
3420     /**
3421      * <code>optional bytes payload = 5;</code>
3422      *
3423      * <pre>
3424      * TODO we are capping this at 8 bytes for now - need to change when we
3425      * support multi-frame responses
3426      * </pre>
3427      */
3428     boolean hasPayload();
3429     /**
3430      * <code>optional bytes payload = 5;</code>
3431      *
3432      * <pre>
3433      * TODO we are capping this at 8 bytes for now - need to change when we
3434      * support multi-frame responses
3435      * </pre>
3436      */
3437     com.google.protobuf.ByteString getPayload();
3438
3439     // optional bool multiple_responses = 6;
3440     /**
3441      * <code>optional bool multiple_responses = 6;</code>
3442      */
3443     boolean hasMultipleResponses();
3444     /**
3445      * <code>optional bool multiple_responses = 6;</code>
3446      */
3447     boolean getMultipleResponses();
3448
3449     // optional double frequency = 7;
3450     /**
3451      * <code>optional double frequency = 7;</code>
3452      */
3453     boolean hasFrequency();
3454     /**
3455      * <code>optional double frequency = 7;</code>
3456      */
3457     double getFrequency();
3458
3459     // optional string name = 8;
3460     /**
3461      * <code>optional string name = 8;</code>
3462      */
3463     boolean hasName();
3464     /**
3465      * <code>optional string name = 8;</code>
3466      */
3467     java.lang.String getName();
3468     /**
3469      * <code>optional string name = 8;</code>
3470      */
3471     com.google.protobuf.ByteString
3472         getNameBytes();
3473
3474     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
3475     /**
3476      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3477      */
3478     boolean hasDecodedType();
3479     /**
3480      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3481      */
3482     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
3483
3484     // optional .openxc.DiagnosticRequest.Action action = 10;
3485     /**
3486      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3487      */
3488     boolean hasAction();
3489     /**
3490      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3491      */
3492     com.openxc.BinaryMessages.DiagnosticRequest.Action getAction();
3493   }
3494   /**
3495    * Protobuf type {@code openxc.DiagnosticRequest}
3496    */
3497   public static final class DiagnosticRequest extends
3498       com.google.protobuf.GeneratedMessage
3499       implements DiagnosticRequestOrBuilder {
3500     // Use DiagnosticRequest.newBuilder() to construct.
3501     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3502       super(builder);
3503       this.unknownFields = builder.getUnknownFields();
3504     }
3505     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3506
3507     private static final DiagnosticRequest defaultInstance;
3508     public static DiagnosticRequest getDefaultInstance() {
3509       return defaultInstance;
3510     }
3511
3512     public DiagnosticRequest getDefaultInstanceForType() {
3513       return defaultInstance;
3514     }
3515
3516     private final com.google.protobuf.UnknownFieldSet unknownFields;
3517     @java.lang.Override
3518     public final com.google.protobuf.UnknownFieldSet
3519         getUnknownFields() {
3520       return this.unknownFields;
3521     }
3522     private DiagnosticRequest(
3523         com.google.protobuf.CodedInputStream input,
3524         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3525         throws com.google.protobuf.InvalidProtocolBufferException {
3526       initFields();
3527       int mutable_bitField0_ = 0;
3528       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3529           com.google.protobuf.UnknownFieldSet.newBuilder();
3530       try {
3531         boolean done = false;
3532         while (!done) {
3533           int tag = input.readTag();
3534           switch (tag) {
3535             case 0:
3536               done = true;
3537               break;
3538             default: {
3539               if (!parseUnknownField(input, unknownFields,
3540                                      extensionRegistry, tag)) {
3541                 done = true;
3542               }
3543               break;
3544             }
3545             case 8: {
3546               bitField0_ |= 0x00000001;
3547               bus_ = input.readInt32();
3548               break;
3549             }
3550             case 16: {
3551               bitField0_ |= 0x00000002;
3552               messageId_ = input.readUInt32();
3553               break;
3554             }
3555             case 24: {
3556               bitField0_ |= 0x00000004;
3557               mode_ = input.readUInt32();
3558               break;
3559             }
3560             case 32: {
3561               bitField0_ |= 0x00000008;
3562               pid_ = input.readUInt32();
3563               break;
3564             }
3565             case 42: {
3566               bitField0_ |= 0x00000010;
3567               payload_ = input.readBytes();
3568               break;
3569             }
3570             case 48: {
3571               bitField0_ |= 0x00000020;
3572               multipleResponses_ = input.readBool();
3573               break;
3574             }
3575             case 57: {
3576               bitField0_ |= 0x00000040;
3577               frequency_ = input.readDouble();
3578               break;
3579             }
3580             case 66: {
3581               bitField0_ |= 0x00000080;
3582               name_ = input.readBytes();
3583               break;
3584             }
3585             case 72: {
3586               int rawValue = input.readEnum();
3587               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
3588               if (value == null) {
3589                 unknownFields.mergeVarintField(9, rawValue);
3590               } else {
3591                 bitField0_ |= 0x00000100;
3592                 decodedType_ = value;
3593               }
3594               break;
3595             }
3596             case 80: {
3597               int rawValue = input.readEnum();
3598               com.openxc.BinaryMessages.DiagnosticRequest.Action value = com.openxc.BinaryMessages.DiagnosticRequest.Action.valueOf(rawValue);
3599               if (value == null) {
3600                 unknownFields.mergeVarintField(10, rawValue);
3601               } else {
3602                 bitField0_ |= 0x00000200;
3603                 action_ = value;
3604               }
3605               break;
3606             }
3607           }
3608         }
3609       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3610         throw e.setUnfinishedMessage(this);
3611       } catch (java.io.IOException e) {
3612         throw new com.google.protobuf.InvalidProtocolBufferException(
3613             e.getMessage()).setUnfinishedMessage(this);
3614       } finally {
3615         this.unknownFields = unknownFields.build();
3616         makeExtensionsImmutable();
3617       }
3618     }
3619     public static final com.google.protobuf.Descriptors.Descriptor
3620         getDescriptor() {
3621       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
3622     }
3623
3624     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3625         internalGetFieldAccessorTable() {
3626       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
3627           .ensureFieldAccessorsInitialized(
3628               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
3629     }
3630
3631     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
3632         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
3633       public DiagnosticRequest parsePartialFrom(
3634           com.google.protobuf.CodedInputStream input,
3635           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3636           throws com.google.protobuf.InvalidProtocolBufferException {
3637         return new DiagnosticRequest(input, extensionRegistry);
3638       }
3639     };
3640
3641     @java.lang.Override
3642     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
3643       return PARSER;
3644     }
3645
3646     /**
3647      * Protobuf enum {@code openxc.DiagnosticRequest.DecodedType}
3648      */
3649     public enum DecodedType
3650         implements com.google.protobuf.ProtocolMessageEnum {
3651       /**
3652        * <code>NONE = 1;</code>
3653        */
3654       NONE(0, 1),
3655       /**
3656        * <code>OBD2 = 2;</code>
3657        */
3658       OBD2(1, 2),
3659       ;
3660
3661       /**
3662        * <code>NONE = 1;</code>
3663        */
3664       public static final int NONE_VALUE = 1;
3665       /**
3666        * <code>OBD2 = 2;</code>
3667        */
3668       public static final int OBD2_VALUE = 2;
3669
3670
3671       public final int getNumber() { return value; }
3672
3673       public static DecodedType valueOf(int value) {
3674         switch (value) {
3675           case 1: return NONE;
3676           case 2: return OBD2;
3677           default: return null;
3678         }
3679       }
3680
3681       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
3682           internalGetValueMap() {
3683         return internalValueMap;
3684       }
3685       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
3686           internalValueMap =
3687             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
3688               public DecodedType findValueByNumber(int number) {
3689                 return DecodedType.valueOf(number);
3690               }
3691             };
3692
3693       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3694           getValueDescriptor() {
3695         return getDescriptor().getValues().get(index);
3696       }
3697       public final com.google.protobuf.Descriptors.EnumDescriptor
3698           getDescriptorForType() {
3699         return getDescriptor();
3700       }
3701       public static final com.google.protobuf.Descriptors.EnumDescriptor
3702           getDescriptor() {
3703         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
3704       }
3705
3706       private static final DecodedType[] VALUES = values();
3707
3708       public static DecodedType valueOf(
3709           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3710         if (desc.getType() != getDescriptor()) {
3711           throw new java.lang.IllegalArgumentException(
3712             "EnumValueDescriptor is not for this type.");
3713         }
3714         return VALUES[desc.getIndex()];
3715       }
3716
3717       private final int index;
3718       private final int value;
3719
3720       private DecodedType(int index, int value) {
3721         this.index = index;
3722         this.value = value;
3723       }
3724
3725       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
3726     }
3727
3728     /**
3729      * Protobuf enum {@code openxc.DiagnosticRequest.Action}
3730      */
3731     public enum Action
3732         implements com.google.protobuf.ProtocolMessageEnum {
3733       /**
3734        * <code>ADD = 1;</code>
3735        */
3736       ADD(0, 1),
3737       /**
3738        * <code>CANCEL = 3;</code>
3739        */
3740       CANCEL(1, 3),
3741       ;
3742
3743       /**
3744        * <code>ADD = 1;</code>
3745        */
3746       public static final int ADD_VALUE = 1;
3747       /**
3748        * <code>CANCEL = 3;</code>
3749        */
3750       public static final int CANCEL_VALUE = 3;
3751
3752
3753       public final int getNumber() { return value; }
3754
3755       public static Action valueOf(int value) {
3756         switch (value) {
3757           case 1: return ADD;
3758           case 3: return CANCEL;
3759           default: return null;
3760         }
3761       }
3762
3763       public static com.google.protobuf.Internal.EnumLiteMap<Action>
3764           internalGetValueMap() {
3765         return internalValueMap;
3766       }
3767       private static com.google.protobuf.Internal.EnumLiteMap<Action>
3768           internalValueMap =
3769             new com.google.protobuf.Internal.EnumLiteMap<Action>() {
3770               public Action findValueByNumber(int number) {
3771                 return Action.valueOf(number);
3772               }
3773             };
3774
3775       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3776           getValueDescriptor() {
3777         return getDescriptor().getValues().get(index);
3778       }
3779       public final com.google.protobuf.Descriptors.EnumDescriptor
3780           getDescriptorForType() {
3781         return getDescriptor();
3782       }
3783       public static final com.google.protobuf.Descriptors.EnumDescriptor
3784           getDescriptor() {
3785         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(1);
3786       }
3787
3788       private static final Action[] VALUES = values();
3789
3790       public static Action valueOf(
3791           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3792         if (desc.getType() != getDescriptor()) {
3793           throw new java.lang.IllegalArgumentException(
3794             "EnumValueDescriptor is not for this type.");
3795         }
3796         return VALUES[desc.getIndex()];
3797       }
3798
3799       private final int index;
3800       private final int value;
3801
3802       private Action(int index, int value) {
3803         this.index = index;
3804         this.value = value;
3805       }
3806
3807       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.Action)
3808     }
3809
3810     private int bitField0_;
3811     // optional int32 bus = 1;
3812     public static final int BUS_FIELD_NUMBER = 1;
3813     private int bus_;
3814     /**
3815      * <code>optional int32 bus = 1;</code>
3816      */
3817     public boolean hasBus() {
3818       return ((bitField0_ & 0x00000001) == 0x00000001);
3819     }
3820     /**
3821      * <code>optional int32 bus = 1;</code>
3822      */
3823     public int getBus() {
3824       return bus_;
3825     }
3826
3827     // optional uint32 message_id = 2;
3828     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
3829     private int messageId_;
3830     /**
3831      * <code>optional uint32 message_id = 2;</code>
3832      */
3833     public boolean hasMessageId() {
3834       return ((bitField0_ & 0x00000002) == 0x00000002);
3835     }
3836     /**
3837      * <code>optional uint32 message_id = 2;</code>
3838      */
3839     public int getMessageId() {
3840       return messageId_;
3841     }
3842
3843     // optional uint32 mode = 3;
3844     public static final int MODE_FIELD_NUMBER = 3;
3845     private int mode_;
3846     /**
3847      * <code>optional uint32 mode = 3;</code>
3848      */
3849     public boolean hasMode() {
3850       return ((bitField0_ & 0x00000004) == 0x00000004);
3851     }
3852     /**
3853      * <code>optional uint32 mode = 3;</code>
3854      */
3855     public int getMode() {
3856       return mode_;
3857     }
3858
3859     // optional uint32 pid = 4;
3860     public static final int PID_FIELD_NUMBER = 4;
3861     private int pid_;
3862     /**
3863      * <code>optional uint32 pid = 4;</code>
3864      */
3865     public boolean hasPid() {
3866       return ((bitField0_ & 0x00000008) == 0x00000008);
3867     }
3868     /**
3869      * <code>optional uint32 pid = 4;</code>
3870      */
3871     public int getPid() {
3872       return pid_;
3873     }
3874
3875     // optional bytes payload = 5;
3876     public static final int PAYLOAD_FIELD_NUMBER = 5;
3877     private com.google.protobuf.ByteString payload_;
3878     /**
3879      * <code>optional bytes payload = 5;</code>
3880      *
3881      * <pre>
3882      * TODO we are capping this at 8 bytes for now - need to change when we
3883      * support multi-frame responses
3884      * </pre>
3885      */
3886     public boolean hasPayload() {
3887       return ((bitField0_ & 0x00000010) == 0x00000010);
3888     }
3889     /**
3890      * <code>optional bytes payload = 5;</code>
3891      *
3892      * <pre>
3893      * TODO we are capping this at 8 bytes for now - need to change when we
3894      * support multi-frame responses
3895      * </pre>
3896      */
3897     public com.google.protobuf.ByteString getPayload() {
3898       return payload_;
3899     }
3900
3901     // optional bool multiple_responses = 6;
3902     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
3903     private boolean multipleResponses_;
3904     /**
3905      * <code>optional bool multiple_responses = 6;</code>
3906      */
3907     public boolean hasMultipleResponses() {
3908       return ((bitField0_ & 0x00000020) == 0x00000020);
3909     }
3910     /**
3911      * <code>optional bool multiple_responses = 6;</code>
3912      */
3913     public boolean getMultipleResponses() {
3914       return multipleResponses_;
3915     }
3916
3917     // optional double frequency = 7;
3918     public static final int FREQUENCY_FIELD_NUMBER = 7;
3919     private double frequency_;
3920     /**
3921      * <code>optional double frequency = 7;</code>
3922      */
3923     public boolean hasFrequency() {
3924       return ((bitField0_ & 0x00000040) == 0x00000040);
3925     }
3926     /**
3927      * <code>optional double frequency = 7;</code>
3928      */
3929     public double getFrequency() {
3930       return frequency_;
3931     }
3932
3933     // optional string name = 8;
3934     public static final int NAME_FIELD_NUMBER = 8;
3935     private java.lang.Object name_;
3936     /**
3937      * <code>optional string name = 8;</code>
3938      */
3939     public boolean hasName() {
3940       return ((bitField0_ & 0x00000080) == 0x00000080);
3941     }
3942     /**
3943      * <code>optional string name = 8;</code>
3944      */
3945     public java.lang.String getName() {
3946       java.lang.Object ref = name_;
3947       if (ref instanceof java.lang.String) {
3948         return (java.lang.String) ref;
3949       } else {
3950         com.google.protobuf.ByteString bs =
3951             (com.google.protobuf.ByteString) ref;
3952         java.lang.String s = bs.toStringUtf8();
3953         if (bs.isValidUtf8()) {
3954           name_ = s;
3955         }
3956         return s;
3957       }
3958     }
3959     /**
3960      * <code>optional string name = 8;</code>
3961      */
3962     public com.google.protobuf.ByteString
3963         getNameBytes() {
3964       java.lang.Object ref = name_;
3965       if (ref instanceof java.lang.String) {
3966         com.google.protobuf.ByteString b =
3967             com.google.protobuf.ByteString.copyFromUtf8(
3968                 (java.lang.String) ref);
3969         name_ = b;
3970         return b;
3971       } else {
3972         return (com.google.protobuf.ByteString) ref;
3973       }
3974     }
3975
3976     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
3977     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
3978     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
3979     /**
3980      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3981      */
3982     public boolean hasDecodedType() {
3983       return ((bitField0_ & 0x00000100) == 0x00000100);
3984     }
3985     /**
3986      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3987      */
3988     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
3989       return decodedType_;
3990     }
3991
3992     // optional .openxc.DiagnosticRequest.Action action = 10;
3993     public static final int ACTION_FIELD_NUMBER = 10;
3994     private com.openxc.BinaryMessages.DiagnosticRequest.Action action_;
3995     /**
3996      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3997      */
3998     public boolean hasAction() {
3999       return ((bitField0_ & 0x00000200) == 0x00000200);
4000     }
4001     /**
4002      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4003      */
4004     public com.openxc.BinaryMessages.DiagnosticRequest.Action getAction() {
4005       return action_;
4006     }
4007
4008     private void initFields() {
4009       bus_ = 0;
4010       messageId_ = 0;
4011       mode_ = 0;
4012       pid_ = 0;
4013       payload_ = com.google.protobuf.ByteString.EMPTY;
4014       multipleResponses_ = false;
4015       frequency_ = 0D;
4016       name_ = "";
4017       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4018       action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
4019     }
4020     private byte memoizedIsInitialized = -1;
4021     public final boolean isInitialized() {
4022       byte isInitialized = memoizedIsInitialized;
4023       if (isInitialized != -1) return isInitialized == 1;
4024
4025       memoizedIsInitialized = 1;
4026       return true;
4027     }
4028
4029     public void writeTo(com.google.protobuf.CodedOutputStream output)
4030                         throws java.io.IOException {
4031       getSerializedSize();
4032       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4033         output.writeInt32(1, bus_);
4034       }
4035       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4036         output.writeUInt32(2, messageId_);
4037       }
4038       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4039         output.writeUInt32(3, mode_);
4040       }
4041       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4042         output.writeUInt32(4, pid_);
4043       }
4044       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4045         output.writeBytes(5, payload_);
4046       }
4047       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4048         output.writeBool(6, multipleResponses_);
4049       }
4050       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4051         output.writeDouble(7, frequency_);
4052       }
4053       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4054         output.writeBytes(8, getNameBytes());
4055       }
4056       if (((bitField0_ & 0x00000100) == 0x00000100)) {
4057         output.writeEnum(9, decodedType_.getNumber());
4058       }
4059       if (((bitField0_ & 0x00000200) == 0x00000200)) {
4060         output.writeEnum(10, action_.getNumber());
4061       }
4062       getUnknownFields().writeTo(output);
4063     }
4064
4065     private int memoizedSerializedSize = -1;
4066     public int getSerializedSize() {
4067       int size = memoizedSerializedSize;
4068       if (size != -1) return size;
4069
4070       size = 0;
4071       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4072         size += com.google.protobuf.CodedOutputStream
4073           .computeInt32Size(1, bus_);
4074       }
4075       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4076         size += com.google.protobuf.CodedOutputStream
4077           .computeUInt32Size(2, messageId_);
4078       }
4079       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4080         size += com.google.protobuf.CodedOutputStream
4081           .computeUInt32Size(3, mode_);
4082       }
4083       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4084         size += com.google.protobuf.CodedOutputStream
4085           .computeUInt32Size(4, pid_);
4086       }
4087       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4088         size += com.google.protobuf.CodedOutputStream
4089           .computeBytesSize(5, payload_);
4090       }
4091       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4092         size += com.google.protobuf.CodedOutputStream
4093           .computeBoolSize(6, multipleResponses_);
4094       }
4095       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4096         size += com.google.protobuf.CodedOutputStream
4097           .computeDoubleSize(7, frequency_);
4098       }
4099       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4100         size += com.google.protobuf.CodedOutputStream
4101           .computeBytesSize(8, getNameBytes());
4102       }
4103       if (((bitField0_ & 0x00000100) == 0x00000100)) {
4104         size += com.google.protobuf.CodedOutputStream
4105           .computeEnumSize(9, decodedType_.getNumber());
4106       }
4107       if (((bitField0_ & 0x00000200) == 0x00000200)) {
4108         size += com.google.protobuf.CodedOutputStream
4109           .computeEnumSize(10, action_.getNumber());
4110       }
4111       size += getUnknownFields().getSerializedSize();
4112       memoizedSerializedSize = size;
4113       return size;
4114     }
4115
4116     private static final long serialVersionUID = 0L;
4117     @java.lang.Override
4118     protected java.lang.Object writeReplace()
4119         throws java.io.ObjectStreamException {
4120       return super.writeReplace();
4121     }
4122
4123     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4124         com.google.protobuf.ByteString data)
4125         throws com.google.protobuf.InvalidProtocolBufferException {
4126       return PARSER.parseFrom(data);
4127     }
4128     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4129         com.google.protobuf.ByteString data,
4130         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4131         throws com.google.protobuf.InvalidProtocolBufferException {
4132       return PARSER.parseFrom(data, extensionRegistry);
4133     }
4134     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
4135         throws com.google.protobuf.InvalidProtocolBufferException {
4136       return PARSER.parseFrom(data);
4137     }
4138     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4139         byte[] data,
4140         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4141         throws com.google.protobuf.InvalidProtocolBufferException {
4142       return PARSER.parseFrom(data, extensionRegistry);
4143     }
4144     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
4145         throws java.io.IOException {
4146       return PARSER.parseFrom(input);
4147     }
4148     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4149         java.io.InputStream input,
4150         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4151         throws java.io.IOException {
4152       return PARSER.parseFrom(input, extensionRegistry);
4153     }
4154     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
4155         throws java.io.IOException {
4156       return PARSER.parseDelimitedFrom(input);
4157     }
4158     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
4159         java.io.InputStream input,
4160         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4161         throws java.io.IOException {
4162       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4163     }
4164     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4165         com.google.protobuf.CodedInputStream input)
4166         throws java.io.IOException {
4167       return PARSER.parseFrom(input);
4168     }
4169     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4170         com.google.protobuf.CodedInputStream input,
4171         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4172         throws java.io.IOException {
4173       return PARSER.parseFrom(input, extensionRegistry);
4174     }
4175
4176     public static Builder newBuilder() { return Builder.create(); }
4177     public Builder newBuilderForType() { return newBuilder(); }
4178     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
4179       return newBuilder().mergeFrom(prototype);
4180     }
4181     public Builder toBuilder() { return newBuilder(this); }
4182
4183     @java.lang.Override
4184     protected Builder newBuilderForType(
4185         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4186       Builder builder = new Builder(parent);
4187       return builder;
4188     }
4189     /**
4190      * Protobuf type {@code openxc.DiagnosticRequest}
4191      */
4192     public static final class Builder extends
4193         com.google.protobuf.GeneratedMessage.Builder<Builder>
4194        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
4195       public static final com.google.protobuf.Descriptors.Descriptor
4196           getDescriptor() {
4197         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4198       }
4199
4200       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4201           internalGetFieldAccessorTable() {
4202         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
4203             .ensureFieldAccessorsInitialized(
4204                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
4205       }
4206
4207       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
4208       private Builder() {
4209         maybeForceBuilderInitialization();
4210       }
4211
4212       private Builder(
4213           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4214         super(parent);
4215         maybeForceBuilderInitialization();
4216       }
4217       private void maybeForceBuilderInitialization() {
4218         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4219         }
4220       }
4221       private static Builder create() {
4222         return new Builder();
4223       }
4224
4225       public Builder clear() {
4226         super.clear();
4227         bus_ = 0;
4228         bitField0_ = (bitField0_ & ~0x00000001);
4229         messageId_ = 0;
4230         bitField0_ = (bitField0_ & ~0x00000002);
4231         mode_ = 0;
4232         bitField0_ = (bitField0_ & ~0x00000004);
4233         pid_ = 0;
4234         bitField0_ = (bitField0_ & ~0x00000008);
4235         payload_ = com.google.protobuf.ByteString.EMPTY;
4236         bitField0_ = (bitField0_ & ~0x00000010);
4237         multipleResponses_ = false;
4238         bitField0_ = (bitField0_ & ~0x00000020);
4239         frequency_ = 0D;
4240         bitField0_ = (bitField0_ & ~0x00000040);
4241         name_ = "";
4242         bitField0_ = (bitField0_ & ~0x00000080);
4243         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4244         bitField0_ = (bitField0_ & ~0x00000100);
4245         action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
4246         bitField0_ = (bitField0_ & ~0x00000200);
4247         return this;
4248       }
4249
4250       public Builder clone() {
4251         return create().mergeFrom(buildPartial());
4252       }
4253
4254       public com.google.protobuf.Descriptors.Descriptor
4255           getDescriptorForType() {
4256         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4257       }
4258
4259       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
4260         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4261       }
4262
4263       public com.openxc.BinaryMessages.DiagnosticRequest build() {
4264         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
4265         if (!result.isInitialized()) {
4266           throw newUninitializedMessageException(result);
4267         }
4268         return result;
4269       }
4270
4271       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
4272         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
4273         int from_bitField0_ = bitField0_;
4274         int to_bitField0_ = 0;
4275         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4276           to_bitField0_ |= 0x00000001;
4277         }
4278         result.bus_ = bus_;
4279         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4280           to_bitField0_ |= 0x00000002;
4281         }
4282         result.messageId_ = messageId_;
4283         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4284           to_bitField0_ |= 0x00000004;
4285         }
4286         result.mode_ = mode_;
4287         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
4288           to_bitField0_ |= 0x00000008;
4289         }
4290         result.pid_ = pid_;
4291         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
4292           to_bitField0_ |= 0x00000010;
4293         }
4294         result.payload_ = payload_;
4295         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
4296           to_bitField0_ |= 0x00000020;
4297         }
4298         result.multipleResponses_ = multipleResponses_;
4299         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
4300           to_bitField0_ |= 0x00000040;
4301         }
4302         result.frequency_ = frequency_;
4303         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
4304           to_bitField0_ |= 0x00000080;
4305         }
4306         result.name_ = name_;
4307         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
4308           to_bitField0_ |= 0x00000100;
4309         }
4310         result.decodedType_ = decodedType_;
4311         if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
4312           to_bitField0_ |= 0x00000200;
4313         }
4314         result.action_ = action_;
4315         result.bitField0_ = to_bitField0_;
4316         onBuilt();
4317         return result;
4318       }
4319
4320       public Builder mergeFrom(com.google.protobuf.Message other) {
4321         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
4322           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
4323         } else {
4324           super.mergeFrom(other);
4325           return this;
4326         }
4327       }
4328
4329       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
4330         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
4331         if (other.hasBus()) {
4332           setBus(other.getBus());
4333         }
4334         if (other.hasMessageId()) {
4335           setMessageId(other.getMessageId());
4336         }
4337         if (other.hasMode()) {
4338           setMode(other.getMode());
4339         }
4340         if (other.hasPid()) {
4341           setPid(other.getPid());
4342         }
4343         if (other.hasPayload()) {
4344           setPayload(other.getPayload());
4345         }
4346         if (other.hasMultipleResponses()) {
4347           setMultipleResponses(other.getMultipleResponses());
4348         }
4349         if (other.hasFrequency()) {
4350           setFrequency(other.getFrequency());
4351         }
4352         if (other.hasName()) {
4353           bitField0_ |= 0x00000080;
4354           name_ = other.name_;
4355           onChanged();
4356         }
4357         if (other.hasDecodedType()) {
4358           setDecodedType(other.getDecodedType());
4359         }
4360         if (other.hasAction()) {
4361           setAction(other.getAction());
4362         }
4363         this.mergeUnknownFields(other.getUnknownFields());
4364         return this;
4365       }
4366
4367       public final boolean isInitialized() {
4368         return true;
4369       }
4370
4371       public Builder mergeFrom(
4372           com.google.protobuf.CodedInputStream input,
4373           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4374           throws java.io.IOException {
4375         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
4376         try {
4377           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4378         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4379           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
4380           throw e;
4381         } finally {
4382           if (parsedMessage != null) {
4383             mergeFrom(parsedMessage);
4384           }
4385         }
4386         return this;
4387       }
4388       private int bitField0_;
4389
4390       // optional int32 bus = 1;
4391       private int bus_ ;
4392       /**
4393        * <code>optional int32 bus = 1;</code>
4394        */
4395       public boolean hasBus() {
4396         return ((bitField0_ & 0x00000001) == 0x00000001);
4397       }
4398       /**
4399        * <code>optional int32 bus = 1;</code>
4400        */
4401       public int getBus() {
4402         return bus_;
4403       }
4404       /**
4405        * <code>optional int32 bus = 1;</code>
4406        */
4407       public Builder setBus(int value) {
4408         bitField0_ |= 0x00000001;
4409         bus_ = value;
4410         onChanged();
4411         return this;
4412       }
4413       /**
4414        * <code>optional int32 bus = 1;</code>
4415        */
4416       public Builder clearBus() {
4417         bitField0_ = (bitField0_ & ~0x00000001);
4418         bus_ = 0;
4419         onChanged();
4420         return this;
4421       }
4422
4423       // optional uint32 message_id = 2;
4424       private int messageId_ ;
4425       /**
4426        * <code>optional uint32 message_id = 2;</code>
4427        */
4428       public boolean hasMessageId() {
4429         return ((bitField0_ & 0x00000002) == 0x00000002);
4430       }
4431       /**
4432        * <code>optional uint32 message_id = 2;</code>
4433        */
4434       public int getMessageId() {
4435         return messageId_;
4436       }
4437       /**
4438        * <code>optional uint32 message_id = 2;</code>
4439        */
4440       public Builder setMessageId(int value) {
4441         bitField0_ |= 0x00000002;
4442         messageId_ = value;
4443         onChanged();
4444         return this;
4445       }
4446       /**
4447        * <code>optional uint32 message_id = 2;</code>
4448        */
4449       public Builder clearMessageId() {
4450         bitField0_ = (bitField0_ & ~0x00000002);
4451         messageId_ = 0;
4452         onChanged();
4453         return this;
4454       }
4455
4456       // optional uint32 mode = 3;
4457       private int mode_ ;
4458       /**
4459        * <code>optional uint32 mode = 3;</code>
4460        */
4461       public boolean hasMode() {
4462         return ((bitField0_ & 0x00000004) == 0x00000004);
4463       }
4464       /**
4465        * <code>optional uint32 mode = 3;</code>
4466        */
4467       public int getMode() {
4468         return mode_;
4469       }
4470       /**
4471        * <code>optional uint32 mode = 3;</code>
4472        */
4473       public Builder setMode(int value) {
4474         bitField0_ |= 0x00000004;
4475         mode_ = value;
4476         onChanged();
4477         return this;
4478       }
4479       /**
4480        * <code>optional uint32 mode = 3;</code>
4481        */
4482       public Builder clearMode() {
4483         bitField0_ = (bitField0_ & ~0x00000004);
4484         mode_ = 0;
4485         onChanged();
4486         return this;
4487       }
4488
4489       // optional uint32 pid = 4;
4490       private int pid_ ;
4491       /**
4492        * <code>optional uint32 pid = 4;</code>
4493        */
4494       public boolean hasPid() {
4495         return ((bitField0_ & 0x00000008) == 0x00000008);
4496       }
4497       /**
4498        * <code>optional uint32 pid = 4;</code>
4499        */
4500       public int getPid() {
4501         return pid_;
4502       }
4503       /**
4504        * <code>optional uint32 pid = 4;</code>
4505        */
4506       public Builder setPid(int value) {
4507         bitField0_ |= 0x00000008;
4508         pid_ = value;
4509         onChanged();
4510         return this;
4511       }
4512       /**
4513        * <code>optional uint32 pid = 4;</code>
4514        */
4515       public Builder clearPid() {
4516         bitField0_ = (bitField0_ & ~0x00000008);
4517         pid_ = 0;
4518         onChanged();
4519         return this;
4520       }
4521
4522       // optional bytes payload = 5;
4523       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
4524       /**
4525        * <code>optional bytes payload = 5;</code>
4526        *
4527        * <pre>
4528        * TODO we are capping this at 8 bytes for now - need to change when we
4529        * support multi-frame responses
4530        * </pre>
4531        */
4532       public boolean hasPayload() {
4533         return ((bitField0_ & 0x00000010) == 0x00000010);
4534       }
4535       /**
4536        * <code>optional bytes payload = 5;</code>
4537        *
4538        * <pre>
4539        * TODO we are capping this at 8 bytes for now - need to change when we
4540        * support multi-frame responses
4541        * </pre>
4542        */
4543       public com.google.protobuf.ByteString getPayload() {
4544         return payload_;
4545       }
4546       /**
4547        * <code>optional bytes payload = 5;</code>
4548        *
4549        * <pre>
4550        * TODO we are capping this at 8 bytes for now - need to change when we
4551        * support multi-frame responses
4552        * </pre>
4553        */
4554       public Builder setPayload(com.google.protobuf.ByteString value) {
4555         if (value == null) {
4556     throw new NullPointerException();
4557   }
4558   bitField0_ |= 0x00000010;
4559         payload_ = value;
4560         onChanged();
4561         return this;
4562       }
4563       /**
4564        * <code>optional bytes payload = 5;</code>
4565        *
4566        * <pre>
4567        * TODO we are capping this at 8 bytes for now - need to change when we
4568        * support multi-frame responses
4569        * </pre>
4570        */
4571       public Builder clearPayload() {
4572         bitField0_ = (bitField0_ & ~0x00000010);
4573         payload_ = getDefaultInstance().getPayload();
4574         onChanged();
4575         return this;
4576       }
4577
4578       // optional bool multiple_responses = 6;
4579       private boolean multipleResponses_ ;
4580       /**
4581        * <code>optional bool multiple_responses = 6;</code>
4582        */
4583       public boolean hasMultipleResponses() {
4584         return ((bitField0_ & 0x00000020) == 0x00000020);
4585       }
4586       /**
4587        * <code>optional bool multiple_responses = 6;</code>
4588        */
4589       public boolean getMultipleResponses() {
4590         return multipleResponses_;
4591       }
4592       /**
4593        * <code>optional bool multiple_responses = 6;</code>
4594        */
4595       public Builder setMultipleResponses(boolean value) {
4596         bitField0_ |= 0x00000020;
4597         multipleResponses_ = value;
4598         onChanged();
4599         return this;
4600       }
4601       /**
4602        * <code>optional bool multiple_responses = 6;</code>
4603        */
4604       public Builder clearMultipleResponses() {
4605         bitField0_ = (bitField0_ & ~0x00000020);
4606         multipleResponses_ = false;
4607         onChanged();
4608         return this;
4609       }
4610
4611       // optional double frequency = 7;
4612       private double frequency_ ;
4613       /**
4614        * <code>optional double frequency = 7;</code>
4615        */
4616       public boolean hasFrequency() {
4617         return ((bitField0_ & 0x00000040) == 0x00000040);
4618       }
4619       /**
4620        * <code>optional double frequency = 7;</code>
4621        */
4622       public double getFrequency() {
4623         return frequency_;
4624       }
4625       /**
4626        * <code>optional double frequency = 7;</code>
4627        */
4628       public Builder setFrequency(double value) {
4629         bitField0_ |= 0x00000040;
4630         frequency_ = value;
4631         onChanged();
4632         return this;
4633       }
4634       /**
4635        * <code>optional double frequency = 7;</code>
4636        */
4637       public Builder clearFrequency() {
4638         bitField0_ = (bitField0_ & ~0x00000040);
4639         frequency_ = 0D;
4640         onChanged();
4641         return this;
4642       }
4643
4644       // optional string name = 8;
4645       private java.lang.Object name_ = "";
4646       /**
4647        * <code>optional string name = 8;</code>
4648        */
4649       public boolean hasName() {
4650         return ((bitField0_ & 0x00000080) == 0x00000080);
4651       }
4652       /**
4653        * <code>optional string name = 8;</code>
4654        */
4655       public java.lang.String getName() {
4656         java.lang.Object ref = name_;
4657         if (!(ref instanceof java.lang.String)) {
4658           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4659               .toStringUtf8();
4660           name_ = s;
4661           return s;
4662         } else {
4663           return (java.lang.String) ref;
4664         }
4665       }
4666       /**
4667        * <code>optional string name = 8;</code>
4668        */
4669       public com.google.protobuf.ByteString
4670           getNameBytes() {
4671         java.lang.Object ref = name_;
4672         if (ref instanceof String) {
4673           com.google.protobuf.ByteString b =
4674               com.google.protobuf.ByteString.copyFromUtf8(
4675                   (java.lang.String) ref);
4676           name_ = b;
4677           return b;
4678         } else {
4679           return (com.google.protobuf.ByteString) ref;
4680         }
4681       }
4682       /**
4683        * <code>optional string name = 8;</code>
4684        */
4685       public Builder setName(
4686           java.lang.String value) {
4687         if (value == null) {
4688     throw new NullPointerException();
4689   }
4690   bitField0_ |= 0x00000080;
4691         name_ = value;
4692         onChanged();
4693         return this;
4694       }
4695       /**
4696        * <code>optional string name = 8;</code>
4697        */
4698       public Builder clearName() {
4699         bitField0_ = (bitField0_ & ~0x00000080);
4700         name_ = getDefaultInstance().getName();
4701         onChanged();
4702         return this;
4703       }
4704       /**
4705        * <code>optional string name = 8;</code>
4706        */
4707       public Builder setNameBytes(
4708           com.google.protobuf.ByteString value) {
4709         if (value == null) {
4710     throw new NullPointerException();
4711   }
4712   bitField0_ |= 0x00000080;
4713         name_ = value;
4714         onChanged();
4715         return this;
4716       }
4717
4718       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
4719       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4720       /**
4721        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4722        */
4723       public boolean hasDecodedType() {
4724         return ((bitField0_ & 0x00000100) == 0x00000100);
4725       }
4726       /**
4727        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4728        */
4729       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
4730         return decodedType_;
4731       }
4732       /**
4733        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4734        */
4735       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
4736         if (value == null) {
4737           throw new NullPointerException();
4738         }
4739         bitField0_ |= 0x00000100;
4740         decodedType_ = value;
4741         onChanged();
4742         return this;
4743       }
4744       /**
4745        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4746        */
4747       public Builder clearDecodedType() {
4748         bitField0_ = (bitField0_ & ~0x00000100);
4749         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4750         onChanged();
4751         return this;
4752       }
4753
4754       // optional .openxc.DiagnosticRequest.Action action = 10;
4755       private com.openxc.BinaryMessages.DiagnosticRequest.Action action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
4756       /**
4757        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4758        */
4759       public boolean hasAction() {
4760         return ((bitField0_ & 0x00000200) == 0x00000200);
4761       }
4762       /**
4763        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4764        */
4765       public com.openxc.BinaryMessages.DiagnosticRequest.Action getAction() {
4766         return action_;
4767       }
4768       /**
4769        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4770        */
4771       public Builder setAction(com.openxc.BinaryMessages.DiagnosticRequest.Action value) {
4772         if (value == null) {
4773           throw new NullPointerException();
4774         }
4775         bitField0_ |= 0x00000200;
4776         action_ = value;
4777         onChanged();
4778         return this;
4779       }
4780       /**
4781        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4782        */
4783       public Builder clearAction() {
4784         bitField0_ = (bitField0_ & ~0x00000200);
4785         action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
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\"\246\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\"2\n\004Type\022\013\n\007VERSION\020\001\022\r\n\tDEVICE_I" +
7749       "D\020\002\022\016\n\nDIAGNOSTIC\020\003\"]\n\017CommandResponse\022)" +
7750       "\n\004type\030\001 \001(\0162\033.openxc.ControlCommand.Typ" +
7751       "e\022\017\n\007message\030\002 \001(\t\022\016\n\006status\030\003 \001(\010\"\316\002\n\021D" +
7752       "iagnosticRequest\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage",
7753       "_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007" +
7754       "payload\030\005 \001(\014\022\032\n\022multiple_responses\030\006 \001(" +
7755       "\010\022\021\n\tfrequency\030\007 \001(\001\022\014\n\004name\030\010 \001(\t\022;\n\014de" +
7756       "coded_type\030\t \001(\0162%.openxc.DiagnosticRequ" +
7757       "est.DecodedType\0220\n\006action\030\n \001(\0162 .openxc" +
7758       ".DiagnosticRequest.Action\"!\n\013DecodedType" +
7759       "\022\010\n\004NONE\020\001\022\010\n\004OBD2\020\002\"\035\n\006Action\022\007\n\003ADD\020\001\022" +
7760       "\n\n\006CANCEL\020\003\"\241\001\n\022DiagnosticResponse\022\013\n\003bu" +
7761       "s\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(" +
7762       "\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005 \001(\010\022\036\n\026negat",
7763       "ive_response_code\030\006 \001(\r\022\017\n\007payload\030\007 \001(\014" +
7764       "\022\r\n\005value\030\010 \001(\001\"\242\001\n\014DynamicField\022\'\n\004type" +
7765       "\030\001 \001(\0162\031.openxc.DynamicField.Type\022\024\n\014str" +
7766       "ing_value\030\002 \001(\t\022\025\n\rnumeric_value\030\003 \001(\001\022\025" +
7767       "\n\rboolean_value\030\004 \001(\010\"%\n\004Type\022\n\n\006STRING\020" +
7768       "\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\"\367\001\n\021TranslatedMessa" +
7769       "ge\022,\n\004type\030\001 \001(\0162\036.openxc.TranslatedMess" +
7770       "age.Type\022\014\n\004name\030\002 \001(\t\022#\n\005value\030\003 \001(\0132\024." +
7771       "openxc.DynamicField\022#\n\005event\030\004 \001(\0132\024.ope" +
7772       "nxc.DynamicField\"\\\n\004Type\022\n\n\006STRING\020\001\022\007\n\003",
7773       "NUM\020\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTED_STRING\020\004\022\017\n\013E" +
7774       "VENTED_NUM\020\005\022\020\n\014EVENTED_BOOL\020\006B\034\n\ncom.op" +
7775       "enxcB\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", });
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", "Action", });
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 }