gen/java/com/openxc/BinaryMessages.java

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