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