gen/java/com/openxc/BinaryMessages.java

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