gen/java/com/openxc/BinaryMessages.java

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