gen/java/com/openxc/BinaryMessages.java

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: openxc.proto
   3
   4 package com.openxc;
   5
   6 public final class BinaryMessages {
   7   private BinaryMessages() {}
   8   public static void registerAllExtensions(
   9       com.google.protobuf.ExtensionRegistry registry) {
  10   }
  11   public interface VehicleMessageOrBuilder
  12       extends com.google.protobuf.MessageOrBuilder {
  13
  14     // optional .openxc.VehicleMessage.Type type = 1;
  15     /**
  16      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
  17      */
  18     boolean hasType();
  19     /**
  20      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
  21      */
  22     com.openxc.BinaryMessages.VehicleMessage.Type getType();
  23
  24     // optional .openxc.RawMessage raw_message = 2;
  25     /**
  26      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  27      */
  28     boolean hasRawMessage();
  29     /**
  30      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  31      */
  32     com.openxc.BinaryMessages.RawMessage getRawMessage();
  33     /**
  34      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  35      */
  36     com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder();
  37
  38     // optional .openxc.TranslatedMessage translated_message = 3;
  39     /**
  40      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  41      */
  42     boolean hasTranslatedMessage();
  43     /**
  44      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  45      */
  46     com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage();
  47     /**
  48      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  49      */
  50     com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder();
  51
  52     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
  53     /**
  54      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  55      */
  56     boolean hasDiagnosticResponse();
  57     /**
  58      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  59      */
  60     com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse();
  61     /**
  62      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  63      */
  64     com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder();
  65
  66     // optional .openxc.ControlCommand control_command = 5;
  67     /**
  68      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  69      */
  70     boolean hasControlCommand();
  71     /**
  72      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  73      */
  74     com.openxc.BinaryMessages.ControlCommand getControlCommand();
  75     /**
  76      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  77      */
  78     com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder();
  79
  80     // optional .openxc.CommandResponse command_response = 6;
  81     /**
  82      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  83      */
  84     boolean hasCommandResponse();
  85     /**
  86      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  87      */
  88     com.openxc.BinaryMessages.CommandResponse getCommandResponse();
  89     /**
  90      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  91      */
  92     com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder();
  93   }
  94   /**
  95    * Protobuf type {@code openxc.VehicleMessage}
  96    */
  97   public static final class VehicleMessage extends
  98       com.google.protobuf.GeneratedMessage
  99       implements VehicleMessageOrBuilder {
 100     // Use VehicleMessage.newBuilder() to construct.
 101     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 102       super(builder);
 103       this.unknownFields = builder.getUnknownFields();
 104     }
 105     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 106
 107     private static final VehicleMessage defaultInstance;
 108     public static VehicleMessage getDefaultInstance() {
 109       return defaultInstance;
 110     }
 111
 112     public VehicleMessage getDefaultInstanceForType() {
 113       return defaultInstance;
 114     }
 115
 116     private final com.google.protobuf.UnknownFieldSet unknownFields;
 117     @java.lang.Override
 118     public final com.google.protobuf.UnknownFieldSet
 119         getUnknownFields() {
 120       return this.unknownFields;
 121     }
 122     private VehicleMessage(
 123         com.google.protobuf.CodedInputStream input,
 124         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 125         throws com.google.protobuf.InvalidProtocolBufferException {
 126       initFields();
 127       int mutable_bitField0_ = 0;
 128       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 129           com.google.protobuf.UnknownFieldSet.newBuilder();
 130       try {
 131         boolean done = false;
 132         while (!done) {
 133           int tag = input.readTag();
 134           switch (tag) {
 135             case 0:
 136               done = true;
 137               break;
 138             default: {
 139               if (!parseUnknownField(input, unknownFields,
 140                                      extensionRegistry, tag)) {
 141                 done = true;
 142               }
 143               break;
 144             }
 145             case 8: {
 146               int rawValue = input.readEnum();
 147               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 148               if (value == null) {
 149                 unknownFields.mergeVarintField(1, rawValue);
 150               } else {
 151                 bitField0_ |= 0x00000001;
 152                 type_ = value;
 153               }
 154               break;
 155             }
 156             case 18: {
 157               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
 158               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 159                 subBuilder = rawMessage_.toBuilder();
 160               }
 161               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
 162               if (subBuilder != null) {
 163                 subBuilder.mergeFrom(rawMessage_);
 164                 rawMessage_ = subBuilder.buildPartial();
 165               }
 166               bitField0_ |= 0x00000002;
 167               break;
 168             }
 169             case 26: {
 170               com.openxc.BinaryMessages.TranslatedMessage.Builder subBuilder = null;
 171               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 172                 subBuilder = translatedMessage_.toBuilder();
 173               }
 174               translatedMessage_ = input.readMessage(com.openxc.BinaryMessages.TranslatedMessage.PARSER, extensionRegistry);
 175               if (subBuilder != null) {
 176                 subBuilder.mergeFrom(translatedMessage_);
 177                 translatedMessage_ = subBuilder.buildPartial();
 178               }
 179               bitField0_ |= 0x00000004;
 180               break;
 181             }
 182             case 34: {
 183               com.openxc.BinaryMessages.DiagnosticResponse.Builder subBuilder = null;
 184               if (((bitField0_ & 0x00000008) == 0x00000008)) {
 185                 subBuilder = diagnosticResponse_.toBuilder();
 186               }
 187               diagnosticResponse_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticResponse.PARSER, extensionRegistry);
 188               if (subBuilder != null) {
 189                 subBuilder.mergeFrom(diagnosticResponse_);
 190                 diagnosticResponse_ = subBuilder.buildPartial();
 191               }
 192               bitField0_ |= 0x00000008;
 193               break;
 194             }
 195             case 42: {
 196               com.openxc.BinaryMessages.ControlCommand.Builder subBuilder = null;
 197               if (((bitField0_ & 0x00000010) == 0x00000010)) {
 198                 subBuilder = controlCommand_.toBuilder();
 199               }
 200               controlCommand_ = input.readMessage(com.openxc.BinaryMessages.ControlCommand.PARSER, extensionRegistry);
 201               if (subBuilder != null) {
 202                 subBuilder.mergeFrom(controlCommand_);
 203                 controlCommand_ = subBuilder.buildPartial();
 204               }
 205               bitField0_ |= 0x00000010;
 206               break;
 207             }
 208             case 50: {
 209               com.openxc.BinaryMessages.CommandResponse.Builder subBuilder = null;
 210               if (((bitField0_ & 0x00000020) == 0x00000020)) {
 211                 subBuilder = commandResponse_.toBuilder();
 212               }
 213               commandResponse_ = input.readMessage(com.openxc.BinaryMessages.CommandResponse.PARSER, extensionRegistry);
 214               if (subBuilder != null) {
 215                 subBuilder.mergeFrom(commandResponse_);
 216                 commandResponse_ = subBuilder.buildPartial();
 217               }
 218               bitField0_ |= 0x00000020;
 219               break;
 220             }
 221           }
 222         }
 223       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 224         throw e.setUnfinishedMessage(this);
 225       } catch (java.io.IOException e) {
 226         throw new com.google.protobuf.InvalidProtocolBufferException(
 227             e.getMessage()).setUnfinishedMessage(this);
 228       } finally {
 229         this.unknownFields = unknownFields.build();
 230         makeExtensionsImmutable();
 231       }
 232     }
 233     public static final com.google.protobuf.Descriptors.Descriptor
 234         getDescriptor() {
 235       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 236     }
 237
 238     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 239         internalGetFieldAccessorTable() {
 240       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 241           .ensureFieldAccessorsInitialized(
 242               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 243     }
 244
 245     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 246         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 247       public VehicleMessage parsePartialFrom(
 248           com.google.protobuf.CodedInputStream input,
 249           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 250           throws com.google.protobuf.InvalidProtocolBufferException {
 251         return new VehicleMessage(input, extensionRegistry);
 252       }
 253     };
 254
 255     @java.lang.Override
 256     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 257       return PARSER;
 258     }
 259
 260     /**
 261      * Protobuf enum {@code openxc.VehicleMessage.Type}
 262      */
 263     public enum Type
 264         implements com.google.protobuf.ProtocolMessageEnum {
 265       /**
 266        * <code>RAW = 1;</code>
 267        */
 268       RAW(0, 1),
 269       /**
 270        * <code>TRANSLATED = 2;</code>
 271        */
 272       TRANSLATED(1, 2),
 273       /**
 274        * <code>DIAGNOSTIC = 3;</code>
 275        */
 276       DIAGNOSTIC(2, 3),
 277       /**
 278        * <code>CONTROL_COMMAND = 4;</code>
 279        */
 280       CONTROL_COMMAND(3, 4),
 281       /**
 282        * <code>COMMAND_RESPONSE = 5;</code>
 283        */
 284       COMMAND_RESPONSE(4, 5),
 285       ;
 286
 287       /**
 288        * <code>RAW = 1;</code>
 289        */
 290       public static final int RAW_VALUE = 1;
 291       /**
 292        * <code>TRANSLATED = 2;</code>
 293        */
 294       public static final int TRANSLATED_VALUE = 2;
 295       /**
 296        * <code>DIAGNOSTIC = 3;</code>
 297        */
 298       public static final int DIAGNOSTIC_VALUE = 3;
 299       /**
 300        * <code>CONTROL_COMMAND = 4;</code>
 301        */
 302       public static final int CONTROL_COMMAND_VALUE = 4;
 303       /**
 304        * <code>COMMAND_RESPONSE = 5;</code>
 305        */
 306       public static final int COMMAND_RESPONSE_VALUE = 5;
 307
 308
 309       public final int getNumber() { return value; }
 310
 311       public static Type valueOf(int value) {
 312         switch (value) {
 313           case 1: return RAW;
 314           case 2: return TRANSLATED;
 315           case 3: return DIAGNOSTIC;
 316           case 4: return CONTROL_COMMAND;
 317           case 5: return COMMAND_RESPONSE;
 318           default: return null;
 319         }
 320       }
 321
 322       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 323           internalGetValueMap() {
 324         return internalValueMap;
 325       }
 326       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 327           internalValueMap =
 328             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 329               public Type findValueByNumber(int number) {
 330                 return Type.valueOf(number);
 331               }
 332             };
 333
 334       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 335           getValueDescriptor() {
 336         return getDescriptor().getValues().get(index);
 337       }
 338       public final com.google.protobuf.Descriptors.EnumDescriptor
 339           getDescriptorForType() {
 340         return getDescriptor();
 341       }
 342       public static final com.google.protobuf.Descriptors.EnumDescriptor
 343           getDescriptor() {
 344         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 345       }
 346
 347       private static final Type[] VALUES = values();
 348
 349       public static Type valueOf(
 350           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 351         if (desc.getType() != getDescriptor()) {
 352           throw new java.lang.IllegalArgumentException(
 353             "EnumValueDescriptor is not for this type.");
 354         }
 355         return VALUES[desc.getIndex()];
 356       }
 357
 358       private final int index;
 359       private final int value;
 360
 361       private Type(int index, int value) {
 362         this.index = index;
 363         this.value = value;
 364       }
 365
 366       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 367     }
 368
 369     private int bitField0_;
 370     // optional .openxc.VehicleMessage.Type type = 1;
 371     public static final int TYPE_FIELD_NUMBER = 1;
 372     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 373     /**
 374      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 375      */
 376     public boolean hasType() {
 377       return ((bitField0_ & 0x00000001) == 0x00000001);
 378     }
 379     /**
 380      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 381      */
 382     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 383       return type_;
 384     }
 385
 386     // optional .openxc.RawMessage raw_message = 2;
 387     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
 388     private com.openxc.BinaryMessages.RawMessage rawMessage_;
 389     /**
 390      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 391      */
 392     public boolean hasRawMessage() {
 393       return ((bitField0_ & 0x00000002) == 0x00000002);
 394     }
 395     /**
 396      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 397      */
 398     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 399       return rawMessage_;
 400     }
 401     /**
 402      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 403      */
 404     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 405       return rawMessage_;
 406     }
 407
 408     // optional .openxc.TranslatedMessage translated_message = 3;
 409     public static final int TRANSLATED_MESSAGE_FIELD_NUMBER = 3;
 410     private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_;
 411     /**
 412      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 413      */
 414     public boolean hasTranslatedMessage() {
 415       return ((bitField0_ & 0x00000004) == 0x00000004);
 416     }
 417     /**
 418      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 419      */
 420     public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 421       return translatedMessage_;
 422     }
 423     /**
 424      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 425      */
 426     public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 427       return translatedMessage_;
 428     }
 429
 430     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
 431     public static final int DIAGNOSTIC_RESPONSE_FIELD_NUMBER = 4;
 432     private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_;
 433     /**
 434      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 435      */
 436     public boolean hasDiagnosticResponse() {
 437       return ((bitField0_ & 0x00000008) == 0x00000008);
 438     }
 439     /**
 440      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 441      */
 442     public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
 443       return diagnosticResponse_;
 444     }
 445     /**
 446      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 447      */
 448     public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
 449       return diagnosticResponse_;
 450     }
 451
 452     // optional .openxc.ControlCommand control_command = 5;
 453     public static final int CONTROL_COMMAND_FIELD_NUMBER = 5;
 454     private com.openxc.BinaryMessages.ControlCommand controlCommand_;
 455     /**
 456      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 457      */
 458     public boolean hasControlCommand() {
 459       return ((bitField0_ & 0x00000010) == 0x00000010);
 460     }
 461     /**
 462      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 463      */
 464     public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
 465       return controlCommand_;
 466     }
 467     /**
 468      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 469      */
 470     public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
 471       return controlCommand_;
 472     }
 473
 474     // optional .openxc.CommandResponse command_response = 6;
 475     public static final int COMMAND_RESPONSE_FIELD_NUMBER = 6;
 476     private com.openxc.BinaryMessages.CommandResponse commandResponse_;
 477     /**
 478      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 479      */
 480     public boolean hasCommandResponse() {
 481       return ((bitField0_ & 0x00000020) == 0x00000020);
 482     }
 483     /**
 484      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 485      */
 486     public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
 487       return commandResponse_;
 488     }
 489     /**
 490      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 491      */
 492     public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
 493       return commandResponse_;
 494     }
 495
 496     private void initFields() {
 497       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 498       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 499       translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 500       diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 501       controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 502       commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 503     }
 504     private byte memoizedIsInitialized = -1;
 505     public final boolean isInitialized() {
 506       byte isInitialized = memoizedIsInitialized;
 507       if (isInitialized != -1) return isInitialized == 1;
 508
 509       memoizedIsInitialized = 1;
 510       return true;
 511     }
 512
 513     public void writeTo(com.google.protobuf.CodedOutputStream output)
 514                         throws java.io.IOException {
 515       getSerializedSize();
 516       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 517         output.writeEnum(1, type_.getNumber());
 518       }
 519       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 520         output.writeMessage(2, rawMessage_);
 521       }
 522       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 523         output.writeMessage(3, translatedMessage_);
 524       }
 525       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 526         output.writeMessage(4, diagnosticResponse_);
 527       }
 528       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 529         output.writeMessage(5, controlCommand_);
 530       }
 531       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 532         output.writeMessage(6, commandResponse_);
 533       }
 534       getUnknownFields().writeTo(output);
 535     }
 536
 537     private int memoizedSerializedSize = -1;
 538     public int getSerializedSize() {
 539       int size = memoizedSerializedSize;
 540       if (size != -1) return size;
 541
 542       size = 0;
 543       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 544         size += com.google.protobuf.CodedOutputStream
 545           .computeEnumSize(1, type_.getNumber());
 546       }
 547       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 548         size += com.google.protobuf.CodedOutputStream
 549           .computeMessageSize(2, rawMessage_);
 550       }
 551       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 552         size += com.google.protobuf.CodedOutputStream
 553           .computeMessageSize(3, translatedMessage_);
 554       }
 555       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 556         size += com.google.protobuf.CodedOutputStream
 557           .computeMessageSize(4, diagnosticResponse_);
 558       }
 559       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 560         size += com.google.protobuf.CodedOutputStream
 561           .computeMessageSize(5, controlCommand_);
 562       }
 563       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 564         size += com.google.protobuf.CodedOutputStream
 565           .computeMessageSize(6, commandResponse_);
 566       }
 567       size += getUnknownFields().getSerializedSize();
 568       memoizedSerializedSize = size;
 569       return size;
 570     }
 571
 572     private static final long serialVersionUID = 0L;
 573     @java.lang.Override
 574     protected java.lang.Object writeReplace()
 575         throws java.io.ObjectStreamException {
 576       return super.writeReplace();
 577     }
 578
 579     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 580         com.google.protobuf.ByteString data)
 581         throws com.google.protobuf.InvalidProtocolBufferException {
 582       return PARSER.parseFrom(data);
 583     }
 584     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 585         com.google.protobuf.ByteString data,
 586         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 587         throws com.google.protobuf.InvalidProtocolBufferException {
 588       return PARSER.parseFrom(data, extensionRegistry);
 589     }
 590     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 591         throws com.google.protobuf.InvalidProtocolBufferException {
 592       return PARSER.parseFrom(data);
 593     }
 594     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 595         byte[] data,
 596         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 597         throws com.google.protobuf.InvalidProtocolBufferException {
 598       return PARSER.parseFrom(data, extensionRegistry);
 599     }
 600     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 601         throws java.io.IOException {
 602       return PARSER.parseFrom(input);
 603     }
 604     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 605         java.io.InputStream input,
 606         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 607         throws java.io.IOException {
 608       return PARSER.parseFrom(input, extensionRegistry);
 609     }
 610     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 611         throws java.io.IOException {
 612       return PARSER.parseDelimitedFrom(input);
 613     }
 614     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 615         java.io.InputStream input,
 616         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 617         throws java.io.IOException {
 618       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 619     }
 620     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 621         com.google.protobuf.CodedInputStream input)
 622         throws java.io.IOException {
 623       return PARSER.parseFrom(input);
 624     }
 625     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 626         com.google.protobuf.CodedInputStream input,
 627         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 628         throws java.io.IOException {
 629       return PARSER.parseFrom(input, extensionRegistry);
 630     }
 631
 632     public static Builder newBuilder() { return Builder.create(); }
 633     public Builder newBuilderForType() { return newBuilder(); }
 634     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 635       return newBuilder().mergeFrom(prototype);
 636     }
 637     public Builder toBuilder() { return newBuilder(this); }
 638
 639     @java.lang.Override
 640     protected Builder newBuilderForType(
 641         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 642       Builder builder = new Builder(parent);
 643       return builder;
 644     }
 645     /**
 646      * Protobuf type {@code openxc.VehicleMessage}
 647      */
 648     public static final class Builder extends
 649         com.google.protobuf.GeneratedMessage.Builder<Builder>
 650        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 651       public static final com.google.protobuf.Descriptors.Descriptor
 652           getDescriptor() {
 653         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 654       }
 655
 656       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 657           internalGetFieldAccessorTable() {
 658         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 659             .ensureFieldAccessorsInitialized(
 660                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 661       }
 662
 663       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 664       private Builder() {
 665         maybeForceBuilderInitialization();
 666       }
 667
 668       private Builder(
 669           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 670         super(parent);
 671         maybeForceBuilderInitialization();
 672       }
 673       private void maybeForceBuilderInitialization() {
 674         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 675           getRawMessageFieldBuilder();
 676           getTranslatedMessageFieldBuilder();
 677           getDiagnosticResponseFieldBuilder();
 678           getControlCommandFieldBuilder();
 679           getCommandResponseFieldBuilder();
 680         }
 681       }
 682       private static Builder create() {
 683         return new Builder();
 684       }
 685
 686       public Builder clear() {
 687         super.clear();
 688         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 689         bitField0_ = (bitField0_ & ~0x00000001);
 690         if (rawMessageBuilder_ == null) {
 691           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 692         } else {
 693           rawMessageBuilder_.clear();
 694         }
 695         bitField0_ = (bitField0_ & ~0x00000002);
 696         if (translatedMessageBuilder_ == null) {
 697           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 698         } else {
 699           translatedMessageBuilder_.clear();
 700         }
 701         bitField0_ = (bitField0_ & ~0x00000004);
 702         if (diagnosticResponseBuilder_ == null) {
 703           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 704         } else {
 705           diagnosticResponseBuilder_.clear();
 706         }
 707         bitField0_ = (bitField0_ & ~0x00000008);
 708         if (controlCommandBuilder_ == null) {
 709           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 710         } else {
 711           controlCommandBuilder_.clear();
 712         }
 713         bitField0_ = (bitField0_ & ~0x00000010);
 714         if (commandResponseBuilder_ == null) {
 715           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 716         } else {
 717           commandResponseBuilder_.clear();
 718         }
 719         bitField0_ = (bitField0_ & ~0x00000020);
 720         return this;
 721       }
 722
 723       public Builder clone() {
 724         return create().mergeFrom(buildPartial());
 725       }
 726
 727       public com.google.protobuf.Descriptors.Descriptor
 728           getDescriptorForType() {
 729         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 730       }
 731
 732       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 733         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 734       }
 735
 736       public com.openxc.BinaryMessages.VehicleMessage build() {
 737         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 738         if (!result.isInitialized()) {
 739           throw newUninitializedMessageException(result);
 740         }
 741         return result;
 742       }
 743
 744       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 745         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 746         int from_bitField0_ = bitField0_;
 747         int to_bitField0_ = 0;
 748         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 749           to_bitField0_ |= 0x00000001;
 750         }
 751         result.type_ = type_;
 752         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 753           to_bitField0_ |= 0x00000002;
 754         }
 755         if (rawMessageBuilder_ == null) {
 756           result.rawMessage_ = rawMessage_;
 757         } else {
 758           result.rawMessage_ = rawMessageBuilder_.build();
 759         }
 760         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 761           to_bitField0_ |= 0x00000004;
 762         }
 763         if (translatedMessageBuilder_ == null) {
 764           result.translatedMessage_ = translatedMessage_;
 765         } else {
 766           result.translatedMessage_ = translatedMessageBuilder_.build();
 767         }
 768         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 769           to_bitField0_ |= 0x00000008;
 770         }
 771         if (diagnosticResponseBuilder_ == null) {
 772           result.diagnosticResponse_ = diagnosticResponse_;
 773         } else {
 774           result.diagnosticResponse_ = diagnosticResponseBuilder_.build();
 775         }
 776         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
 777           to_bitField0_ |= 0x00000010;
 778         }
 779         if (controlCommandBuilder_ == null) {
 780           result.controlCommand_ = controlCommand_;
 781         } else {
 782           result.controlCommand_ = controlCommandBuilder_.build();
 783         }
 784         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
 785           to_bitField0_ |= 0x00000020;
 786         }
 787         if (commandResponseBuilder_ == null) {
 788           result.commandResponse_ = commandResponse_;
 789         } else {
 790           result.commandResponse_ = commandResponseBuilder_.build();
 791         }
 792         result.bitField0_ = to_bitField0_;
 793         onBuilt();
 794         return result;
 795       }
 796
 797       public Builder mergeFrom(com.google.protobuf.Message other) {
 798         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 799           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 800         } else {
 801           super.mergeFrom(other);
 802           return this;
 803         }
 804       }
 805
 806       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 807         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 808         if (other.hasType()) {
 809           setType(other.getType());
 810         }
 811         if (other.hasRawMessage()) {
 812           mergeRawMessage(other.getRawMessage());
 813         }
 814         if (other.hasTranslatedMessage()) {
 815           mergeTranslatedMessage(other.getTranslatedMessage());
 816         }
 817         if (other.hasDiagnosticResponse()) {
 818           mergeDiagnosticResponse(other.getDiagnosticResponse());
 819         }
 820         if (other.hasControlCommand()) {
 821           mergeControlCommand(other.getControlCommand());
 822         }
 823         if (other.hasCommandResponse()) {
 824           mergeCommandResponse(other.getCommandResponse());
 825         }
 826         this.mergeUnknownFields(other.getUnknownFields());
 827         return this;
 828       }
 829
 830       public final boolean isInitialized() {
 831         return true;
 832       }
 833
 834       public Builder mergeFrom(
 835           com.google.protobuf.CodedInputStream input,
 836           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 837           throws java.io.IOException {
 838         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
 839         try {
 840           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 841         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 842           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
 843           throw e;
 844         } finally {
 845           if (parsedMessage != null) {
 846             mergeFrom(parsedMessage);
 847           }
 848         }
 849         return this;
 850       }
 851       private int bitField0_;
 852
 853       // optional .openxc.VehicleMessage.Type type = 1;
 854       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 855       /**
 856        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 857        */
 858       public boolean hasType() {
 859         return ((bitField0_ & 0x00000001) == 0x00000001);
 860       }
 861       /**
 862        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 863        */
 864       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 865         return type_;
 866       }
 867       /**
 868        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 869        */
 870       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 871         if (value == null) {
 872           throw new NullPointerException();
 873         }
 874         bitField0_ |= 0x00000001;
 875         type_ = value;
 876         onChanged();
 877         return this;
 878       }
 879       /**
 880        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 881        */
 882       public Builder clearType() {
 883         bitField0_ = (bitField0_ & ~0x00000001);
 884         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 885         onChanged();
 886         return this;
 887       }
 888
 889       // optional .openxc.RawMessage raw_message = 2;
 890       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 891       private com.google.protobuf.SingleFieldBuilder<
 892           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
 893       /**
 894        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 895        */
 896       public boolean hasRawMessage() {
 897         return ((bitField0_ & 0x00000002) == 0x00000002);
 898       }
 899       /**
 900        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 901        */
 902       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 903         if (rawMessageBuilder_ == null) {
 904           return rawMessage_;
 905         } else {
 906           return rawMessageBuilder_.getMessage();
 907         }
 908       }
 909       /**
 910        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 911        */
 912       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 913         if (rawMessageBuilder_ == null) {
 914           if (value == null) {
 915             throw new NullPointerException();
 916           }
 917           rawMessage_ = value;
 918           onChanged();
 919         } else {
 920           rawMessageBuilder_.setMessage(value);
 921         }
 922         bitField0_ |= 0x00000002;
 923         return this;
 924       }
 925       /**
 926        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 927        */
 928       public Builder setRawMessage(
 929           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
 930         if (rawMessageBuilder_ == null) {
 931           rawMessage_ = builderForValue.build();
 932           onChanged();
 933         } else {
 934           rawMessageBuilder_.setMessage(builderForValue.build());
 935         }
 936         bitField0_ |= 0x00000002;
 937         return this;
 938       }
 939       /**
 940        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 941        */
 942       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 943         if (rawMessageBuilder_ == null) {
 944           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 945               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
 946             rawMessage_ =
 947               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
 948           } else {
 949             rawMessage_ = value;
 950           }
 951           onChanged();
 952         } else {
 953           rawMessageBuilder_.mergeFrom(value);
 954         }
 955         bitField0_ |= 0x00000002;
 956         return this;
 957       }
 958       /**
 959        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 960        */
 961       public Builder clearRawMessage() {
 962         if (rawMessageBuilder_ == null) {
 963           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 964           onChanged();
 965         } else {
 966           rawMessageBuilder_.clear();
 967         }
 968         bitField0_ = (bitField0_ & ~0x00000002);
 969         return this;
 970       }
 971       /**
 972        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 973        */
 974       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
 975         bitField0_ |= 0x00000002;
 976         onChanged();
 977         return getRawMessageFieldBuilder().getBuilder();
 978       }
 979       /**
 980        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 981        */
 982       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 983         if (rawMessageBuilder_ != null) {
 984           return rawMessageBuilder_.getMessageOrBuilder();
 985         } else {
 986           return rawMessage_;
 987         }
 988       }
 989       /**
 990        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 991        */
 992       private com.google.protobuf.SingleFieldBuilder<
 993           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>
 994           getRawMessageFieldBuilder() {
 995         if (rawMessageBuilder_ == null) {
 996           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 997               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
 998                   rawMessage_,
 999                   getParentForChildren(),
1000                   isClean());
1001           rawMessage_ = null;
1002         }
1003         return rawMessageBuilder_;
1004       }
1005
1006       // optional .openxc.TranslatedMessage translated_message = 3;
1007       private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1008       private com.google.protobuf.SingleFieldBuilder<
1009           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> translatedMessageBuilder_;
1010       /**
1011        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1012        */
1013       public boolean hasTranslatedMessage() {
1014         return ((bitField0_ & 0x00000004) == 0x00000004);
1015       }
1016       /**
1017        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1018        */
1019       public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
1020         if (translatedMessageBuilder_ == null) {
1021           return translatedMessage_;
1022         } else {
1023           return translatedMessageBuilder_.getMessage();
1024         }
1025       }
1026       /**
1027        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1028        */
1029       public Builder setTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1030         if (translatedMessageBuilder_ == null) {
1031           if (value == null) {
1032             throw new NullPointerException();
1033           }
1034           translatedMessage_ = value;
1035           onChanged();
1036         } else {
1037           translatedMessageBuilder_.setMessage(value);
1038         }
1039         bitField0_ |= 0x00000004;
1040         return this;
1041       }
1042       /**
1043        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1044        */
1045       public Builder setTranslatedMessage(
1046           com.openxc.BinaryMessages.TranslatedMessage.Builder builderForValue) {
1047         if (translatedMessageBuilder_ == null) {
1048           translatedMessage_ = builderForValue.build();
1049           onChanged();
1050         } else {
1051           translatedMessageBuilder_.setMessage(builderForValue.build());
1052         }
1053         bitField0_ |= 0x00000004;
1054         return this;
1055       }
1056       /**
1057        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1058        */
1059       public Builder mergeTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1060         if (translatedMessageBuilder_ == null) {
1061           if (((bitField0_ & 0x00000004) == 0x00000004) &&
1062               translatedMessage_ != com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) {
1063             translatedMessage_ =
1064               com.openxc.BinaryMessages.TranslatedMessage.newBuilder(translatedMessage_).mergeFrom(value).buildPartial();
1065           } else {
1066             translatedMessage_ = value;
1067           }
1068           onChanged();
1069         } else {
1070           translatedMessageBuilder_.mergeFrom(value);
1071         }
1072         bitField0_ |= 0x00000004;
1073         return this;
1074       }
1075       /**
1076        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1077        */
1078       public Builder clearTranslatedMessage() {
1079         if (translatedMessageBuilder_ == null) {
1080           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1081           onChanged();
1082         } else {
1083           translatedMessageBuilder_.clear();
1084         }
1085         bitField0_ = (bitField0_ & ~0x00000004);
1086         return this;
1087       }
1088       /**
1089        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1090        */
1091       public com.openxc.BinaryMessages.TranslatedMessage.Builder getTranslatedMessageBuilder() {
1092         bitField0_ |= 0x00000004;
1093         onChanged();
1094         return getTranslatedMessageFieldBuilder().getBuilder();
1095       }
1096       /**
1097        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1098        */
1099       public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
1100         if (translatedMessageBuilder_ != null) {
1101           return translatedMessageBuilder_.getMessageOrBuilder();
1102         } else {
1103           return translatedMessage_;
1104         }
1105       }
1106       /**
1107        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1108        */
1109       private com.google.protobuf.SingleFieldBuilder<
1110           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>
1111           getTranslatedMessageFieldBuilder() {
1112         if (translatedMessageBuilder_ == null) {
1113           translatedMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1114               com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>(
1115                   translatedMessage_,
1116                   getParentForChildren(),
1117                   isClean());
1118           translatedMessage_ = null;
1119         }
1120         return translatedMessageBuilder_;
1121       }
1122
1123       // optional .openxc.DiagnosticResponse diagnostic_response = 4;
1124       private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1125       private com.google.protobuf.SingleFieldBuilder<
1126           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> diagnosticResponseBuilder_;
1127       /**
1128        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1129        */
1130       public boolean hasDiagnosticResponse() {
1131         return ((bitField0_ & 0x00000008) == 0x00000008);
1132       }
1133       /**
1134        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1135        */
1136       public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
1137         if (diagnosticResponseBuilder_ == null) {
1138           return diagnosticResponse_;
1139         } else {
1140           return diagnosticResponseBuilder_.getMessage();
1141         }
1142       }
1143       /**
1144        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1145        */
1146       public Builder setDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1147         if (diagnosticResponseBuilder_ == null) {
1148           if (value == null) {
1149             throw new NullPointerException();
1150           }
1151           diagnosticResponse_ = value;
1152           onChanged();
1153         } else {
1154           diagnosticResponseBuilder_.setMessage(value);
1155         }
1156         bitField0_ |= 0x00000008;
1157         return this;
1158       }
1159       /**
1160        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1161        */
1162       public Builder setDiagnosticResponse(
1163           com.openxc.BinaryMessages.DiagnosticResponse.Builder builderForValue) {
1164         if (diagnosticResponseBuilder_ == null) {
1165           diagnosticResponse_ = builderForValue.build();
1166           onChanged();
1167         } else {
1168           diagnosticResponseBuilder_.setMessage(builderForValue.build());
1169         }
1170         bitField0_ |= 0x00000008;
1171         return this;
1172       }
1173       /**
1174        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1175        */
1176       public Builder mergeDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1177         if (diagnosticResponseBuilder_ == null) {
1178           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1179               diagnosticResponse_ != com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) {
1180             diagnosticResponse_ =
1181               com.openxc.BinaryMessages.DiagnosticResponse.newBuilder(diagnosticResponse_).mergeFrom(value).buildPartial();
1182           } else {
1183             diagnosticResponse_ = value;
1184           }
1185           onChanged();
1186         } else {
1187           diagnosticResponseBuilder_.mergeFrom(value);
1188         }
1189         bitField0_ |= 0x00000008;
1190         return this;
1191       }
1192       /**
1193        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1194        */
1195       public Builder clearDiagnosticResponse() {
1196         if (diagnosticResponseBuilder_ == null) {
1197           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1198           onChanged();
1199         } else {
1200           diagnosticResponseBuilder_.clear();
1201         }
1202         bitField0_ = (bitField0_ & ~0x00000008);
1203         return this;
1204       }
1205       /**
1206        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1207        */
1208       public com.openxc.BinaryMessages.DiagnosticResponse.Builder getDiagnosticResponseBuilder() {
1209         bitField0_ |= 0x00000008;
1210         onChanged();
1211         return getDiagnosticResponseFieldBuilder().getBuilder();
1212       }
1213       /**
1214        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1215        */
1216       public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
1217         if (diagnosticResponseBuilder_ != null) {
1218           return diagnosticResponseBuilder_.getMessageOrBuilder();
1219         } else {
1220           return diagnosticResponse_;
1221         }
1222       }
1223       /**
1224        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1225        */
1226       private com.google.protobuf.SingleFieldBuilder<
1227           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>
1228           getDiagnosticResponseFieldBuilder() {
1229         if (diagnosticResponseBuilder_ == null) {
1230           diagnosticResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1231               com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>(
1232                   diagnosticResponse_,
1233                   getParentForChildren(),
1234                   isClean());
1235           diagnosticResponse_ = null;
1236         }
1237         return diagnosticResponseBuilder_;
1238       }
1239
1240       // optional .openxc.ControlCommand control_command = 5;
1241       private com.openxc.BinaryMessages.ControlCommand controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1242       private com.google.protobuf.SingleFieldBuilder<
1243           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> controlCommandBuilder_;
1244       /**
1245        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1246        */
1247       public boolean hasControlCommand() {
1248         return ((bitField0_ & 0x00000010) == 0x00000010);
1249       }
1250       /**
1251        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1252        */
1253       public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
1254         if (controlCommandBuilder_ == null) {
1255           return controlCommand_;
1256         } else {
1257           return controlCommandBuilder_.getMessage();
1258         }
1259       }
1260       /**
1261        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1262        */
1263       public Builder setControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1264         if (controlCommandBuilder_ == null) {
1265           if (value == null) {
1266             throw new NullPointerException();
1267           }
1268           controlCommand_ = value;
1269           onChanged();
1270         } else {
1271           controlCommandBuilder_.setMessage(value);
1272         }
1273         bitField0_ |= 0x00000010;
1274         return this;
1275       }
1276       /**
1277        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1278        */
1279       public Builder setControlCommand(
1280           com.openxc.BinaryMessages.ControlCommand.Builder builderForValue) {
1281         if (controlCommandBuilder_ == null) {
1282           controlCommand_ = builderForValue.build();
1283           onChanged();
1284         } else {
1285           controlCommandBuilder_.setMessage(builderForValue.build());
1286         }
1287         bitField0_ |= 0x00000010;
1288         return this;
1289       }
1290       /**
1291        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1292        */
1293       public Builder mergeControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1294         if (controlCommandBuilder_ == null) {
1295           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1296               controlCommand_ != com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) {
1297             controlCommand_ =
1298               com.openxc.BinaryMessages.ControlCommand.newBuilder(controlCommand_).mergeFrom(value).buildPartial();
1299           } else {
1300             controlCommand_ = value;
1301           }
1302           onChanged();
1303         } else {
1304           controlCommandBuilder_.mergeFrom(value);
1305         }
1306         bitField0_ |= 0x00000010;
1307         return this;
1308       }
1309       /**
1310        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1311        */
1312       public Builder clearControlCommand() {
1313         if (controlCommandBuilder_ == null) {
1314           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1315           onChanged();
1316         } else {
1317           controlCommandBuilder_.clear();
1318         }
1319         bitField0_ = (bitField0_ & ~0x00000010);
1320         return this;
1321       }
1322       /**
1323        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1324        */
1325       public com.openxc.BinaryMessages.ControlCommand.Builder getControlCommandBuilder() {
1326         bitField0_ |= 0x00000010;
1327         onChanged();
1328         return getControlCommandFieldBuilder().getBuilder();
1329       }
1330       /**
1331        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1332        */
1333       public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
1334         if (controlCommandBuilder_ != null) {
1335           return controlCommandBuilder_.getMessageOrBuilder();
1336         } else {
1337           return controlCommand_;
1338         }
1339       }
1340       /**
1341        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1342        */
1343       private com.google.protobuf.SingleFieldBuilder<
1344           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>
1345           getControlCommandFieldBuilder() {
1346         if (controlCommandBuilder_ == null) {
1347           controlCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1348               com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>(
1349                   controlCommand_,
1350                   getParentForChildren(),
1351                   isClean());
1352           controlCommand_ = null;
1353         }
1354         return controlCommandBuilder_;
1355       }
1356
1357       // optional .openxc.CommandResponse command_response = 6;
1358       private com.openxc.BinaryMessages.CommandResponse commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1359       private com.google.protobuf.SingleFieldBuilder<
1360           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> commandResponseBuilder_;
1361       /**
1362        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1363        */
1364       public boolean hasCommandResponse() {
1365         return ((bitField0_ & 0x00000020) == 0x00000020);
1366       }
1367       /**
1368        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1369        */
1370       public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
1371         if (commandResponseBuilder_ == null) {
1372           return commandResponse_;
1373         } else {
1374           return commandResponseBuilder_.getMessage();
1375         }
1376       }
1377       /**
1378        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1379        */
1380       public Builder setCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1381         if (commandResponseBuilder_ == null) {
1382           if (value == null) {
1383             throw new NullPointerException();
1384           }
1385           commandResponse_ = value;
1386           onChanged();
1387         } else {
1388           commandResponseBuilder_.setMessage(value);
1389         }
1390         bitField0_ |= 0x00000020;
1391         return this;
1392       }
1393       /**
1394        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1395        */
1396       public Builder setCommandResponse(
1397           com.openxc.BinaryMessages.CommandResponse.Builder builderForValue) {
1398         if (commandResponseBuilder_ == null) {
1399           commandResponse_ = builderForValue.build();
1400           onChanged();
1401         } else {
1402           commandResponseBuilder_.setMessage(builderForValue.build());
1403         }
1404         bitField0_ |= 0x00000020;
1405         return this;
1406       }
1407       /**
1408        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1409        */
1410       public Builder mergeCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1411         if (commandResponseBuilder_ == null) {
1412           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1413               commandResponse_ != com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) {
1414             commandResponse_ =
1415               com.openxc.BinaryMessages.CommandResponse.newBuilder(commandResponse_).mergeFrom(value).buildPartial();
1416           } else {
1417             commandResponse_ = value;
1418           }
1419           onChanged();
1420         } else {
1421           commandResponseBuilder_.mergeFrom(value);
1422         }
1423         bitField0_ |= 0x00000020;
1424         return this;
1425       }
1426       /**
1427        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1428        */
1429       public Builder clearCommandResponse() {
1430         if (commandResponseBuilder_ == null) {
1431           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1432           onChanged();
1433         } else {
1434           commandResponseBuilder_.clear();
1435         }
1436         bitField0_ = (bitField0_ & ~0x00000020);
1437         return this;
1438       }
1439       /**
1440        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1441        */
1442       public com.openxc.BinaryMessages.CommandResponse.Builder getCommandResponseBuilder() {
1443         bitField0_ |= 0x00000020;
1444         onChanged();
1445         return getCommandResponseFieldBuilder().getBuilder();
1446       }
1447       /**
1448        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1449        */
1450       public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
1451         if (commandResponseBuilder_ != null) {
1452           return commandResponseBuilder_.getMessageOrBuilder();
1453         } else {
1454           return commandResponse_;
1455         }
1456       }
1457       /**
1458        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1459        */
1460       private com.google.protobuf.SingleFieldBuilder<
1461           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>
1462           getCommandResponseFieldBuilder() {
1463         if (commandResponseBuilder_ == null) {
1464           commandResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1465               com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>(
1466                   commandResponse_,
1467                   getParentForChildren(),
1468                   isClean());
1469           commandResponse_ = null;
1470         }
1471         return commandResponseBuilder_;
1472       }
1473
1474       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1475     }
1476
1477     static {
1478       defaultInstance = new VehicleMessage(true);
1479       defaultInstance.initFields();
1480     }
1481
1482     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1483   }
1484
1485   public interface RawMessageOrBuilder
1486       extends com.google.protobuf.MessageOrBuilder {
1487
1488     // optional int32 bus = 1;
1489     /**
1490      * <code>optional int32 bus = 1;</code>
1491      */
1492     boolean hasBus();
1493     /**
1494      * <code>optional int32 bus = 1;</code>
1495      */
1496     int getBus();
1497
1498     // optional uint32 message_id = 2;
1499     /**
1500      * <code>optional uint32 message_id = 2;</code>
1501      */
1502     boolean hasMessageId();
1503     /**
1504      * <code>optional uint32 message_id = 2;</code>
1505      */
1506     int getMessageId();
1507
1508     // optional bytes data = 3;
1509     /**
1510      * <code>optional bytes data = 3;</code>
1511      */
1512     boolean hasData();
1513     /**
1514      * <code>optional bytes data = 3;</code>
1515      */
1516     com.google.protobuf.ByteString getData();
1517   }
1518   /**
1519    * Protobuf type {@code openxc.RawMessage}
1520    */
1521   public static final class RawMessage extends
1522       com.google.protobuf.GeneratedMessage
1523       implements RawMessageOrBuilder {
1524     // Use RawMessage.newBuilder() to construct.
1525     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1526       super(builder);
1527       this.unknownFields = builder.getUnknownFields();
1528     }
1529     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1530
1531     private static final RawMessage defaultInstance;
1532     public static RawMessage getDefaultInstance() {
1533       return defaultInstance;
1534     }
1535
1536     public RawMessage getDefaultInstanceForType() {
1537       return defaultInstance;
1538     }
1539
1540     private final com.google.protobuf.UnknownFieldSet unknownFields;
1541     @java.lang.Override
1542     public final com.google.protobuf.UnknownFieldSet
1543         getUnknownFields() {
1544       return this.unknownFields;
1545     }
1546     private RawMessage(
1547         com.google.protobuf.CodedInputStream input,
1548         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1549         throws com.google.protobuf.InvalidProtocolBufferException {
1550       initFields();
1551       int mutable_bitField0_ = 0;
1552       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1553           com.google.protobuf.UnknownFieldSet.newBuilder();
1554       try {
1555         boolean done = false;
1556         while (!done) {
1557           int tag = input.readTag();
1558           switch (tag) {
1559             case 0:
1560               done = true;
1561               break;
1562             default: {
1563               if (!parseUnknownField(input, unknownFields,
1564                                      extensionRegistry, tag)) {
1565                 done = true;
1566               }
1567               break;
1568             }
1569             case 8: {
1570               bitField0_ |= 0x00000001;
1571               bus_ = input.readInt32();
1572               break;
1573             }
1574             case 16: {
1575               bitField0_ |= 0x00000002;
1576               messageId_ = input.readUInt32();
1577               break;
1578             }
1579             case 26: {
1580               bitField0_ |= 0x00000004;
1581               data_ = input.readBytes();
1582               break;
1583             }
1584           }
1585         }
1586       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1587         throw e.setUnfinishedMessage(this);
1588       } catch (java.io.IOException e) {
1589         throw new com.google.protobuf.InvalidProtocolBufferException(
1590             e.getMessage()).setUnfinishedMessage(this);
1591       } finally {
1592         this.unknownFields = unknownFields.build();
1593         makeExtensionsImmutable();
1594       }
1595     }
1596     public static final com.google.protobuf.Descriptors.Descriptor
1597         getDescriptor() {
1598       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1599     }
1600
1601     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1602         internalGetFieldAccessorTable() {
1603       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1604           .ensureFieldAccessorsInitialized(
1605               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1606     }
1607
1608     public static com.google.protobuf.Parser<RawMessage> PARSER =
1609         new com.google.protobuf.AbstractParser<RawMessage>() {
1610       public RawMessage parsePartialFrom(
1611           com.google.protobuf.CodedInputStream input,
1612           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1613           throws com.google.protobuf.InvalidProtocolBufferException {
1614         return new RawMessage(input, extensionRegistry);
1615       }
1616     };
1617
1618     @java.lang.Override
1619     public com.google.protobuf.Parser<RawMessage> getParserForType() {
1620       return PARSER;
1621     }
1622
1623     private int bitField0_;
1624     // optional int32 bus = 1;
1625     public static final int BUS_FIELD_NUMBER = 1;
1626     private int bus_;
1627     /**
1628      * <code>optional int32 bus = 1;</code>
1629      */
1630     public boolean hasBus() {
1631       return ((bitField0_ & 0x00000001) == 0x00000001);
1632     }
1633     /**
1634      * <code>optional int32 bus = 1;</code>
1635      */
1636     public int getBus() {
1637       return bus_;
1638     }
1639
1640     // optional uint32 message_id = 2;
1641     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1642     private int messageId_;
1643     /**
1644      * <code>optional uint32 message_id = 2;</code>
1645      */
1646     public boolean hasMessageId() {
1647       return ((bitField0_ & 0x00000002) == 0x00000002);
1648     }
1649     /**
1650      * <code>optional uint32 message_id = 2;</code>
1651      */
1652     public int getMessageId() {
1653       return messageId_;
1654     }
1655
1656     // optional bytes data = 3;
1657     public static final int DATA_FIELD_NUMBER = 3;
1658     private com.google.protobuf.ByteString data_;
1659     /**
1660      * <code>optional bytes data = 3;</code>
1661      */
1662     public boolean hasData() {
1663       return ((bitField0_ & 0x00000004) == 0x00000004);
1664     }
1665     /**
1666      * <code>optional bytes data = 3;</code>
1667      */
1668     public com.google.protobuf.ByteString getData() {
1669       return data_;
1670     }
1671
1672     private void initFields() {
1673       bus_ = 0;
1674       messageId_ = 0;
1675       data_ = com.google.protobuf.ByteString.EMPTY;
1676     }
1677     private byte memoizedIsInitialized = -1;
1678     public final boolean isInitialized() {
1679       byte isInitialized = memoizedIsInitialized;
1680       if (isInitialized != -1) return isInitialized == 1;
1681
1682       memoizedIsInitialized = 1;
1683       return true;
1684     }
1685
1686     public void writeTo(com.google.protobuf.CodedOutputStream output)
1687                         throws java.io.IOException {
1688       getSerializedSize();
1689       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1690         output.writeInt32(1, bus_);
1691       }
1692       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1693         output.writeUInt32(2, messageId_);
1694       }
1695       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1696         output.writeBytes(3, data_);
1697       }
1698       getUnknownFields().writeTo(output);
1699     }
1700
1701     private int memoizedSerializedSize = -1;
1702     public int getSerializedSize() {
1703       int size = memoizedSerializedSize;
1704       if (size != -1) return size;
1705
1706       size = 0;
1707       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1708         size += com.google.protobuf.CodedOutputStream
1709           .computeInt32Size(1, bus_);
1710       }
1711       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1712         size += com.google.protobuf.CodedOutputStream
1713           .computeUInt32Size(2, messageId_);
1714       }
1715       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1716         size += com.google.protobuf.CodedOutputStream
1717           .computeBytesSize(3, data_);
1718       }
1719       size += getUnknownFields().getSerializedSize();
1720       memoizedSerializedSize = size;
1721       return size;
1722     }
1723
1724     private static final long serialVersionUID = 0L;
1725     @java.lang.Override
1726     protected java.lang.Object writeReplace()
1727         throws java.io.ObjectStreamException {
1728       return super.writeReplace();
1729     }
1730
1731     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1732         com.google.protobuf.ByteString data)
1733         throws com.google.protobuf.InvalidProtocolBufferException {
1734       return PARSER.parseFrom(data);
1735     }
1736     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1737         com.google.protobuf.ByteString data,
1738         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1739         throws com.google.protobuf.InvalidProtocolBufferException {
1740       return PARSER.parseFrom(data, extensionRegistry);
1741     }
1742     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
1743         throws com.google.protobuf.InvalidProtocolBufferException {
1744       return PARSER.parseFrom(data);
1745     }
1746     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1747         byte[] data,
1748         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1749         throws com.google.protobuf.InvalidProtocolBufferException {
1750       return PARSER.parseFrom(data, extensionRegistry);
1751     }
1752     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
1753         throws java.io.IOException {
1754       return PARSER.parseFrom(input);
1755     }
1756     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1757         java.io.InputStream input,
1758         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1759         throws java.io.IOException {
1760       return PARSER.parseFrom(input, extensionRegistry);
1761     }
1762     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
1763         throws java.io.IOException {
1764       return PARSER.parseDelimitedFrom(input);
1765     }
1766     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
1767         java.io.InputStream input,
1768         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1769         throws java.io.IOException {
1770       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1771     }
1772     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1773         com.google.protobuf.CodedInputStream input)
1774         throws java.io.IOException {
1775       return PARSER.parseFrom(input);
1776     }
1777     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1778         com.google.protobuf.CodedInputStream input,
1779         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1780         throws java.io.IOException {
1781       return PARSER.parseFrom(input, extensionRegistry);
1782     }
1783
1784     public static Builder newBuilder() { return Builder.create(); }
1785     public Builder newBuilderForType() { return newBuilder(); }
1786     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
1787       return newBuilder().mergeFrom(prototype);
1788     }
1789     public Builder toBuilder() { return newBuilder(this); }
1790
1791     @java.lang.Override
1792     protected Builder newBuilderForType(
1793         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1794       Builder builder = new Builder(parent);
1795       return builder;
1796     }
1797     /**
1798      * Protobuf type {@code openxc.RawMessage}
1799      */
1800     public static final class Builder extends
1801         com.google.protobuf.GeneratedMessage.Builder<Builder>
1802        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
1803       public static final com.google.protobuf.Descriptors.Descriptor
1804           getDescriptor() {
1805         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1806       }
1807
1808       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1809           internalGetFieldAccessorTable() {
1810         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1811             .ensureFieldAccessorsInitialized(
1812                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1813       }
1814
1815       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
1816       private Builder() {
1817         maybeForceBuilderInitialization();
1818       }
1819
1820       private Builder(
1821           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1822         super(parent);
1823         maybeForceBuilderInitialization();
1824       }
1825       private void maybeForceBuilderInitialization() {
1826         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1827         }
1828       }
1829       private static Builder create() {
1830         return new Builder();
1831       }
1832
1833       public Builder clear() {
1834         super.clear();
1835         bus_ = 0;
1836         bitField0_ = (bitField0_ & ~0x00000001);
1837         messageId_ = 0;
1838         bitField0_ = (bitField0_ & ~0x00000002);
1839         data_ = com.google.protobuf.ByteString.EMPTY;
1840         bitField0_ = (bitField0_ & ~0x00000004);
1841         return this;
1842       }
1843
1844       public Builder clone() {
1845         return create().mergeFrom(buildPartial());
1846       }
1847
1848       public com.google.protobuf.Descriptors.Descriptor
1849           getDescriptorForType() {
1850         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1851       }
1852
1853       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
1854         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1855       }
1856
1857       public com.openxc.BinaryMessages.RawMessage build() {
1858         com.openxc.BinaryMessages.RawMessage result = buildPartial();
1859         if (!result.isInitialized()) {
1860           throw newUninitializedMessageException(result);
1861         }
1862         return result;
1863       }
1864
1865       public com.openxc.BinaryMessages.RawMessage buildPartial() {
1866         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
1867         int from_bitField0_ = bitField0_;
1868         int to_bitField0_ = 0;
1869         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1870           to_bitField0_ |= 0x00000001;
1871         }
1872         result.bus_ = bus_;
1873         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1874           to_bitField0_ |= 0x00000002;
1875         }
1876         result.messageId_ = messageId_;
1877         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1878           to_bitField0_ |= 0x00000004;
1879         }
1880         result.data_ = data_;
1881         result.bitField0_ = to_bitField0_;
1882         onBuilt();
1883         return result;
1884       }
1885
1886       public Builder mergeFrom(com.google.protobuf.Message other) {
1887         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
1888           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
1889         } else {
1890           super.mergeFrom(other);
1891           return this;
1892         }
1893       }
1894
1895       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
1896         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
1897         if (other.hasBus()) {
1898           setBus(other.getBus());
1899         }
1900         if (other.hasMessageId()) {
1901           setMessageId(other.getMessageId());
1902         }
1903         if (other.hasData()) {
1904           setData(other.getData());
1905         }
1906         this.mergeUnknownFields(other.getUnknownFields());
1907         return this;
1908       }
1909
1910       public final boolean isInitialized() {
1911         return true;
1912       }
1913
1914       public Builder mergeFrom(
1915           com.google.protobuf.CodedInputStream input,
1916           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1917           throws java.io.IOException {
1918         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
1919         try {
1920           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1921         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1922           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
1923           throw e;
1924         } finally {
1925           if (parsedMessage != null) {
1926             mergeFrom(parsedMessage);
1927           }
1928         }
1929         return this;
1930       }
1931       private int bitField0_;
1932
1933       // optional int32 bus = 1;
1934       private int bus_ ;
1935       /**
1936        * <code>optional int32 bus = 1;</code>
1937        */
1938       public boolean hasBus() {
1939         return ((bitField0_ & 0x00000001) == 0x00000001);
1940       }
1941       /**
1942        * <code>optional int32 bus = 1;</code>
1943        */
1944       public int getBus() {
1945         return bus_;
1946       }
1947       /**
1948        * <code>optional int32 bus = 1;</code>
1949        */
1950       public Builder setBus(int value) {
1951         bitField0_ |= 0x00000001;
1952         bus_ = value;
1953         onChanged();
1954         return this;
1955       }
1956       /**
1957        * <code>optional int32 bus = 1;</code>
1958        */
1959       public Builder clearBus() {
1960         bitField0_ = (bitField0_ & ~0x00000001);
1961         bus_ = 0;
1962         onChanged();
1963         return this;
1964       }
1965
1966       // optional uint32 message_id = 2;
1967       private int messageId_ ;
1968       /**
1969        * <code>optional uint32 message_id = 2;</code>
1970        */
1971       public boolean hasMessageId() {
1972         return ((bitField0_ & 0x00000002) == 0x00000002);
1973       }
1974       /**
1975        * <code>optional uint32 message_id = 2;</code>
1976        */
1977       public int getMessageId() {
1978         return messageId_;
1979       }
1980       /**
1981        * <code>optional uint32 message_id = 2;</code>
1982        */
1983       public Builder setMessageId(int value) {
1984         bitField0_ |= 0x00000002;
1985         messageId_ = value;
1986         onChanged();
1987         return this;
1988       }
1989       /**
1990        * <code>optional uint32 message_id = 2;</code>
1991        */
1992       public Builder clearMessageId() {
1993         bitField0_ = (bitField0_ & ~0x00000002);
1994         messageId_ = 0;
1995         onChanged();
1996         return this;
1997       }
1998
1999       // optional bytes data = 3;
2000       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
2001       /**
2002        * <code>optional bytes data = 3;</code>
2003        */
2004       public boolean hasData() {
2005         return ((bitField0_ & 0x00000004) == 0x00000004);
2006       }
2007       /**
2008        * <code>optional bytes data = 3;</code>
2009        */
2010       public com.google.protobuf.ByteString getData() {
2011         return data_;
2012       }
2013       /**
2014        * <code>optional bytes data = 3;</code>
2015        */
2016       public Builder setData(com.google.protobuf.ByteString value) {
2017         if (value == null) {
2018     throw new NullPointerException();
2019   }
2020   bitField0_ |= 0x00000004;
2021         data_ = value;
2022         onChanged();
2023         return this;
2024       }
2025       /**
2026        * <code>optional bytes data = 3;</code>
2027        */
2028       public Builder clearData() {
2029         bitField0_ = (bitField0_ & ~0x00000004);
2030         data_ = getDefaultInstance().getData();
2031         onChanged();
2032         return this;
2033       }
2034
2035       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
2036     }
2037
2038     static {
2039       defaultInstance = new RawMessage(true);
2040       defaultInstance.initFields();
2041     }
2042
2043     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
2044   }
2045
2046   public interface ControlCommandOrBuilder
2047       extends com.google.protobuf.MessageOrBuilder {
2048
2049     // optional .openxc.ControlCommand.Type type = 1;
2050     /**
2051      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2052      */
2053     boolean hasType();
2054     /**
2055      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2056      */
2057     com.openxc.BinaryMessages.ControlCommand.Type getType();
2058
2059     // optional .openxc.DiagnosticControlCommand diagnostic_request = 2;
2060     /**
2061      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2062      */
2063     boolean hasDiagnosticRequest();
2064     /**
2065      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2066      */
2067     com.openxc.BinaryMessages.DiagnosticControlCommand getDiagnosticRequest();
2068     /**
2069      * <code>optional .openxc.DiagnosticControlCommand diagnostic_request = 2;</code>
2070      */
2071     com.openxc.BinaryMessages.DiagnosticControlCommandOrBuilder getDiagnosticRequestOrBuilder();
2072
2073     // optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;
2074     /**
2075      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2076      */
2077     boolean hasPassthroughModeRequest();
2078     /**
2079      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2080      */
2081     com.openxc.BinaryMessages.PassthroughModeControlCommand getPassthroughModeRequest();
2082     /**
2083      * <code>optional .openxc.PassthroughModeControlCommand passthrough_mode_request = 3;</code>
2084      */
2085     com.openxc.BinaryMessages.PassthroughModeControlCommandOrBuilder getPassthroughModeRequestOrBuilder();
2086
2087     // optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;
2088     /**
2089      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2090      */
2091     boolean hasAcceptanceFilterBypassCommand();
2092     /**
2093      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2094      */
2095     com.openxc.BinaryMessages.AcceptanceFilterBypassCommand getAcceptanceFilterBypassCommand();
2096     /**
2097      * <code>optional .openxc.AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4;</code>
2098      */
2099     com.openxc.BinaryMessages.AcceptanceFilterBypassCommandOrBuilder getAcceptanceFilterBypassCommandOrBuilder();
2100
2101     // optional .openxc.PayloadFormatCommand payload_format_command = 5;
2102     /**
2103      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2104      */
2105     boolean hasPayloadFormatCommand();
2106     /**
2107      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2108      */
2109     com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand();
2110     /**
2111      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2112      */
2113     com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder();
2114   }
2115   /**
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.PayloadFormatCommand.Builder subBuilder = null;
2218               if (((bitField0_ & 0x00000010) == 0x00000010)) {
2219                 subBuilder = payloadFormatCommand_.toBuilder();
2220               }
2221               payloadFormatCommand_ = input.readMessage(com.openxc.BinaryMessages.PayloadFormatCommand.PARSER, extensionRegistry);
2222               if (subBuilder != null) {
2223                 subBuilder.mergeFrom(payloadFormatCommand_);
2224                 payloadFormatCommand_ = 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>PAYLOAD_FORMAT = 6;</code>
2295        */
2296       PAYLOAD_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>PAYLOAD_FORMAT = 6;</code>
2321        */
2322       public static final int PAYLOAD_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 PAYLOAD_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.PayloadFormatCommand payload_format_command = 5;
2470     public static final int PAYLOAD_FORMAT_COMMAND_FIELD_NUMBER = 5;
2471     private com.openxc.BinaryMessages.PayloadFormatCommand payloadFormatCommand_;
2472     /**
2473      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2474      */
2475     public boolean hasPayloadFormatCommand() {
2476       return ((bitField0_ & 0x00000010) == 0x00000010);
2477     }
2478     /**
2479      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2480      */
2481     public com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand() {
2482       return payloadFormatCommand_;
2483     }
2484     /**
2485      * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
2486      */
2487     public com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder() {
2488       return payloadFormatCommand_;
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       payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.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, payloadFormatCommand_);
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, payloadFormatCommand_);
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           getPayloadFormatCommandFieldBuilder();
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 (payloadFormatCommandBuilder_ == null) {
2695           payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
2696         } else {
2697           payloadFormatCommandBuilder_.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 (payloadFormatCommandBuilder_ == null) {
2760           result.payloadFormatCommand_ = payloadFormatCommand_;
2761         } else {
2762           result.payloadFormatCommand_ = payloadFormatCommandBuilder_.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.hasPayloadFormatCommand()) {
2793           mergePayloadFormatCommand(other.getPayloadFormatCommand());
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.PayloadFormatCommand payload_format_command = 5;
3210       private com.openxc.BinaryMessages.PayloadFormatCommand payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
3211       private com.google.protobuf.SingleFieldBuilder<
3212           com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder> payloadFormatCommandBuilder_;
3213       /**
3214        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3215        */
3216       public boolean hasPayloadFormatCommand() {
3217         return ((bitField0_ & 0x00000010) == 0x00000010);
3218       }
3219       /**
3220        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3221        */
3222       public com.openxc.BinaryMessages.PayloadFormatCommand getPayloadFormatCommand() {
3223         if (payloadFormatCommandBuilder_ == null) {
3224           return payloadFormatCommand_;
3225         } else {
3226           return payloadFormatCommandBuilder_.getMessage();
3227         }
3228       }
3229       /**
3230        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3231        */
3232       public Builder setPayloadFormatCommand(com.openxc.BinaryMessages.PayloadFormatCommand value) {
3233         if (payloadFormatCommandBuilder_ == null) {
3234           if (value == null) {
3235             throw new NullPointerException();
3236           }
3237           payloadFormatCommand_ = value;
3238           onChanged();
3239         } else {
3240           payloadFormatCommandBuilder_.setMessage(value);
3241         }
3242         bitField0_ |= 0x00000010;
3243         return this;
3244       }
3245       /**
3246        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3247        */
3248       public Builder setPayloadFormatCommand(
3249           com.openxc.BinaryMessages.PayloadFormatCommand.Builder builderForValue) {
3250         if (payloadFormatCommandBuilder_ == null) {
3251           payloadFormatCommand_ = builderForValue.build();
3252           onChanged();
3253         } else {
3254           payloadFormatCommandBuilder_.setMessage(builderForValue.build());
3255         }
3256         bitField0_ |= 0x00000010;
3257         return this;
3258       }
3259       /**
3260        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3261        */
3262       public Builder mergePayloadFormatCommand(com.openxc.BinaryMessages.PayloadFormatCommand value) {
3263         if (payloadFormatCommandBuilder_ == null) {
3264           if (((bitField0_ & 0x00000010) == 0x00000010) &&
3265               payloadFormatCommand_ != com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance()) {
3266             payloadFormatCommand_ =
3267               com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder(payloadFormatCommand_).mergeFrom(value).buildPartial();
3268           } else {
3269             payloadFormatCommand_ = value;
3270           }
3271           onChanged();
3272         } else {
3273           payloadFormatCommandBuilder_.mergeFrom(value);
3274         }
3275         bitField0_ |= 0x00000010;
3276         return this;
3277       }
3278       /**
3279        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3280        */
3281       public Builder clearPayloadFormatCommand() {
3282         if (payloadFormatCommandBuilder_ == null) {
3283           payloadFormatCommand_ = com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
3284           onChanged();
3285         } else {
3286           payloadFormatCommandBuilder_.clear();
3287         }
3288         bitField0_ = (bitField0_ & ~0x00000010);
3289         return this;
3290       }
3291       /**
3292        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3293        */
3294       public com.openxc.BinaryMessages.PayloadFormatCommand.Builder getPayloadFormatCommandBuilder() {
3295         bitField0_ |= 0x00000010;
3296         onChanged();
3297         return getPayloadFormatCommandFieldBuilder().getBuilder();
3298       }
3299       /**
3300        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3301        */
3302       public com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder getPayloadFormatCommandOrBuilder() {
3303         if (payloadFormatCommandBuilder_ != null) {
3304           return payloadFormatCommandBuilder_.getMessageOrBuilder();
3305         } else {
3306           return payloadFormatCommand_;
3307         }
3308       }
3309       /**
3310        * <code>optional .openxc.PayloadFormatCommand payload_format_command = 5;</code>
3311        */
3312       private com.google.protobuf.SingleFieldBuilder<
3313           com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder>
3314           getPayloadFormatCommandFieldBuilder() {
3315         if (payloadFormatCommandBuilder_ == null) {
3316           payloadFormatCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
3317               com.openxc.BinaryMessages.PayloadFormatCommand, com.openxc.BinaryMessages.PayloadFormatCommand.Builder, com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder>(
3318                   payloadFormatCommand_,
3319                   getParentForChildren(),
3320                   isClean());
3321           payloadFormatCommand_ = null;
3322         }
3323         return payloadFormatCommandBuilder_;
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 PayloadFormatCommandOrBuilder
4971       extends com.google.protobuf.MessageOrBuilder {
4972
4973     // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
4974     /**
4975      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
4976      */
4977     boolean hasFormat();
4978     /**
4979      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
4980      */
4981     com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat();
4982   }
4983   /**
4984    * Protobuf type {@code openxc.PayloadFormatCommand}
4985    */
4986   public static final class PayloadFormatCommand extends
4987       com.google.protobuf.GeneratedMessage
4988       implements PayloadFormatCommandOrBuilder {
4989     // Use PayloadFormatCommand.newBuilder() to construct.
4990     private PayloadFormatCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4991       super(builder);
4992       this.unknownFields = builder.getUnknownFields();
4993     }
4994     private PayloadFormatCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4995
4996     private static final PayloadFormatCommand defaultInstance;
4997     public static PayloadFormatCommand getDefaultInstance() {
4998       return defaultInstance;
4999     }
5000
5001     public PayloadFormatCommand getDefaultInstanceForType() {
5002       return defaultInstance;
5003     }
5004
5005     private final com.google.protobuf.UnknownFieldSet unknownFields;
5006     @java.lang.Override
5007     public final com.google.protobuf.UnknownFieldSet
5008         getUnknownFields() {
5009       return this.unknownFields;
5010     }
5011     private PayloadFormatCommand(
5012         com.google.protobuf.CodedInputStream input,
5013         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5014         throws com.google.protobuf.InvalidProtocolBufferException {
5015       initFields();
5016       int mutable_bitField0_ = 0;
5017       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5018           com.google.protobuf.UnknownFieldSet.newBuilder();
5019       try {
5020         boolean done = false;
5021         while (!done) {
5022           int tag = input.readTag();
5023           switch (tag) {
5024             case 0:
5025               done = true;
5026               break;
5027             default: {
5028               if (!parseUnknownField(input, unknownFields,
5029                                      extensionRegistry, tag)) {
5030                 done = true;
5031               }
5032               break;
5033             }
5034             case 8: {
5035               int rawValue = input.readEnum();
5036               com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat value = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.valueOf(rawValue);
5037               if (value == null) {
5038                 unknownFields.mergeVarintField(1, rawValue);
5039               } else {
5040                 bitField0_ |= 0x00000001;
5041                 format_ = value;
5042               }
5043               break;
5044             }
5045           }
5046         }
5047       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5048         throw e.setUnfinishedMessage(this);
5049       } catch (java.io.IOException e) {
5050         throw new com.google.protobuf.InvalidProtocolBufferException(
5051             e.getMessage()).setUnfinishedMessage(this);
5052       } finally {
5053         this.unknownFields = unknownFields.build();
5054         makeExtensionsImmutable();
5055       }
5056     }
5057     public static final com.google.protobuf.Descriptors.Descriptor
5058         getDescriptor() {
5059       return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
5060     }
5061
5062     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5063         internalGetFieldAccessorTable() {
5064       return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_fieldAccessorTable
5065           .ensureFieldAccessorsInitialized(
5066               com.openxc.BinaryMessages.PayloadFormatCommand.class, com.openxc.BinaryMessages.PayloadFormatCommand.Builder.class);
5067     }
5068
5069     public static com.google.protobuf.Parser<PayloadFormatCommand> PARSER =
5070         new com.google.protobuf.AbstractParser<PayloadFormatCommand>() {
5071       public PayloadFormatCommand parsePartialFrom(
5072           com.google.protobuf.CodedInputStream input,
5073           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5074           throws com.google.protobuf.InvalidProtocolBufferException {
5075         return new PayloadFormatCommand(input, extensionRegistry);
5076       }
5077     };
5078
5079     @java.lang.Override
5080     public com.google.protobuf.Parser<PayloadFormatCommand> getParserForType() {
5081       return PARSER;
5082     }
5083
5084     /**
5085      * Protobuf enum {@code openxc.PayloadFormatCommand.PayloadFormat}
5086      */
5087     public enum PayloadFormat
5088         implements com.google.protobuf.ProtocolMessageEnum {
5089       /**
5090        * <code>JSON = 1;</code>
5091        */
5092       JSON(0, 1),
5093       /**
5094        * <code>PROTOBUF = 2;</code>
5095        */
5096       PROTOBUF(1, 2),
5097       ;
5098
5099       /**
5100        * <code>JSON = 1;</code>
5101        */
5102       public static final int JSON_VALUE = 1;
5103       /**
5104        * <code>PROTOBUF = 2;</code>
5105        */
5106       public static final int PROTOBUF_VALUE = 2;
5107
5108
5109       public final int getNumber() { return value; }
5110
5111       public static PayloadFormat valueOf(int value) {
5112         switch (value) {
5113           case 1: return JSON;
5114           case 2: return PROTOBUF;
5115           default: return null;
5116         }
5117       }
5118
5119       public static com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>
5120           internalGetValueMap() {
5121         return internalValueMap;
5122       }
5123       private static com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>
5124           internalValueMap =
5125             new com.google.protobuf.Internal.EnumLiteMap<PayloadFormat>() {
5126               public PayloadFormat findValueByNumber(int number) {
5127                 return PayloadFormat.valueOf(number);
5128               }
5129             };
5130
5131       public final com.google.protobuf.Descriptors.EnumValueDescriptor
5132           getValueDescriptor() {
5133         return getDescriptor().getValues().get(index);
5134       }
5135       public final com.google.protobuf.Descriptors.EnumDescriptor
5136           getDescriptorForType() {
5137         return getDescriptor();
5138       }
5139       public static final com.google.protobuf.Descriptors.EnumDescriptor
5140           getDescriptor() {
5141         return com.openxc.BinaryMessages.PayloadFormatCommand.getDescriptor().getEnumTypes().get(0);
5142       }
5143
5144       private static final PayloadFormat[] VALUES = values();
5145
5146       public static PayloadFormat valueOf(
5147           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
5148         if (desc.getType() != getDescriptor()) {
5149           throw new java.lang.IllegalArgumentException(
5150             "EnumValueDescriptor is not for this type.");
5151         }
5152         return VALUES[desc.getIndex()];
5153       }
5154
5155       private final int index;
5156       private final int value;
5157
5158       private PayloadFormat(int index, int value) {
5159         this.index = index;
5160         this.value = value;
5161       }
5162
5163       // @@protoc_insertion_point(enum_scope:openxc.PayloadFormatCommand.PayloadFormat)
5164     }
5165
5166     private int bitField0_;
5167     // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
5168     public static final int FORMAT_FIELD_NUMBER = 1;
5169     private com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat format_;
5170     /**
5171      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5172      */
5173     public boolean hasFormat() {
5174       return ((bitField0_ & 0x00000001) == 0x00000001);
5175     }
5176     /**
5177      * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5178      */
5179     public com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat() {
5180       return format_;
5181     }
5182
5183     private void initFields() {
5184       format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
5185     }
5186     private byte memoizedIsInitialized = -1;
5187     public final boolean isInitialized() {
5188       byte isInitialized = memoizedIsInitialized;
5189       if (isInitialized != -1) return isInitialized == 1;
5190
5191       memoizedIsInitialized = 1;
5192       return true;
5193     }
5194
5195     public void writeTo(com.google.protobuf.CodedOutputStream output)
5196                         throws java.io.IOException {
5197       getSerializedSize();
5198       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5199         output.writeEnum(1, format_.getNumber());
5200       }
5201       getUnknownFields().writeTo(output);
5202     }
5203
5204     private int memoizedSerializedSize = -1;
5205     public int getSerializedSize() {
5206       int size = memoizedSerializedSize;
5207       if (size != -1) return size;
5208
5209       size = 0;
5210       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5211         size += com.google.protobuf.CodedOutputStream
5212           .computeEnumSize(1, format_.getNumber());
5213       }
5214       size += getUnknownFields().getSerializedSize();
5215       memoizedSerializedSize = size;
5216       return size;
5217     }
5218
5219     private static final long serialVersionUID = 0L;
5220     @java.lang.Override
5221     protected java.lang.Object writeReplace()
5222         throws java.io.ObjectStreamException {
5223       return super.writeReplace();
5224     }
5225
5226     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
5227         com.google.protobuf.ByteString data)
5228         throws com.google.protobuf.InvalidProtocolBufferException {
5229       return PARSER.parseFrom(data);
5230     }
5231     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
5232         com.google.protobuf.ByteString data,
5233         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5234         throws com.google.protobuf.InvalidProtocolBufferException {
5235       return PARSER.parseFrom(data, extensionRegistry);
5236     }
5237     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(byte[] data)
5238         throws com.google.protobuf.InvalidProtocolBufferException {
5239       return PARSER.parseFrom(data);
5240     }
5241     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
5242         byte[] data,
5243         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5244         throws com.google.protobuf.InvalidProtocolBufferException {
5245       return PARSER.parseFrom(data, extensionRegistry);
5246     }
5247     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(java.io.InputStream input)
5248         throws java.io.IOException {
5249       return PARSER.parseFrom(input);
5250     }
5251     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
5252         java.io.InputStream input,
5253         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5254         throws java.io.IOException {
5255       return PARSER.parseFrom(input, extensionRegistry);
5256     }
5257     public static com.openxc.BinaryMessages.PayloadFormatCommand parseDelimitedFrom(java.io.InputStream input)
5258         throws java.io.IOException {
5259       return PARSER.parseDelimitedFrom(input);
5260     }
5261     public static com.openxc.BinaryMessages.PayloadFormatCommand parseDelimitedFrom(
5262         java.io.InputStream input,
5263         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5264         throws java.io.IOException {
5265       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5266     }
5267     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
5268         com.google.protobuf.CodedInputStream input)
5269         throws java.io.IOException {
5270       return PARSER.parseFrom(input);
5271     }
5272     public static com.openxc.BinaryMessages.PayloadFormatCommand parseFrom(
5273         com.google.protobuf.CodedInputStream input,
5274         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5275         throws java.io.IOException {
5276       return PARSER.parseFrom(input, extensionRegistry);
5277     }
5278
5279     public static Builder newBuilder() { return Builder.create(); }
5280     public Builder newBuilderForType() { return newBuilder(); }
5281     public static Builder newBuilder(com.openxc.BinaryMessages.PayloadFormatCommand prototype) {
5282       return newBuilder().mergeFrom(prototype);
5283     }
5284     public Builder toBuilder() { return newBuilder(this); }
5285
5286     @java.lang.Override
5287     protected Builder newBuilderForType(
5288         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5289       Builder builder = new Builder(parent);
5290       return builder;
5291     }
5292     /**
5293      * Protobuf type {@code openxc.PayloadFormatCommand}
5294      */
5295     public static final class Builder extends
5296         com.google.protobuf.GeneratedMessage.Builder<Builder>
5297        implements com.openxc.BinaryMessages.PayloadFormatCommandOrBuilder {
5298       public static final com.google.protobuf.Descriptors.Descriptor
5299           getDescriptor() {
5300         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
5301       }
5302
5303       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5304           internalGetFieldAccessorTable() {
5305         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_fieldAccessorTable
5306             .ensureFieldAccessorsInitialized(
5307                 com.openxc.BinaryMessages.PayloadFormatCommand.class, com.openxc.BinaryMessages.PayloadFormatCommand.Builder.class);
5308       }
5309
5310       // Construct using com.openxc.BinaryMessages.PayloadFormatCommand.newBuilder()
5311       private Builder() {
5312         maybeForceBuilderInitialization();
5313       }
5314
5315       private Builder(
5316           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5317         super(parent);
5318         maybeForceBuilderInitialization();
5319       }
5320       private void maybeForceBuilderInitialization() {
5321         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5322         }
5323       }
5324       private static Builder create() {
5325         return new Builder();
5326       }
5327
5328       public Builder clear() {
5329         super.clear();
5330         format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
5331         bitField0_ = (bitField0_ & ~0x00000001);
5332         return this;
5333       }
5334
5335       public Builder clone() {
5336         return create().mergeFrom(buildPartial());
5337       }
5338
5339       public com.google.protobuf.Descriptors.Descriptor
5340           getDescriptorForType() {
5341         return com.openxc.BinaryMessages.internal_static_openxc_PayloadFormatCommand_descriptor;
5342       }
5343
5344       public com.openxc.BinaryMessages.PayloadFormatCommand getDefaultInstanceForType() {
5345         return com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance();
5346       }
5347
5348       public com.openxc.BinaryMessages.PayloadFormatCommand build() {
5349         com.openxc.BinaryMessages.PayloadFormatCommand result = buildPartial();
5350         if (!result.isInitialized()) {
5351           throw newUninitializedMessageException(result);
5352         }
5353         return result;
5354       }
5355
5356       public com.openxc.BinaryMessages.PayloadFormatCommand buildPartial() {
5357         com.openxc.BinaryMessages.PayloadFormatCommand result = new com.openxc.BinaryMessages.PayloadFormatCommand(this);
5358         int from_bitField0_ = bitField0_;
5359         int to_bitField0_ = 0;
5360         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5361           to_bitField0_ |= 0x00000001;
5362         }
5363         result.format_ = format_;
5364         result.bitField0_ = to_bitField0_;
5365         onBuilt();
5366         return result;
5367       }
5368
5369       public Builder mergeFrom(com.google.protobuf.Message other) {
5370         if (other instanceof com.openxc.BinaryMessages.PayloadFormatCommand) {
5371           return mergeFrom((com.openxc.BinaryMessages.PayloadFormatCommand)other);
5372         } else {
5373           super.mergeFrom(other);
5374           return this;
5375         }
5376       }
5377
5378       public Builder mergeFrom(com.openxc.BinaryMessages.PayloadFormatCommand other) {
5379         if (other == com.openxc.BinaryMessages.PayloadFormatCommand.getDefaultInstance()) return this;
5380         if (other.hasFormat()) {
5381           setFormat(other.getFormat());
5382         }
5383         this.mergeUnknownFields(other.getUnknownFields());
5384         return this;
5385       }
5386
5387       public final boolean isInitialized() {
5388         return true;
5389       }
5390
5391       public Builder mergeFrom(
5392           com.google.protobuf.CodedInputStream input,
5393           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5394           throws java.io.IOException {
5395         com.openxc.BinaryMessages.PayloadFormatCommand parsedMessage = null;
5396         try {
5397           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5398         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5399           parsedMessage = (com.openxc.BinaryMessages.PayloadFormatCommand) e.getUnfinishedMessage();
5400           throw e;
5401         } finally {
5402           if (parsedMessage != null) {
5403             mergeFrom(parsedMessage);
5404           }
5405         }
5406         return this;
5407       }
5408       private int bitField0_;
5409
5410       // optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;
5411       private com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
5412       /**
5413        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5414        */
5415       public boolean hasFormat() {
5416         return ((bitField0_ & 0x00000001) == 0x00000001);
5417       }
5418       /**
5419        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5420        */
5421       public com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat getFormat() {
5422         return format_;
5423       }
5424       /**
5425        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5426        */
5427       public Builder setFormat(com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat value) {
5428         if (value == null) {
5429           throw new NullPointerException();
5430         }
5431         bitField0_ |= 0x00000001;
5432         format_ = value;
5433         onChanged();
5434         return this;
5435       }
5436       /**
5437        * <code>optional .openxc.PayloadFormatCommand.PayloadFormat format = 1;</code>
5438        */
5439       public Builder clearFormat() {
5440         bitField0_ = (bitField0_ & ~0x00000001);
5441         format_ = com.openxc.BinaryMessages.PayloadFormatCommand.PayloadFormat.JSON;
5442         onChanged();
5443         return this;
5444       }
5445
5446       // @@protoc_insertion_point(builder_scope:openxc.PayloadFormatCommand)
5447     }
5448
5449     static {
5450       defaultInstance = new PayloadFormatCommand(true);
5451       defaultInstance.initFields();
5452     }
5453
5454     // @@protoc_insertion_point(class_scope:openxc.PayloadFormatCommand)
5455   }
5456
5457   public interface CommandResponseOrBuilder
5458       extends com.google.protobuf.MessageOrBuilder {
5459
5460     // optional .openxc.ControlCommand.Type type = 1;
5461     /**
5462      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5463      */
5464     boolean hasType();
5465     /**
5466      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5467      */
5468     com.openxc.BinaryMessages.ControlCommand.Type getType();
5469
5470     // optional string message = 2;
5471     /**
5472      * <code>optional string message = 2;</code>
5473      */
5474     boolean hasMessage();
5475     /**
5476      * <code>optional string message = 2;</code>
5477      */
5478     java.lang.String getMessage();
5479     /**
5480      * <code>optional string message = 2;</code>
5481      */
5482     com.google.protobuf.ByteString
5483         getMessageBytes();
5484
5485     // optional bool status = 3;
5486     /**
5487      * <code>optional bool status = 3;</code>
5488      */
5489     boolean hasStatus();
5490     /**
5491      * <code>optional bool status = 3;</code>
5492      */
5493     boolean getStatus();
5494   }
5495   /**
5496    * Protobuf type {@code openxc.CommandResponse}
5497    */
5498   public static final class CommandResponse extends
5499       com.google.protobuf.GeneratedMessage
5500       implements CommandResponseOrBuilder {
5501     // Use CommandResponse.newBuilder() to construct.
5502     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5503       super(builder);
5504       this.unknownFields = builder.getUnknownFields();
5505     }
5506     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5507
5508     private static final CommandResponse defaultInstance;
5509     public static CommandResponse getDefaultInstance() {
5510       return defaultInstance;
5511     }
5512
5513     public CommandResponse getDefaultInstanceForType() {
5514       return defaultInstance;
5515     }
5516
5517     private final com.google.protobuf.UnknownFieldSet unknownFields;
5518     @java.lang.Override
5519     public final com.google.protobuf.UnknownFieldSet
5520         getUnknownFields() {
5521       return this.unknownFields;
5522     }
5523     private CommandResponse(
5524         com.google.protobuf.CodedInputStream input,
5525         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5526         throws com.google.protobuf.InvalidProtocolBufferException {
5527       initFields();
5528       int mutable_bitField0_ = 0;
5529       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5530           com.google.protobuf.UnknownFieldSet.newBuilder();
5531       try {
5532         boolean done = false;
5533         while (!done) {
5534           int tag = input.readTag();
5535           switch (tag) {
5536             case 0:
5537               done = true;
5538               break;
5539             default: {
5540               if (!parseUnknownField(input, unknownFields,
5541                                      extensionRegistry, tag)) {
5542                 done = true;
5543               }
5544               break;
5545             }
5546             case 8: {
5547               int rawValue = input.readEnum();
5548               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
5549               if (value == null) {
5550                 unknownFields.mergeVarintField(1, rawValue);
5551               } else {
5552                 bitField0_ |= 0x00000001;
5553                 type_ = value;
5554               }
5555               break;
5556             }
5557             case 18: {
5558               bitField0_ |= 0x00000002;
5559               message_ = input.readBytes();
5560               break;
5561             }
5562             case 24: {
5563               bitField0_ |= 0x00000004;
5564               status_ = input.readBool();
5565               break;
5566             }
5567           }
5568         }
5569       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5570         throw e.setUnfinishedMessage(this);
5571       } catch (java.io.IOException e) {
5572         throw new com.google.protobuf.InvalidProtocolBufferException(
5573             e.getMessage()).setUnfinishedMessage(this);
5574       } finally {
5575         this.unknownFields = unknownFields.build();
5576         makeExtensionsImmutable();
5577       }
5578     }
5579     public static final com.google.protobuf.Descriptors.Descriptor
5580         getDescriptor() {
5581       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
5582     }
5583
5584     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5585         internalGetFieldAccessorTable() {
5586       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
5587           .ensureFieldAccessorsInitialized(
5588               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
5589     }
5590
5591     public static com.google.protobuf.Parser<CommandResponse> PARSER =
5592         new com.google.protobuf.AbstractParser<CommandResponse>() {
5593       public CommandResponse parsePartialFrom(
5594           com.google.protobuf.CodedInputStream input,
5595           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5596           throws com.google.protobuf.InvalidProtocolBufferException {
5597         return new CommandResponse(input, extensionRegistry);
5598       }
5599     };
5600
5601     @java.lang.Override
5602     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
5603       return PARSER;
5604     }
5605
5606     private int bitField0_;
5607     // optional .openxc.ControlCommand.Type type = 1;
5608     public static final int TYPE_FIELD_NUMBER = 1;
5609     private com.openxc.BinaryMessages.ControlCommand.Type type_;
5610     /**
5611      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5612      */
5613     public boolean hasType() {
5614       return ((bitField0_ & 0x00000001) == 0x00000001);
5615     }
5616     /**
5617      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5618      */
5619     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
5620       return type_;
5621     }
5622
5623     // optional string message = 2;
5624     public static final int MESSAGE_FIELD_NUMBER = 2;
5625     private java.lang.Object message_;
5626     /**
5627      * <code>optional string message = 2;</code>
5628      */
5629     public boolean hasMessage() {
5630       return ((bitField0_ & 0x00000002) == 0x00000002);
5631     }
5632     /**
5633      * <code>optional string message = 2;</code>
5634      */
5635     public java.lang.String getMessage() {
5636       java.lang.Object ref = message_;
5637       if (ref instanceof java.lang.String) {
5638         return (java.lang.String) ref;
5639       } else {
5640         com.google.protobuf.ByteString bs =
5641             (com.google.protobuf.ByteString) ref;
5642         java.lang.String s = bs.toStringUtf8();
5643         if (bs.isValidUtf8()) {
5644           message_ = s;
5645         }
5646         return s;
5647       }
5648     }
5649     /**
5650      * <code>optional string message = 2;</code>
5651      */
5652     public com.google.protobuf.ByteString
5653         getMessageBytes() {
5654       java.lang.Object ref = message_;
5655       if (ref instanceof java.lang.String) {
5656         com.google.protobuf.ByteString b =
5657             com.google.protobuf.ByteString.copyFromUtf8(
5658                 (java.lang.String) ref);
5659         message_ = b;
5660         return b;
5661       } else {
5662         return (com.google.protobuf.ByteString) ref;
5663       }
5664     }
5665
5666     // optional bool status = 3;
5667     public static final int STATUS_FIELD_NUMBER = 3;
5668     private boolean status_;
5669     /**
5670      * <code>optional bool status = 3;</code>
5671      */
5672     public boolean hasStatus() {
5673       return ((bitField0_ & 0x00000004) == 0x00000004);
5674     }
5675     /**
5676      * <code>optional bool status = 3;</code>
5677      */
5678     public boolean getStatus() {
5679       return status_;
5680     }
5681
5682     private void initFields() {
5683       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
5684       message_ = "";
5685       status_ = false;
5686     }
5687     private byte memoizedIsInitialized = -1;
5688     public final boolean isInitialized() {
5689       byte isInitialized = memoizedIsInitialized;
5690       if (isInitialized != -1) return isInitialized == 1;
5691
5692       memoizedIsInitialized = 1;
5693       return true;
5694     }
5695
5696     public void writeTo(com.google.protobuf.CodedOutputStream output)
5697                         throws java.io.IOException {
5698       getSerializedSize();
5699       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5700         output.writeEnum(1, type_.getNumber());
5701       }
5702       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5703         output.writeBytes(2, getMessageBytes());
5704       }
5705       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5706         output.writeBool(3, status_);
5707       }
5708       getUnknownFields().writeTo(output);
5709     }
5710
5711     private int memoizedSerializedSize = -1;
5712     public int getSerializedSize() {
5713       int size = memoizedSerializedSize;
5714       if (size != -1) return size;
5715
5716       size = 0;
5717       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5718         size += com.google.protobuf.CodedOutputStream
5719           .computeEnumSize(1, type_.getNumber());
5720       }
5721       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5722         size += com.google.protobuf.CodedOutputStream
5723           .computeBytesSize(2, getMessageBytes());
5724       }
5725       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5726         size += com.google.protobuf.CodedOutputStream
5727           .computeBoolSize(3, status_);
5728       }
5729       size += getUnknownFields().getSerializedSize();
5730       memoizedSerializedSize = size;
5731       return size;
5732     }
5733
5734     private static final long serialVersionUID = 0L;
5735     @java.lang.Override
5736     protected java.lang.Object writeReplace()
5737         throws java.io.ObjectStreamException {
5738       return super.writeReplace();
5739     }
5740
5741     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
5742         com.google.protobuf.ByteString data)
5743         throws com.google.protobuf.InvalidProtocolBufferException {
5744       return PARSER.parseFrom(data);
5745     }
5746     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
5747         com.google.protobuf.ByteString data,
5748         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5749         throws com.google.protobuf.InvalidProtocolBufferException {
5750       return PARSER.parseFrom(data, extensionRegistry);
5751     }
5752     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
5753         throws com.google.protobuf.InvalidProtocolBufferException {
5754       return PARSER.parseFrom(data);
5755     }
5756     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
5757         byte[] data,
5758         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5759         throws com.google.protobuf.InvalidProtocolBufferException {
5760       return PARSER.parseFrom(data, extensionRegistry);
5761     }
5762     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
5763         throws java.io.IOException {
5764       return PARSER.parseFrom(input);
5765     }
5766     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
5767         java.io.InputStream input,
5768         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5769         throws java.io.IOException {
5770       return PARSER.parseFrom(input, extensionRegistry);
5771     }
5772     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
5773         throws java.io.IOException {
5774       return PARSER.parseDelimitedFrom(input);
5775     }
5776     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
5777         java.io.InputStream input,
5778         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5779         throws java.io.IOException {
5780       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5781     }
5782     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
5783         com.google.protobuf.CodedInputStream input)
5784         throws java.io.IOException {
5785       return PARSER.parseFrom(input);
5786     }
5787     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
5788         com.google.protobuf.CodedInputStream input,
5789         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5790         throws java.io.IOException {
5791       return PARSER.parseFrom(input, extensionRegistry);
5792     }
5793
5794     public static Builder newBuilder() { return Builder.create(); }
5795     public Builder newBuilderForType() { return newBuilder(); }
5796     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
5797       return newBuilder().mergeFrom(prototype);
5798     }
5799     public Builder toBuilder() { return newBuilder(this); }
5800
5801     @java.lang.Override
5802     protected Builder newBuilderForType(
5803         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5804       Builder builder = new Builder(parent);
5805       return builder;
5806     }
5807     /**
5808      * Protobuf type {@code openxc.CommandResponse}
5809      */
5810     public static final class Builder extends
5811         com.google.protobuf.GeneratedMessage.Builder<Builder>
5812        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
5813       public static final com.google.protobuf.Descriptors.Descriptor
5814           getDescriptor() {
5815         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
5816       }
5817
5818       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5819           internalGetFieldAccessorTable() {
5820         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
5821             .ensureFieldAccessorsInitialized(
5822                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
5823       }
5824
5825       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
5826       private Builder() {
5827         maybeForceBuilderInitialization();
5828       }
5829
5830       private Builder(
5831           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5832         super(parent);
5833         maybeForceBuilderInitialization();
5834       }
5835       private void maybeForceBuilderInitialization() {
5836         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5837         }
5838       }
5839       private static Builder create() {
5840         return new Builder();
5841       }
5842
5843       public Builder clear() {
5844         super.clear();
5845         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
5846         bitField0_ = (bitField0_ & ~0x00000001);
5847         message_ = "";
5848         bitField0_ = (bitField0_ & ~0x00000002);
5849         status_ = false;
5850         bitField0_ = (bitField0_ & ~0x00000004);
5851         return this;
5852       }
5853
5854       public Builder clone() {
5855         return create().mergeFrom(buildPartial());
5856       }
5857
5858       public com.google.protobuf.Descriptors.Descriptor
5859           getDescriptorForType() {
5860         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
5861       }
5862
5863       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
5864         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
5865       }
5866
5867       public com.openxc.BinaryMessages.CommandResponse build() {
5868         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
5869         if (!result.isInitialized()) {
5870           throw newUninitializedMessageException(result);
5871         }
5872         return result;
5873       }
5874
5875       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
5876         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
5877         int from_bitField0_ = bitField0_;
5878         int to_bitField0_ = 0;
5879         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5880           to_bitField0_ |= 0x00000001;
5881         }
5882         result.type_ = type_;
5883         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5884           to_bitField0_ |= 0x00000002;
5885         }
5886         result.message_ = message_;
5887         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5888           to_bitField0_ |= 0x00000004;
5889         }
5890         result.status_ = status_;
5891         result.bitField0_ = to_bitField0_;
5892         onBuilt();
5893         return result;
5894       }
5895
5896       public Builder mergeFrom(com.google.protobuf.Message other) {
5897         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
5898           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
5899         } else {
5900           super.mergeFrom(other);
5901           return this;
5902         }
5903       }
5904
5905       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
5906         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
5907         if (other.hasType()) {
5908           setType(other.getType());
5909         }
5910         if (other.hasMessage()) {
5911           bitField0_ |= 0x00000002;
5912           message_ = other.message_;
5913           onChanged();
5914         }
5915         if (other.hasStatus()) {
5916           setStatus(other.getStatus());
5917         }
5918         this.mergeUnknownFields(other.getUnknownFields());
5919         return this;
5920       }
5921
5922       public final boolean isInitialized() {
5923         return true;
5924       }
5925
5926       public Builder mergeFrom(
5927           com.google.protobuf.CodedInputStream input,
5928           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5929           throws java.io.IOException {
5930         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
5931         try {
5932           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5933         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5934           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
5935           throw e;
5936         } finally {
5937           if (parsedMessage != null) {
5938             mergeFrom(parsedMessage);
5939           }
5940         }
5941         return this;
5942       }
5943       private int bitField0_;
5944
5945       // optional .openxc.ControlCommand.Type type = 1;
5946       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
5947       /**
5948        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5949        */
5950       public boolean hasType() {
5951         return ((bitField0_ & 0x00000001) == 0x00000001);
5952       }
5953       /**
5954        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5955        */
5956       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
5957         return type_;
5958       }
5959       /**
5960        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5961        */
5962       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
5963         if (value == null) {
5964           throw new NullPointerException();
5965         }
5966         bitField0_ |= 0x00000001;
5967         type_ = value;
5968         onChanged();
5969         return this;
5970       }
5971       /**
5972        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
5973        */
5974       public Builder clearType() {
5975         bitField0_ = (bitField0_ & ~0x00000001);
5976         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
5977         onChanged();
5978         return this;
5979       }
5980
5981       // optional string message = 2;
5982       private java.lang.Object message_ = "";
5983       /**
5984        * <code>optional string message = 2;</code>
5985        */
5986       public boolean hasMessage() {
5987         return ((bitField0_ & 0x00000002) == 0x00000002);
5988       }
5989       /**
5990        * <code>optional string message = 2;</code>
5991        */
5992       public java.lang.String getMessage() {
5993         java.lang.Object ref = message_;
5994         if (!(ref instanceof java.lang.String)) {
5995           java.lang.String s = ((com.google.protobuf.ByteString) ref)
5996               .toStringUtf8();
5997           message_ = s;
5998           return s;
5999         } else {
6000           return (java.lang.String) ref;
6001         }
6002       }
6003       /**
6004        * <code>optional string message = 2;</code>
6005        */
6006       public com.google.protobuf.ByteString
6007           getMessageBytes() {
6008         java.lang.Object ref = message_;
6009         if (ref instanceof String) {
6010           com.google.protobuf.ByteString b =
6011               com.google.protobuf.ByteString.copyFromUtf8(
6012                   (java.lang.String) ref);
6013           message_ = b;
6014           return b;
6015         } else {
6016           return (com.google.protobuf.ByteString) ref;
6017         }
6018       }
6019       /**
6020        * <code>optional string message = 2;</code>
6021        */
6022       public Builder setMessage(
6023           java.lang.String value) {
6024         if (value == null) {
6025     throw new NullPointerException();
6026   }
6027   bitField0_ |= 0x00000002;
6028         message_ = value;
6029         onChanged();
6030         return this;
6031       }
6032       /**
6033        * <code>optional string message = 2;</code>
6034        */
6035       public Builder clearMessage() {
6036         bitField0_ = (bitField0_ & ~0x00000002);
6037         message_ = getDefaultInstance().getMessage();
6038         onChanged();
6039         return this;
6040       }
6041       /**
6042        * <code>optional string message = 2;</code>
6043        */
6044       public Builder setMessageBytes(
6045           com.google.protobuf.ByteString value) {
6046         if (value == null) {
6047     throw new NullPointerException();
6048   }
6049   bitField0_ |= 0x00000002;
6050         message_ = value;
6051         onChanged();
6052         return this;
6053       }
6054
6055       // optional bool status = 3;
6056       private boolean status_ ;
6057       /**
6058        * <code>optional bool status = 3;</code>
6059        */
6060       public boolean hasStatus() {
6061         return ((bitField0_ & 0x00000004) == 0x00000004);
6062       }
6063       /**
6064        * <code>optional bool status = 3;</code>
6065        */
6066       public boolean getStatus() {
6067         return status_;
6068       }
6069       /**
6070        * <code>optional bool status = 3;</code>
6071        */
6072       public Builder setStatus(boolean value) {
6073         bitField0_ |= 0x00000004;
6074         status_ = value;
6075         onChanged();
6076         return this;
6077       }
6078       /**
6079        * <code>optional bool status = 3;</code>
6080        */
6081       public Builder clearStatus() {
6082         bitField0_ = (bitField0_ & ~0x00000004);
6083         status_ = false;
6084         onChanged();
6085         return this;
6086       }
6087
6088       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
6089     }
6090
6091     static {
6092       defaultInstance = new CommandResponse(true);
6093       defaultInstance.initFields();
6094     }
6095
6096     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
6097   }
6098
6099   public interface DiagnosticRequestOrBuilder
6100       extends com.google.protobuf.MessageOrBuilder {
6101
6102     // optional int32 bus = 1;
6103     /**
6104      * <code>optional int32 bus = 1;</code>
6105      */
6106     boolean hasBus();
6107     /**
6108      * <code>optional int32 bus = 1;</code>
6109      */
6110     int getBus();
6111
6112     // optional uint32 message_id = 2;
6113     /**
6114      * <code>optional uint32 message_id = 2;</code>
6115      */
6116     boolean hasMessageId();
6117     /**
6118      * <code>optional uint32 message_id = 2;</code>
6119      */
6120     int getMessageId();
6121
6122     // optional uint32 mode = 3;
6123     /**
6124      * <code>optional uint32 mode = 3;</code>
6125      */
6126     boolean hasMode();
6127     /**
6128      * <code>optional uint32 mode = 3;</code>
6129      */
6130     int getMode();
6131
6132     // optional uint32 pid = 4;
6133     /**
6134      * <code>optional uint32 pid = 4;</code>
6135      */
6136     boolean hasPid();
6137     /**
6138      * <code>optional uint32 pid = 4;</code>
6139      */
6140     int getPid();
6141
6142     // optional bytes payload = 5;
6143     /**
6144      * <code>optional bytes payload = 5;</code>
6145      *
6146      * <pre>
6147      * TODO we are capping this at 8 bytes for now - need to change when we
6148      * support multi-frame responses
6149      * </pre>
6150      */
6151     boolean hasPayload();
6152     /**
6153      * <code>optional bytes payload = 5;</code>
6154      *
6155      * <pre>
6156      * TODO we are capping this at 8 bytes for now - need to change when we
6157      * support multi-frame responses
6158      * </pre>
6159      */
6160     com.google.protobuf.ByteString getPayload();
6161
6162     // optional bool multiple_responses = 6;
6163     /**
6164      * <code>optional bool multiple_responses = 6;</code>
6165      */
6166     boolean hasMultipleResponses();
6167     /**
6168      * <code>optional bool multiple_responses = 6;</code>
6169      */
6170     boolean getMultipleResponses();
6171
6172     // optional double frequency = 7;
6173     /**
6174      * <code>optional double frequency = 7;</code>
6175      */
6176     boolean hasFrequency();
6177     /**
6178      * <code>optional double frequency = 7;</code>
6179      */
6180     double getFrequency();
6181
6182     // optional string name = 8;
6183     /**
6184      * <code>optional string name = 8;</code>
6185      */
6186     boolean hasName();
6187     /**
6188      * <code>optional string name = 8;</code>
6189      */
6190     java.lang.String getName();
6191     /**
6192      * <code>optional string name = 8;</code>
6193      */
6194     com.google.protobuf.ByteString
6195         getNameBytes();
6196
6197     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
6198     /**
6199      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
6200      */
6201     boolean hasDecodedType();
6202     /**
6203      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
6204      */
6205     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
6206   }
6207   /**
6208    * Protobuf type {@code openxc.DiagnosticRequest}
6209    */
6210   public static final class DiagnosticRequest extends
6211       com.google.protobuf.GeneratedMessage
6212       implements DiagnosticRequestOrBuilder {
6213     // Use DiagnosticRequest.newBuilder() to construct.
6214     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6215       super(builder);
6216       this.unknownFields = builder.getUnknownFields();
6217     }
6218     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6219
6220     private static final DiagnosticRequest defaultInstance;
6221     public static DiagnosticRequest getDefaultInstance() {
6222       return defaultInstance;
6223     }
6224
6225     public DiagnosticRequest getDefaultInstanceForType() {
6226       return defaultInstance;
6227     }
6228
6229     private final com.google.protobuf.UnknownFieldSet unknownFields;
6230     @java.lang.Override
6231     public final com.google.protobuf.UnknownFieldSet
6232         getUnknownFields() {
6233       return this.unknownFields;
6234     }
6235     private DiagnosticRequest(
6236         com.google.protobuf.CodedInputStream input,
6237         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6238         throws com.google.protobuf.InvalidProtocolBufferException {
6239       initFields();
6240       int mutable_bitField0_ = 0;
6241       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6242           com.google.protobuf.UnknownFieldSet.newBuilder();
6243       try {
6244         boolean done = false;
6245         while (!done) {
6246           int tag = input.readTag();
6247           switch (tag) {
6248             case 0:
6249               done = true;
6250               break;
6251             default: {
6252               if (!parseUnknownField(input, unknownFields,
6253                                      extensionRegistry, tag)) {
6254                 done = true;
6255               }
6256               break;
6257             }
6258             case 8: {
6259               bitField0_ |= 0x00000001;
6260               bus_ = input.readInt32();
6261               break;
6262             }
6263             case 16: {
6264               bitField0_ |= 0x00000002;
6265               messageId_ = input.readUInt32();
6266               break;
6267             }
6268             case 24: {
6269               bitField0_ |= 0x00000004;
6270               mode_ = input.readUInt32();
6271               break;
6272             }
6273             case 32: {
6274               bitField0_ |= 0x00000008;
6275               pid_ = input.readUInt32();
6276               break;
6277             }
6278             case 42: {
6279               bitField0_ |= 0x00000010;
6280               payload_ = input.readBytes();
6281               break;
6282             }
6283             case 48: {
6284               bitField0_ |= 0x00000020;
6285               multipleResponses_ = input.readBool();
6286               break;
6287             }
6288             case 57: {
6289               bitField0_ |= 0x00000040;
6290               frequency_ = input.readDouble();
6291               break;
6292             }
6293             case 66: {
6294               bitField0_ |= 0x00000080;
6295               name_ = input.readBytes();
6296               break;
6297             }
6298             case 72: {
6299               int rawValue = input.readEnum();
6300               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
6301               if (value == null) {
6302                 unknownFields.mergeVarintField(9, rawValue);
6303               } else {
6304                 bitField0_ |= 0x00000100;
6305                 decodedType_ = value;
6306               }
6307               break;
6308             }
6309           }
6310         }
6311       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6312         throw e.setUnfinishedMessage(this);
6313       } catch (java.io.IOException e) {
6314         throw new com.google.protobuf.InvalidProtocolBufferException(
6315             e.getMessage()).setUnfinishedMessage(this);
6316       } finally {
6317         this.unknownFields = unknownFields.build();
6318         makeExtensionsImmutable();
6319       }
6320     }
6321     public static final com.google.protobuf.Descriptors.Descriptor
6322         getDescriptor() {
6323       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
6324     }
6325
6326     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6327         internalGetFieldAccessorTable() {
6328       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
6329           .ensureFieldAccessorsInitialized(
6330               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
6331     }
6332
6333     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
6334         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
6335       public DiagnosticRequest parsePartialFrom(
6336           com.google.protobuf.CodedInputStream input,
6337           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6338           throws com.google.protobuf.InvalidProtocolBufferException {
6339         return new DiagnosticRequest(input, extensionRegistry);
6340       }
6341     };
6342
6343     @java.lang.Override
6344     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
6345       return PARSER;
6346     }
6347
6348     /**
6349      * Protobuf enum {@code openxc.DiagnosticRequest.DecodedType}
6350      */
6351     public enum DecodedType
6352         implements com.google.protobuf.ProtocolMessageEnum {
6353       /**
6354        * <code>NONE = 1;</code>
6355        */
6356       NONE(0, 1),
6357       /**
6358        * <code>OBD2 = 2;</code>
6359        */
6360       OBD2(1, 2),
6361       ;
6362
6363       /**
6364        * <code>NONE = 1;</code>
6365        */
6366       public static final int NONE_VALUE = 1;
6367       /**
6368        * <code>OBD2 = 2;</code>
6369        */
6370       public static final int OBD2_VALUE = 2;
6371
6372
6373       public final int getNumber() { return value; }
6374
6375       public static DecodedType valueOf(int value) {
6376         switch (value) {
6377           case 1: return NONE;
6378           case 2: return OBD2;
6379           default: return null;
6380         }
6381       }
6382
6383       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
6384           internalGetValueMap() {
6385         return internalValueMap;
6386       }
6387       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
6388           internalValueMap =
6389             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
6390               public DecodedType findValueByNumber(int number) {
6391                 return DecodedType.valueOf(number);
6392               }
6393             };
6394
6395       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6396           getValueDescriptor() {
6397         return getDescriptor().getValues().get(index);
6398       }
6399       public final com.google.protobuf.Descriptors.EnumDescriptor
6400           getDescriptorForType() {
6401         return getDescriptor();
6402       }
6403       public static final com.google.protobuf.Descriptors.EnumDescriptor
6404           getDescriptor() {
6405         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
6406       }
6407
6408       private static final DecodedType[] VALUES = values();
6409
6410       public static DecodedType valueOf(
6411           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6412         if (desc.getType() != getDescriptor()) {
6413           throw new java.lang.IllegalArgumentException(
6414             "EnumValueDescriptor is not for this type.");
6415         }
6416         return VALUES[desc.getIndex()];
6417       }
6418
6419       private final int index;
6420       private final int value;
6421
6422       private DecodedType(int index, int value) {
6423         this.index = index;
6424         this.value = value;
6425       }
6426
6427       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
6428     }
6429
6430     private int bitField0_;
6431     // optional int32 bus = 1;
6432     public static final int BUS_FIELD_NUMBER = 1;
6433     private int bus_;
6434     /**
6435      * <code>optional int32 bus = 1;</code>
6436      */
6437     public boolean hasBus() {
6438       return ((bitField0_ & 0x00000001) == 0x00000001);
6439     }
6440     /**
6441      * <code>optional int32 bus = 1;</code>
6442      */
6443     public int getBus() {
6444       return bus_;
6445     }
6446
6447     // optional uint32 message_id = 2;
6448     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
6449     private int messageId_;
6450     /**
6451      * <code>optional uint32 message_id = 2;</code>
6452      */
6453     public boolean hasMessageId() {
6454       return ((bitField0_ & 0x00000002) == 0x00000002);
6455     }
6456     /**
6457      * <code>optional uint32 message_id = 2;</code>
6458      */
6459     public int getMessageId() {
6460       return messageId_;
6461     }
6462
6463     // optional uint32 mode = 3;
6464     public static final int MODE_FIELD_NUMBER = 3;
6465     private int mode_;
6466     /**
6467      * <code>optional uint32 mode = 3;</code>
6468      */
6469     public boolean hasMode() {
6470       return ((bitField0_ & 0x00000004) == 0x00000004);
6471     }
6472     /**
6473      * <code>optional uint32 mode = 3;</code>
6474      */
6475     public int getMode() {
6476       return mode_;
6477     }
6478
6479     // optional uint32 pid = 4;
6480     public static final int PID_FIELD_NUMBER = 4;
6481     private int pid_;
6482     /**
6483      * <code>optional uint32 pid = 4;</code>
6484      */
6485     public boolean hasPid() {
6486       return ((bitField0_ & 0x00000008) == 0x00000008);
6487     }
6488     /**
6489      * <code>optional uint32 pid = 4;</code>
6490      */
6491     public int getPid() {
6492       return pid_;
6493     }
6494
6495     // optional bytes payload = 5;
6496     public static final int PAYLOAD_FIELD_NUMBER = 5;
6497     private com.google.protobuf.ByteString payload_;
6498     /**
6499      * <code>optional bytes payload = 5;</code>
6500      *
6501      * <pre>
6502      * TODO we are capping this at 8 bytes for now - need to change when we
6503      * support multi-frame responses
6504      * </pre>
6505      */
6506     public boolean hasPayload() {
6507       return ((bitField0_ & 0x00000010) == 0x00000010);
6508     }
6509     /**
6510      * <code>optional bytes payload = 5;</code>
6511      *
6512      * <pre>
6513      * TODO we are capping this at 8 bytes for now - need to change when we
6514      * support multi-frame responses
6515      * </pre>
6516      */
6517     public com.google.protobuf.ByteString getPayload() {
6518       return payload_;
6519     }
6520
6521     // optional bool multiple_responses = 6;
6522     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
6523     private boolean multipleResponses_;
6524     /**
6525      * <code>optional bool multiple_responses = 6;</code>
6526      */
6527     public boolean hasMultipleResponses() {
6528       return ((bitField0_ & 0x00000020) == 0x00000020);
6529     }
6530     /**
6531      * <code>optional bool multiple_responses = 6;</code>
6532      */
6533     public boolean getMultipleResponses() {
6534       return multipleResponses_;
6535     }
6536
6537     // optional double frequency = 7;
6538     public static final int FREQUENCY_FIELD_NUMBER = 7;
6539     private double frequency_;
6540     /**
6541      * <code>optional double frequency = 7;</code>
6542      */
6543     public boolean hasFrequency() {
6544       return ((bitField0_ & 0x00000040) == 0x00000040);
6545     }
6546     /**
6547      * <code>optional double frequency = 7;</code>
6548      */
6549     public double getFrequency() {
6550       return frequency_;
6551     }
6552
6553     // optional string name = 8;
6554     public static final int NAME_FIELD_NUMBER = 8;
6555     private java.lang.Object name_;
6556     /**
6557      * <code>optional string name = 8;</code>
6558      */
6559     public boolean hasName() {
6560       return ((bitField0_ & 0x00000080) == 0x00000080);
6561     }
6562     /**
6563      * <code>optional string name = 8;</code>
6564      */
6565     public java.lang.String getName() {
6566       java.lang.Object ref = name_;
6567       if (ref instanceof java.lang.String) {
6568         return (java.lang.String) ref;
6569       } else {
6570         com.google.protobuf.ByteString bs =
6571             (com.google.protobuf.ByteString) ref;
6572         java.lang.String s = bs.toStringUtf8();
6573         if (bs.isValidUtf8()) {
6574           name_ = s;
6575         }
6576         return s;
6577       }
6578     }
6579     /**
6580      * <code>optional string name = 8;</code>
6581      */
6582     public com.google.protobuf.ByteString
6583         getNameBytes() {
6584       java.lang.Object ref = name_;
6585       if (ref instanceof java.lang.String) {
6586         com.google.protobuf.ByteString b =
6587             com.google.protobuf.ByteString.copyFromUtf8(
6588                 (java.lang.String) ref);
6589         name_ = b;
6590         return b;
6591       } else {
6592         return (com.google.protobuf.ByteString) ref;
6593       }
6594     }
6595
6596     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
6597     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
6598     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
6599     /**
6600      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
6601      */
6602     public boolean hasDecodedType() {
6603       return ((bitField0_ & 0x00000100) == 0x00000100);
6604     }
6605     /**
6606      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
6607      */
6608     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
6609       return decodedType_;
6610     }
6611
6612     private void initFields() {
6613       bus_ = 0;
6614       messageId_ = 0;
6615       mode_ = 0;
6616       pid_ = 0;
6617       payload_ = com.google.protobuf.ByteString.EMPTY;
6618       multipleResponses_ = false;
6619       frequency_ = 0D;
6620       name_ = "";
6621       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
6622     }
6623     private byte memoizedIsInitialized = -1;
6624     public final boolean isInitialized() {
6625       byte isInitialized = memoizedIsInitialized;
6626       if (isInitialized != -1) return isInitialized == 1;
6627
6628       memoizedIsInitialized = 1;
6629       return true;
6630     }
6631
6632     public void writeTo(com.google.protobuf.CodedOutputStream output)
6633                         throws java.io.IOException {
6634       getSerializedSize();
6635       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6636         output.writeInt32(1, bus_);
6637       }
6638       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6639         output.writeUInt32(2, messageId_);
6640       }
6641       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6642         output.writeUInt32(3, mode_);
6643       }
6644       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6645         output.writeUInt32(4, pid_);
6646       }
6647       if (((bitField0_ & 0x00000010) == 0x00000010)) {
6648         output.writeBytes(5, payload_);
6649       }
6650       if (((bitField0_ & 0x00000020) == 0x00000020)) {
6651         output.writeBool(6, multipleResponses_);
6652       }
6653       if (((bitField0_ & 0x00000040) == 0x00000040)) {
6654         output.writeDouble(7, frequency_);
6655       }
6656       if (((bitField0_ & 0x00000080) == 0x00000080)) {
6657         output.writeBytes(8, getNameBytes());
6658       }
6659       if (((bitField0_ & 0x00000100) == 0x00000100)) {
6660         output.writeEnum(9, decodedType_.getNumber());
6661       }
6662       getUnknownFields().writeTo(output);
6663     }
6664
6665     private int memoizedSerializedSize = -1;
6666     public int getSerializedSize() {
6667       int size = memoizedSerializedSize;
6668       if (size != -1) return size;
6669
6670       size = 0;
6671       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6672         size += com.google.protobuf.CodedOutputStream
6673           .computeInt32Size(1, bus_);
6674       }
6675       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6676         size += com.google.protobuf.CodedOutputStream
6677           .computeUInt32Size(2, messageId_);
6678       }
6679       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6680         size += com.google.protobuf.CodedOutputStream
6681           .computeUInt32Size(3, mode_);
6682       }
6683       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6684         size += com.google.protobuf.CodedOutputStream
6685           .computeUInt32Size(4, pid_);
6686       }
6687       if (((bitField0_ & 0x00000010) == 0x00000010)) {
6688         size += com.google.protobuf.CodedOutputStream
6689           .computeBytesSize(5, payload_);
6690       }
6691       if (((bitField0_ & 0x00000020) == 0x00000020)) {
6692         size += com.google.protobuf.CodedOutputStream
6693           .computeBoolSize(6, multipleResponses_);
6694       }
6695       if (((bitField0_ & 0x00000040) == 0x00000040)) {
6696         size += com.google.protobuf.CodedOutputStream
6697           .computeDoubleSize(7, frequency_);
6698       }
6699       if (((bitField0_ & 0x00000080) == 0x00000080)) {
6700         size += com.google.protobuf.CodedOutputStream
6701           .computeBytesSize(8, getNameBytes());
6702       }
6703       if (((bitField0_ & 0x00000100) == 0x00000100)) {
6704         size += com.google.protobuf.CodedOutputStream
6705           .computeEnumSize(9, decodedType_.getNumber());
6706       }
6707       size += getUnknownFields().getSerializedSize();
6708       memoizedSerializedSize = size;
6709       return size;
6710     }
6711
6712     private static final long serialVersionUID = 0L;
6713     @java.lang.Override
6714     protected java.lang.Object writeReplace()
6715         throws java.io.ObjectStreamException {
6716       return super.writeReplace();
6717     }
6718
6719     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
6720         com.google.protobuf.ByteString data)
6721         throws com.google.protobuf.InvalidProtocolBufferException {
6722       return PARSER.parseFrom(data);
6723     }
6724     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
6725         com.google.protobuf.ByteString data,
6726         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6727         throws com.google.protobuf.InvalidProtocolBufferException {
6728       return PARSER.parseFrom(data, extensionRegistry);
6729     }
6730     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
6731         throws com.google.protobuf.InvalidProtocolBufferException {
6732       return PARSER.parseFrom(data);
6733     }
6734     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
6735         byte[] data,
6736         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6737         throws com.google.protobuf.InvalidProtocolBufferException {
6738       return PARSER.parseFrom(data, extensionRegistry);
6739     }
6740     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
6741         throws java.io.IOException {
6742       return PARSER.parseFrom(input);
6743     }
6744     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
6745         java.io.InputStream input,
6746         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6747         throws java.io.IOException {
6748       return PARSER.parseFrom(input, extensionRegistry);
6749     }
6750     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
6751         throws java.io.IOException {
6752       return PARSER.parseDelimitedFrom(input);
6753     }
6754     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
6755         java.io.InputStream input,
6756         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6757         throws java.io.IOException {
6758       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6759     }
6760     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
6761         com.google.protobuf.CodedInputStream input)
6762         throws java.io.IOException {
6763       return PARSER.parseFrom(input);
6764     }
6765     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
6766         com.google.protobuf.CodedInputStream input,
6767         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6768         throws java.io.IOException {
6769       return PARSER.parseFrom(input, extensionRegistry);
6770     }
6771
6772     public static Builder newBuilder() { return Builder.create(); }
6773     public Builder newBuilderForType() { return newBuilder(); }
6774     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
6775       return newBuilder().mergeFrom(prototype);
6776     }
6777     public Builder toBuilder() { return newBuilder(this); }
6778
6779     @java.lang.Override
6780     protected Builder newBuilderForType(
6781         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6782       Builder builder = new Builder(parent);
6783       return builder;
6784     }
6785     /**
6786      * Protobuf type {@code openxc.DiagnosticRequest}
6787      */
6788     public static final class Builder extends
6789         com.google.protobuf.GeneratedMessage.Builder<Builder>
6790        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
6791       public static final com.google.protobuf.Descriptors.Descriptor
6792           getDescriptor() {
6793         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
6794       }
6795
6796       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6797           internalGetFieldAccessorTable() {
6798         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
6799             .ensureFieldAccessorsInitialized(
6800                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
6801       }
6802
6803       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
6804       private Builder() {
6805         maybeForceBuilderInitialization();
6806       }
6807
6808       private Builder(
6809           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6810         super(parent);
6811         maybeForceBuilderInitialization();
6812       }
6813       private void maybeForceBuilderInitialization() {
6814         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6815         }
6816       }
6817       private static Builder create() {
6818         return new Builder();
6819       }
6820
6821       public Builder clear() {
6822         super.clear();
6823         bus_ = 0;
6824         bitField0_ = (bitField0_ & ~0x00000001);
6825         messageId_ = 0;
6826         bitField0_ = (bitField0_ & ~0x00000002);
6827         mode_ = 0;
6828         bitField0_ = (bitField0_ & ~0x00000004);
6829         pid_ = 0;
6830         bitField0_ = (bitField0_ & ~0x00000008);
6831         payload_ = com.google.protobuf.ByteString.EMPTY;
6832         bitField0_ = (bitField0_ & ~0x00000010);
6833         multipleResponses_ = false;
6834         bitField0_ = (bitField0_ & ~0x00000020);
6835         frequency_ = 0D;
6836         bitField0_ = (bitField0_ & ~0x00000040);
6837         name_ = "";
6838         bitField0_ = (bitField0_ & ~0x00000080);
6839         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
6840         bitField0_ = (bitField0_ & ~0x00000100);
6841         return this;
6842       }
6843
6844       public Builder clone() {
6845         return create().mergeFrom(buildPartial());
6846       }
6847
6848       public com.google.protobuf.Descriptors.Descriptor
6849           getDescriptorForType() {
6850         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
6851       }
6852
6853       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
6854         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
6855       }
6856
6857       public com.openxc.BinaryMessages.DiagnosticRequest build() {
6858         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
6859         if (!result.isInitialized()) {
6860           throw newUninitializedMessageException(result);
6861         }
6862         return result;
6863       }
6864
6865       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
6866         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
6867         int from_bitField0_ = bitField0_;
6868         int to_bitField0_ = 0;
6869         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6870           to_bitField0_ |= 0x00000001;
6871         }
6872         result.bus_ = bus_;
6873         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6874           to_bitField0_ |= 0x00000002;
6875         }
6876         result.messageId_ = messageId_;
6877         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6878           to_bitField0_ |= 0x00000004;
6879         }
6880         result.mode_ = mode_;
6881         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
6882           to_bitField0_ |= 0x00000008;
6883         }
6884         result.pid_ = pid_;
6885         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
6886           to_bitField0_ |= 0x00000010;
6887         }
6888         result.payload_ = payload_;
6889         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
6890           to_bitField0_ |= 0x00000020;
6891         }
6892         result.multipleResponses_ = multipleResponses_;
6893         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
6894           to_bitField0_ |= 0x00000040;
6895         }
6896         result.frequency_ = frequency_;
6897         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
6898           to_bitField0_ |= 0x00000080;
6899         }
6900         result.name_ = name_;
6901         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
6902           to_bitField0_ |= 0x00000100;
6903         }
6904         result.decodedType_ = decodedType_;
6905         result.bitField0_ = to_bitField0_;
6906         onBuilt();
6907         return result;
6908       }
6909
6910       public Builder mergeFrom(com.google.protobuf.Message other) {
6911         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
6912           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
6913         } else {
6914           super.mergeFrom(other);
6915           return this;
6916         }
6917       }
6918
6919       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
6920         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
6921         if (other.hasBus()) {
6922           setBus(other.getBus());
6923         }
6924         if (other.hasMessageId()) {
6925           setMessageId(other.getMessageId());
6926         }
6927         if (other.hasMode()) {
6928           setMode(other.getMode());
6929         }
6930         if (other.hasPid()) {
6931           setPid(other.getPid());
6932         }
6933         if (other.hasPayload()) {
6934           setPayload(other.getPayload());
6935         }
6936         if (other.hasMultipleResponses()) {
6937           setMultipleResponses(other.getMultipleResponses());
6938         }
6939         if (other.hasFrequency()) {
6940           setFrequency(other.getFrequency());
6941         }
6942         if (other.hasName()) {
6943           bitField0_ |= 0x00000080;
6944           name_ = other.name_;
6945           onChanged();
6946         }
6947         if (other.hasDecodedType()) {
6948           setDecodedType(other.getDecodedType());
6949         }
6950         this.mergeUnknownFields(other.getUnknownFields());
6951         return this;
6952       }
6953
6954       public final boolean isInitialized() {
6955         return true;
6956       }
6957
6958       public Builder mergeFrom(
6959           com.google.protobuf.CodedInputStream input,
6960           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6961           throws java.io.IOException {
6962         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
6963         try {
6964           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6965         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6966           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
6967           throw e;
6968         } finally {
6969           if (parsedMessage != null) {
6970             mergeFrom(parsedMessage);
6971           }
6972         }
6973         return this;
6974       }
6975       private int bitField0_;
6976
6977       // optional int32 bus = 1;
6978       private int bus_ ;
6979       /**
6980        * <code>optional int32 bus = 1;</code>
6981        */
6982       public boolean hasBus() {
6983         return ((bitField0_ & 0x00000001) == 0x00000001);
6984       }
6985       /**
6986        * <code>optional int32 bus = 1;</code>
6987        */
6988       public int getBus() {
6989         return bus_;
6990       }
6991       /**
6992        * <code>optional int32 bus = 1;</code>
6993        */
6994       public Builder setBus(int value) {
6995         bitField0_ |= 0x00000001;
6996         bus_ = value;
6997         onChanged();
6998         return this;
6999       }
7000       /**
7001        * <code>optional int32 bus = 1;</code>
7002        */
7003       public Builder clearBus() {
7004         bitField0_ = (bitField0_ & ~0x00000001);
7005         bus_ = 0;
7006         onChanged();
7007         return this;
7008       }
7009
7010       // optional uint32 message_id = 2;
7011       private int messageId_ ;
7012       /**
7013        * <code>optional uint32 message_id = 2;</code>
7014        */
7015       public boolean hasMessageId() {
7016         return ((bitField0_ & 0x00000002) == 0x00000002);
7017       }
7018       /**
7019        * <code>optional uint32 message_id = 2;</code>
7020        */
7021       public int getMessageId() {
7022         return messageId_;
7023       }
7024       /**
7025        * <code>optional uint32 message_id = 2;</code>
7026        */
7027       public Builder setMessageId(int value) {
7028         bitField0_ |= 0x00000002;
7029         messageId_ = value;
7030         onChanged();
7031         return this;
7032       }
7033       /**
7034        * <code>optional uint32 message_id = 2;</code>
7035        */
7036       public Builder clearMessageId() {
7037         bitField0_ = (bitField0_ & ~0x00000002);
7038         messageId_ = 0;
7039         onChanged();
7040         return this;
7041       }
7042
7043       // optional uint32 mode = 3;
7044       private int mode_ ;
7045       /**
7046        * <code>optional uint32 mode = 3;</code>
7047        */
7048       public boolean hasMode() {
7049         return ((bitField0_ & 0x00000004) == 0x00000004);
7050       }
7051       /**
7052        * <code>optional uint32 mode = 3;</code>
7053        */
7054       public int getMode() {
7055         return mode_;
7056       }
7057       /**
7058        * <code>optional uint32 mode = 3;</code>
7059        */
7060       public Builder setMode(int value) {
7061         bitField0_ |= 0x00000004;
7062         mode_ = value;
7063         onChanged();
7064         return this;
7065       }
7066       /**
7067        * <code>optional uint32 mode = 3;</code>
7068        */
7069       public Builder clearMode() {
7070         bitField0_ = (bitField0_ & ~0x00000004);
7071         mode_ = 0;
7072         onChanged();
7073         return this;
7074       }
7075
7076       // optional uint32 pid = 4;
7077       private int pid_ ;
7078       /**
7079        * <code>optional uint32 pid = 4;</code>
7080        */
7081       public boolean hasPid() {
7082         return ((bitField0_ & 0x00000008) == 0x00000008);
7083       }
7084       /**
7085        * <code>optional uint32 pid = 4;</code>
7086        */
7087       public int getPid() {
7088         return pid_;
7089       }
7090       /**
7091        * <code>optional uint32 pid = 4;</code>
7092        */
7093       public Builder setPid(int value) {
7094         bitField0_ |= 0x00000008;
7095         pid_ = value;
7096         onChanged();
7097         return this;
7098       }
7099       /**
7100        * <code>optional uint32 pid = 4;</code>
7101        */
7102       public Builder clearPid() {
7103         bitField0_ = (bitField0_ & ~0x00000008);
7104         pid_ = 0;
7105         onChanged();
7106         return this;
7107       }
7108
7109       // optional bytes payload = 5;
7110       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
7111       /**
7112        * <code>optional bytes payload = 5;</code>
7113        *
7114        * <pre>
7115        * TODO we are capping this at 8 bytes for now - need to change when we
7116        * support multi-frame responses
7117        * </pre>
7118        */
7119       public boolean hasPayload() {
7120         return ((bitField0_ & 0x00000010) == 0x00000010);
7121       }
7122       /**
7123        * <code>optional bytes payload = 5;</code>
7124        *
7125        * <pre>
7126        * TODO we are capping this at 8 bytes for now - need to change when we
7127        * support multi-frame responses
7128        * </pre>
7129        */
7130       public com.google.protobuf.ByteString getPayload() {
7131         return payload_;
7132       }
7133       /**
7134        * <code>optional bytes payload = 5;</code>
7135        *
7136        * <pre>
7137        * TODO we are capping this at 8 bytes for now - need to change when we
7138        * support multi-frame responses
7139        * </pre>
7140        */
7141       public Builder setPayload(com.google.protobuf.ByteString value) {
7142         if (value == null) {
7143     throw new NullPointerException();
7144   }
7145   bitField0_ |= 0x00000010;
7146         payload_ = value;
7147         onChanged();
7148         return this;
7149       }
7150       /**
7151        * <code>optional bytes payload = 5;</code>
7152        *
7153        * <pre>
7154        * TODO we are capping this at 8 bytes for now - need to change when we
7155        * support multi-frame responses
7156        * </pre>
7157        */
7158       public Builder clearPayload() {
7159         bitField0_ = (bitField0_ & ~0x00000010);
7160         payload_ = getDefaultInstance().getPayload();
7161         onChanged();
7162         return this;
7163       }
7164
7165       // optional bool multiple_responses = 6;
7166       private boolean multipleResponses_ ;
7167       /**
7168        * <code>optional bool multiple_responses = 6;</code>
7169        */
7170       public boolean hasMultipleResponses() {
7171         return ((bitField0_ & 0x00000020) == 0x00000020);
7172       }
7173       /**
7174        * <code>optional bool multiple_responses = 6;</code>
7175        */
7176       public boolean getMultipleResponses() {
7177         return multipleResponses_;
7178       }
7179       /**
7180        * <code>optional bool multiple_responses = 6;</code>
7181        */
7182       public Builder setMultipleResponses(boolean value) {
7183         bitField0_ |= 0x00000020;
7184         multipleResponses_ = value;
7185         onChanged();
7186         return this;
7187       }
7188       /**
7189        * <code>optional bool multiple_responses = 6;</code>
7190        */
7191       public Builder clearMultipleResponses() {
7192         bitField0_ = (bitField0_ & ~0x00000020);
7193         multipleResponses_ = false;
7194         onChanged();
7195         return this;
7196       }
7197
7198       // optional double frequency = 7;
7199       private double frequency_ ;
7200       /**
7201        * <code>optional double frequency = 7;</code>
7202        */
7203       public boolean hasFrequency() {
7204         return ((bitField0_ & 0x00000040) == 0x00000040);
7205       }
7206       /**
7207        * <code>optional double frequency = 7;</code>
7208        */
7209       public double getFrequency() {
7210         return frequency_;
7211       }
7212       /**
7213        * <code>optional double frequency = 7;</code>
7214        */
7215       public Builder setFrequency(double value) {
7216         bitField0_ |= 0x00000040;
7217         frequency_ = value;
7218         onChanged();
7219         return this;
7220       }
7221       /**
7222        * <code>optional double frequency = 7;</code>
7223        */
7224       public Builder clearFrequency() {
7225         bitField0_ = (bitField0_ & ~0x00000040);
7226         frequency_ = 0D;
7227         onChanged();
7228         return this;
7229       }
7230
7231       // optional string name = 8;
7232       private java.lang.Object name_ = "";
7233       /**
7234        * <code>optional string name = 8;</code>
7235        */
7236       public boolean hasName() {
7237         return ((bitField0_ & 0x00000080) == 0x00000080);
7238       }
7239       /**
7240        * <code>optional string name = 8;</code>
7241        */
7242       public java.lang.String getName() {
7243         java.lang.Object ref = name_;
7244         if (!(ref instanceof java.lang.String)) {
7245           java.lang.String s = ((com.google.protobuf.ByteString) ref)
7246               .toStringUtf8();
7247           name_ = s;
7248           return s;
7249         } else {
7250           return (java.lang.String) ref;
7251         }
7252       }
7253       /**
7254        * <code>optional string name = 8;</code>
7255        */
7256       public com.google.protobuf.ByteString
7257           getNameBytes() {
7258         java.lang.Object ref = name_;
7259         if (ref instanceof String) {
7260           com.google.protobuf.ByteString b =
7261               com.google.protobuf.ByteString.copyFromUtf8(
7262                   (java.lang.String) ref);
7263           name_ = b;
7264           return b;
7265         } else {
7266           return (com.google.protobuf.ByteString) ref;
7267         }
7268       }
7269       /**
7270        * <code>optional string name = 8;</code>
7271        */
7272       public Builder setName(
7273           java.lang.String value) {
7274         if (value == null) {
7275     throw new NullPointerException();
7276   }
7277   bitField0_ |= 0x00000080;
7278         name_ = value;
7279         onChanged();
7280         return this;
7281       }
7282       /**
7283        * <code>optional string name = 8;</code>
7284        */
7285       public Builder clearName() {
7286         bitField0_ = (bitField0_ & ~0x00000080);
7287         name_ = getDefaultInstance().getName();
7288         onChanged();
7289         return this;
7290       }
7291       /**
7292        * <code>optional string name = 8;</code>
7293        */
7294       public Builder setNameBytes(
7295           com.google.protobuf.ByteString value) {
7296         if (value == null) {
7297     throw new NullPointerException();
7298   }
7299   bitField0_ |= 0x00000080;
7300         name_ = value;
7301         onChanged();
7302         return this;
7303       }
7304
7305       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
7306       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
7307       /**
7308        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
7309        */
7310       public boolean hasDecodedType() {
7311         return ((bitField0_ & 0x00000100) == 0x00000100);
7312       }
7313       /**
7314        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
7315        */
7316       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
7317         return decodedType_;
7318       }
7319       /**
7320        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
7321        */
7322       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
7323         if (value == null) {
7324           throw new NullPointerException();
7325         }
7326         bitField0_ |= 0x00000100;
7327         decodedType_ = value;
7328         onChanged();
7329         return this;
7330       }
7331       /**
7332        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
7333        */
7334       public Builder clearDecodedType() {
7335         bitField0_ = (bitField0_ & ~0x00000100);
7336         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
7337         onChanged();
7338         return this;
7339       }
7340
7341       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
7342     }
7343
7344     static {
7345       defaultInstance = new DiagnosticRequest(true);
7346       defaultInstance.initFields();
7347     }
7348
7349     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
7350   }
7351
7352   public interface DiagnosticResponseOrBuilder
7353       extends com.google.protobuf.MessageOrBuilder {
7354
7355     // optional int32 bus = 1;
7356     /**
7357      * <code>optional int32 bus = 1;</code>
7358      */
7359     boolean hasBus();
7360     /**
7361      * <code>optional int32 bus = 1;</code>
7362      */
7363     int getBus();
7364
7365     // optional uint32 message_id = 2;
7366     /**
7367      * <code>optional uint32 message_id = 2;</code>
7368      */
7369     boolean hasMessageId();
7370     /**
7371      * <code>optional uint32 message_id = 2;</code>
7372      */
7373     int getMessageId();
7374
7375     // optional uint32 mode = 3;
7376     /**
7377      * <code>optional uint32 mode = 3;</code>
7378      */
7379     boolean hasMode();
7380     /**
7381      * <code>optional uint32 mode = 3;</code>
7382      */
7383     int getMode();
7384
7385     // optional uint32 pid = 4;
7386     /**
7387      * <code>optional uint32 pid = 4;</code>
7388      */
7389     boolean hasPid();
7390     /**
7391      * <code>optional uint32 pid = 4;</code>
7392      */
7393     int getPid();
7394
7395     // optional bool success = 5;
7396     /**
7397      * <code>optional bool success = 5;</code>
7398      */
7399     boolean hasSuccess();
7400     /**
7401      * <code>optional bool success = 5;</code>
7402      */
7403     boolean getSuccess();
7404
7405     // optional uint32 negative_response_code = 6;
7406     /**
7407      * <code>optional uint32 negative_response_code = 6;</code>
7408      */
7409     boolean hasNegativeResponseCode();
7410     /**
7411      * <code>optional uint32 negative_response_code = 6;</code>
7412      */
7413     int getNegativeResponseCode();
7414
7415     // optional bytes payload = 7;
7416     /**
7417      * <code>optional bytes payload = 7;</code>
7418      *
7419      * <pre>
7420      * TODO we are capping this at 8 bytes for now - need to change when we
7421      * support multi-frame responses
7422      * </pre>
7423      */
7424     boolean hasPayload();
7425     /**
7426      * <code>optional bytes payload = 7;</code>
7427      *
7428      * <pre>
7429      * TODO we are capping this at 8 bytes for now - need to change when we
7430      * support multi-frame responses
7431      * </pre>
7432      */
7433     com.google.protobuf.ByteString getPayload();
7434
7435     // optional double value = 8;
7436     /**
7437      * <code>optional double value = 8;</code>
7438      */
7439     boolean hasValue();
7440     /**
7441      * <code>optional double value = 8;</code>
7442      */
7443     double getValue();
7444   }
7445   /**
7446    * Protobuf type {@code openxc.DiagnosticResponse}
7447    */
7448   public static final class DiagnosticResponse extends
7449       com.google.protobuf.GeneratedMessage
7450       implements DiagnosticResponseOrBuilder {
7451     // Use DiagnosticResponse.newBuilder() to construct.
7452     private DiagnosticResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
7453       super(builder);
7454       this.unknownFields = builder.getUnknownFields();
7455     }
7456     private DiagnosticResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
7457
7458     private static final DiagnosticResponse defaultInstance;
7459     public static DiagnosticResponse getDefaultInstance() {
7460       return defaultInstance;
7461     }
7462
7463     public DiagnosticResponse getDefaultInstanceForType() {
7464       return defaultInstance;
7465     }
7466
7467     private final com.google.protobuf.UnknownFieldSet unknownFields;
7468     @java.lang.Override
7469     public final com.google.protobuf.UnknownFieldSet
7470         getUnknownFields() {
7471       return this.unknownFields;
7472     }
7473     private DiagnosticResponse(
7474         com.google.protobuf.CodedInputStream input,
7475         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7476         throws com.google.protobuf.InvalidProtocolBufferException {
7477       initFields();
7478       int mutable_bitField0_ = 0;
7479       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
7480           com.google.protobuf.UnknownFieldSet.newBuilder();
7481       try {
7482         boolean done = false;
7483         while (!done) {
7484           int tag = input.readTag();
7485           switch (tag) {
7486             case 0:
7487               done = true;
7488               break;
7489             default: {
7490               if (!parseUnknownField(input, unknownFields,
7491                                      extensionRegistry, tag)) {
7492                 done = true;
7493               }
7494               break;
7495             }
7496             case 8: {
7497               bitField0_ |= 0x00000001;
7498               bus_ = input.readInt32();
7499               break;
7500             }
7501             case 16: {
7502               bitField0_ |= 0x00000002;
7503               messageId_ = input.readUInt32();
7504               break;
7505             }
7506             case 24: {
7507               bitField0_ |= 0x00000004;
7508               mode_ = input.readUInt32();
7509               break;
7510             }
7511             case 32: {
7512               bitField0_ |= 0x00000008;
7513               pid_ = input.readUInt32();
7514               break;
7515             }
7516             case 40: {
7517               bitField0_ |= 0x00000010;
7518               success_ = input.readBool();
7519               break;
7520             }
7521             case 48: {
7522               bitField0_ |= 0x00000020;
7523               negativeResponseCode_ = input.readUInt32();
7524               break;
7525             }
7526             case 58: {
7527               bitField0_ |= 0x00000040;
7528               payload_ = input.readBytes();
7529               break;
7530             }
7531             case 65: {
7532               bitField0_ |= 0x00000080;
7533               value_ = input.readDouble();
7534               break;
7535             }
7536           }
7537         }
7538       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7539         throw e.setUnfinishedMessage(this);
7540       } catch (java.io.IOException e) {
7541         throw new com.google.protobuf.InvalidProtocolBufferException(
7542             e.getMessage()).setUnfinishedMessage(this);
7543       } finally {
7544         this.unknownFields = unknownFields.build();
7545         makeExtensionsImmutable();
7546       }
7547     }
7548     public static final com.google.protobuf.Descriptors.Descriptor
7549         getDescriptor() {
7550       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
7551     }
7552
7553     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7554         internalGetFieldAccessorTable() {
7555       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
7556           .ensureFieldAccessorsInitialized(
7557               com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
7558     }
7559
7560     public static com.google.protobuf.Parser<DiagnosticResponse> PARSER =
7561         new com.google.protobuf.AbstractParser<DiagnosticResponse>() {
7562       public DiagnosticResponse parsePartialFrom(
7563           com.google.protobuf.CodedInputStream input,
7564           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7565           throws com.google.protobuf.InvalidProtocolBufferException {
7566         return new DiagnosticResponse(input, extensionRegistry);
7567       }
7568     };
7569
7570     @java.lang.Override
7571     public com.google.protobuf.Parser<DiagnosticResponse> getParserForType() {
7572       return PARSER;
7573     }
7574
7575     private int bitField0_;
7576     // optional int32 bus = 1;
7577     public static final int BUS_FIELD_NUMBER = 1;
7578     private int bus_;
7579     /**
7580      * <code>optional int32 bus = 1;</code>
7581      */
7582     public boolean hasBus() {
7583       return ((bitField0_ & 0x00000001) == 0x00000001);
7584     }
7585     /**
7586      * <code>optional int32 bus = 1;</code>
7587      */
7588     public int getBus() {
7589       return bus_;
7590     }
7591
7592     // optional uint32 message_id = 2;
7593     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
7594     private int messageId_;
7595     /**
7596      * <code>optional uint32 message_id = 2;</code>
7597      */
7598     public boolean hasMessageId() {
7599       return ((bitField0_ & 0x00000002) == 0x00000002);
7600     }
7601     /**
7602      * <code>optional uint32 message_id = 2;</code>
7603      */
7604     public int getMessageId() {
7605       return messageId_;
7606     }
7607
7608     // optional uint32 mode = 3;
7609     public static final int MODE_FIELD_NUMBER = 3;
7610     private int mode_;
7611     /**
7612      * <code>optional uint32 mode = 3;</code>
7613      */
7614     public boolean hasMode() {
7615       return ((bitField0_ & 0x00000004) == 0x00000004);
7616     }
7617     /**
7618      * <code>optional uint32 mode = 3;</code>
7619      */
7620     public int getMode() {
7621       return mode_;
7622     }
7623
7624     // optional uint32 pid = 4;
7625     public static final int PID_FIELD_NUMBER = 4;
7626     private int pid_;
7627     /**
7628      * <code>optional uint32 pid = 4;</code>
7629      */
7630     public boolean hasPid() {
7631       return ((bitField0_ & 0x00000008) == 0x00000008);
7632     }
7633     /**
7634      * <code>optional uint32 pid = 4;</code>
7635      */
7636     public int getPid() {
7637       return pid_;
7638     }
7639
7640     // optional bool success = 5;
7641     public static final int SUCCESS_FIELD_NUMBER = 5;
7642     private boolean success_;
7643     /**
7644      * <code>optional bool success = 5;</code>
7645      */
7646     public boolean hasSuccess() {
7647       return ((bitField0_ & 0x00000010) == 0x00000010);
7648     }
7649     /**
7650      * <code>optional bool success = 5;</code>
7651      */
7652     public boolean getSuccess() {
7653       return success_;
7654     }
7655
7656     // optional uint32 negative_response_code = 6;
7657     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
7658     private int negativeResponseCode_;
7659     /**
7660      * <code>optional uint32 negative_response_code = 6;</code>
7661      */
7662     public boolean hasNegativeResponseCode() {
7663       return ((bitField0_ & 0x00000020) == 0x00000020);
7664     }
7665     /**
7666      * <code>optional uint32 negative_response_code = 6;</code>
7667      */
7668     public int getNegativeResponseCode() {
7669       return negativeResponseCode_;
7670     }
7671
7672     // optional bytes payload = 7;
7673     public static final int PAYLOAD_FIELD_NUMBER = 7;
7674     private com.google.protobuf.ByteString payload_;
7675     /**
7676      * <code>optional bytes payload = 7;</code>
7677      *
7678      * <pre>
7679      * TODO we are capping this at 8 bytes for now - need to change when we
7680      * support multi-frame responses
7681      * </pre>
7682      */
7683     public boolean hasPayload() {
7684       return ((bitField0_ & 0x00000040) == 0x00000040);
7685     }
7686     /**
7687      * <code>optional bytes payload = 7;</code>
7688      *
7689      * <pre>
7690      * TODO we are capping this at 8 bytes for now - need to change when we
7691      * support multi-frame responses
7692      * </pre>
7693      */
7694     public com.google.protobuf.ByteString getPayload() {
7695       return payload_;
7696     }
7697
7698     // optional double value = 8;
7699     public static final int VALUE_FIELD_NUMBER = 8;
7700     private double value_;
7701     /**
7702      * <code>optional double value = 8;</code>
7703      */
7704     public boolean hasValue() {
7705       return ((bitField0_ & 0x00000080) == 0x00000080);
7706     }
7707     /**
7708      * <code>optional double value = 8;</code>
7709      */
7710     public double getValue() {
7711       return value_;
7712     }
7713
7714     private void initFields() {
7715       bus_ = 0;
7716       messageId_ = 0;
7717       mode_ = 0;
7718       pid_ = 0;
7719       success_ = false;
7720       negativeResponseCode_ = 0;
7721       payload_ = com.google.protobuf.ByteString.EMPTY;
7722       value_ = 0D;
7723     }
7724     private byte memoizedIsInitialized = -1;
7725     public final boolean isInitialized() {
7726       byte isInitialized = memoizedIsInitialized;
7727       if (isInitialized != -1) return isInitialized == 1;
7728
7729       memoizedIsInitialized = 1;
7730       return true;
7731     }
7732
7733     public void writeTo(com.google.protobuf.CodedOutputStream output)
7734                         throws java.io.IOException {
7735       getSerializedSize();
7736       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7737         output.writeInt32(1, bus_);
7738       }
7739       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7740         output.writeUInt32(2, messageId_);
7741       }
7742       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7743         output.writeUInt32(3, mode_);
7744       }
7745       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7746         output.writeUInt32(4, pid_);
7747       }
7748       if (((bitField0_ & 0x00000010) == 0x00000010)) {
7749         output.writeBool(5, success_);
7750       }
7751       if (((bitField0_ & 0x00000020) == 0x00000020)) {
7752         output.writeUInt32(6, negativeResponseCode_);
7753       }
7754       if (((bitField0_ & 0x00000040) == 0x00000040)) {
7755         output.writeBytes(7, payload_);
7756       }
7757       if (((bitField0_ & 0x00000080) == 0x00000080)) {
7758         output.writeDouble(8, value_);
7759       }
7760       getUnknownFields().writeTo(output);
7761     }
7762
7763     private int memoizedSerializedSize = -1;
7764     public int getSerializedSize() {
7765       int size = memoizedSerializedSize;
7766       if (size != -1) return size;
7767
7768       size = 0;
7769       if (((bitField0_ & 0x00000001) == 0x00000001)) {
7770         size += com.google.protobuf.CodedOutputStream
7771           .computeInt32Size(1, bus_);
7772       }
7773       if (((bitField0_ & 0x00000002) == 0x00000002)) {
7774         size += com.google.protobuf.CodedOutputStream
7775           .computeUInt32Size(2, messageId_);
7776       }
7777       if (((bitField0_ & 0x00000004) == 0x00000004)) {
7778         size += com.google.protobuf.CodedOutputStream
7779           .computeUInt32Size(3, mode_);
7780       }
7781       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7782         size += com.google.protobuf.CodedOutputStream
7783           .computeUInt32Size(4, pid_);
7784       }
7785       if (((bitField0_ & 0x00000010) == 0x00000010)) {
7786         size += com.google.protobuf.CodedOutputStream
7787           .computeBoolSize(5, success_);
7788       }
7789       if (((bitField0_ & 0x00000020) == 0x00000020)) {
7790         size += com.google.protobuf.CodedOutputStream
7791           .computeUInt32Size(6, negativeResponseCode_);
7792       }
7793       if (((bitField0_ & 0x00000040) == 0x00000040)) {
7794         size += com.google.protobuf.CodedOutputStream
7795           .computeBytesSize(7, payload_);
7796       }
7797       if (((bitField0_ & 0x00000080) == 0x00000080)) {
7798         size += com.google.protobuf.CodedOutputStream
7799           .computeDoubleSize(8, value_);
7800       }
7801       size += getUnknownFields().getSerializedSize();
7802       memoizedSerializedSize = size;
7803       return size;
7804     }
7805
7806     private static final long serialVersionUID = 0L;
7807     @java.lang.Override
7808     protected java.lang.Object writeReplace()
7809         throws java.io.ObjectStreamException {
7810       return super.writeReplace();
7811     }
7812
7813     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
7814         com.google.protobuf.ByteString data)
7815         throws com.google.protobuf.InvalidProtocolBufferException {
7816       return PARSER.parseFrom(data);
7817     }
7818     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
7819         com.google.protobuf.ByteString data,
7820         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7821         throws com.google.protobuf.InvalidProtocolBufferException {
7822       return PARSER.parseFrom(data, extensionRegistry);
7823     }
7824     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
7825         throws com.google.protobuf.InvalidProtocolBufferException {
7826       return PARSER.parseFrom(data);
7827     }
7828     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
7829         byte[] data,
7830         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7831         throws com.google.protobuf.InvalidProtocolBufferException {
7832       return PARSER.parseFrom(data, extensionRegistry);
7833     }
7834     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
7835         throws java.io.IOException {
7836       return PARSER.parseFrom(input);
7837     }
7838     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
7839         java.io.InputStream input,
7840         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7841         throws java.io.IOException {
7842       return PARSER.parseFrom(input, extensionRegistry);
7843     }
7844     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
7845         throws java.io.IOException {
7846       return PARSER.parseDelimitedFrom(input);
7847     }
7848     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
7849         java.io.InputStream input,
7850         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7851         throws java.io.IOException {
7852       return PARSER.parseDelimitedFrom(input, extensionRegistry);
7853     }
7854     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
7855         com.google.protobuf.CodedInputStream input)
7856         throws java.io.IOException {
7857       return PARSER.parseFrom(input);
7858     }
7859     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
7860         com.google.protobuf.CodedInputStream input,
7861         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7862         throws java.io.IOException {
7863       return PARSER.parseFrom(input, extensionRegistry);
7864     }
7865
7866     public static Builder newBuilder() { return Builder.create(); }
7867     public Builder newBuilderForType() { return newBuilder(); }
7868     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
7869       return newBuilder().mergeFrom(prototype);
7870     }
7871     public Builder toBuilder() { return newBuilder(this); }
7872
7873     @java.lang.Override
7874     protected Builder newBuilderForType(
7875         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7876       Builder builder = new Builder(parent);
7877       return builder;
7878     }
7879     /**
7880      * Protobuf type {@code openxc.DiagnosticResponse}
7881      */
7882     public static final class Builder extends
7883         com.google.protobuf.GeneratedMessage.Builder<Builder>
7884        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
7885       public static final com.google.protobuf.Descriptors.Descriptor
7886           getDescriptor() {
7887         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
7888       }
7889
7890       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7891           internalGetFieldAccessorTable() {
7892         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
7893             .ensureFieldAccessorsInitialized(
7894                 com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
7895       }
7896
7897       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
7898       private Builder() {
7899         maybeForceBuilderInitialization();
7900       }
7901
7902       private Builder(
7903           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7904         super(parent);
7905         maybeForceBuilderInitialization();
7906       }
7907       private void maybeForceBuilderInitialization() {
7908         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7909         }
7910       }
7911       private static Builder create() {
7912         return new Builder();
7913       }
7914
7915       public Builder clear() {
7916         super.clear();
7917         bus_ = 0;
7918         bitField0_ = (bitField0_ & ~0x00000001);
7919         messageId_ = 0;
7920         bitField0_ = (bitField0_ & ~0x00000002);
7921         mode_ = 0;
7922         bitField0_ = (bitField0_ & ~0x00000004);
7923         pid_ = 0;
7924         bitField0_ = (bitField0_ & ~0x00000008);
7925         success_ = false;
7926         bitField0_ = (bitField0_ & ~0x00000010);
7927         negativeResponseCode_ = 0;
7928         bitField0_ = (bitField0_ & ~0x00000020);
7929         payload_ = com.google.protobuf.ByteString.EMPTY;
7930         bitField0_ = (bitField0_ & ~0x00000040);
7931         value_ = 0D;
7932         bitField0_ = (bitField0_ & ~0x00000080);
7933         return this;
7934       }
7935
7936       public Builder clone() {
7937         return create().mergeFrom(buildPartial());
7938       }
7939
7940       public com.google.protobuf.Descriptors.Descriptor
7941           getDescriptorForType() {
7942         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
7943       }
7944
7945       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
7946         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
7947       }
7948
7949       public com.openxc.BinaryMessages.DiagnosticResponse build() {
7950         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
7951         if (!result.isInitialized()) {
7952           throw newUninitializedMessageException(result);
7953         }
7954         return result;
7955       }
7956
7957       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
7958         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
7959         int from_bitField0_ = bitField0_;
7960         int to_bitField0_ = 0;
7961         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7962           to_bitField0_ |= 0x00000001;
7963         }
7964         result.bus_ = bus_;
7965         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7966           to_bitField0_ |= 0x00000002;
7967         }
7968         result.messageId_ = messageId_;
7969         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
7970           to_bitField0_ |= 0x00000004;
7971         }
7972         result.mode_ = mode_;
7973         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
7974           to_bitField0_ |= 0x00000008;
7975         }
7976         result.pid_ = pid_;
7977         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
7978           to_bitField0_ |= 0x00000010;
7979         }
7980         result.success_ = success_;
7981         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
7982           to_bitField0_ |= 0x00000020;
7983         }
7984         result.negativeResponseCode_ = negativeResponseCode_;
7985         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
7986           to_bitField0_ |= 0x00000040;
7987         }
7988         result.payload_ = payload_;
7989         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
7990           to_bitField0_ |= 0x00000080;
7991         }
7992         result.value_ = value_;
7993         result.bitField0_ = to_bitField0_;
7994         onBuilt();
7995         return result;
7996       }
7997
7998       public Builder mergeFrom(com.google.protobuf.Message other) {
7999         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
8000           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
8001         } else {
8002           super.mergeFrom(other);
8003           return this;
8004         }
8005       }
8006
8007       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
8008         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
8009         if (other.hasBus()) {
8010           setBus(other.getBus());
8011         }
8012         if (other.hasMessageId()) {
8013           setMessageId(other.getMessageId());
8014         }
8015         if (other.hasMode()) {
8016           setMode(other.getMode());
8017         }
8018         if (other.hasPid()) {
8019           setPid(other.getPid());
8020         }
8021         if (other.hasSuccess()) {
8022           setSuccess(other.getSuccess());
8023         }
8024         if (other.hasNegativeResponseCode()) {
8025           setNegativeResponseCode(other.getNegativeResponseCode());
8026         }
8027         if (other.hasPayload()) {
8028           setPayload(other.getPayload());
8029         }
8030         if (other.hasValue()) {
8031           setValue(other.getValue());
8032         }
8033         this.mergeUnknownFields(other.getUnknownFields());
8034         return this;
8035       }
8036
8037       public final boolean isInitialized() {
8038         return true;
8039       }
8040
8041       public Builder mergeFrom(
8042           com.google.protobuf.CodedInputStream input,
8043           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8044           throws java.io.IOException {
8045         com.openxc.BinaryMessages.DiagnosticResponse parsedMessage = null;
8046         try {
8047           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
8048         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8049           parsedMessage = (com.openxc.BinaryMessages.DiagnosticResponse) e.getUnfinishedMessage();
8050           throw e;
8051         } finally {
8052           if (parsedMessage != null) {
8053             mergeFrom(parsedMessage);
8054           }
8055         }
8056         return this;
8057       }
8058       private int bitField0_;
8059
8060       // optional int32 bus = 1;
8061       private int bus_ ;
8062       /**
8063        * <code>optional int32 bus = 1;</code>
8064        */
8065       public boolean hasBus() {
8066         return ((bitField0_ & 0x00000001) == 0x00000001);
8067       }
8068       /**
8069        * <code>optional int32 bus = 1;</code>
8070        */
8071       public int getBus() {
8072         return bus_;
8073       }
8074       /**
8075        * <code>optional int32 bus = 1;</code>
8076        */
8077       public Builder setBus(int value) {
8078         bitField0_ |= 0x00000001;
8079         bus_ = value;
8080         onChanged();
8081         return this;
8082       }
8083       /**
8084        * <code>optional int32 bus = 1;</code>
8085        */
8086       public Builder clearBus() {
8087         bitField0_ = (bitField0_ & ~0x00000001);
8088         bus_ = 0;
8089         onChanged();
8090         return this;
8091       }
8092
8093       // optional uint32 message_id = 2;
8094       private int messageId_ ;
8095       /**
8096        * <code>optional uint32 message_id = 2;</code>
8097        */
8098       public boolean hasMessageId() {
8099         return ((bitField0_ & 0x00000002) == 0x00000002);
8100       }
8101       /**
8102        * <code>optional uint32 message_id = 2;</code>
8103        */
8104       public int getMessageId() {
8105         return messageId_;
8106       }
8107       /**
8108        * <code>optional uint32 message_id = 2;</code>
8109        */
8110       public Builder setMessageId(int value) {
8111         bitField0_ |= 0x00000002;
8112         messageId_ = value;
8113         onChanged();
8114         return this;
8115       }
8116       /**
8117        * <code>optional uint32 message_id = 2;</code>
8118        */
8119       public Builder clearMessageId() {
8120         bitField0_ = (bitField0_ & ~0x00000002);
8121         messageId_ = 0;
8122         onChanged();
8123         return this;
8124       }
8125
8126       // optional uint32 mode = 3;
8127       private int mode_ ;
8128       /**
8129        * <code>optional uint32 mode = 3;</code>
8130        */
8131       public boolean hasMode() {
8132         return ((bitField0_ & 0x00000004) == 0x00000004);
8133       }
8134       /**
8135        * <code>optional uint32 mode = 3;</code>
8136        */
8137       public int getMode() {
8138         return mode_;
8139       }
8140       /**
8141        * <code>optional uint32 mode = 3;</code>
8142        */
8143       public Builder setMode(int value) {
8144         bitField0_ |= 0x00000004;
8145         mode_ = value;
8146         onChanged();
8147         return this;
8148       }
8149       /**
8150        * <code>optional uint32 mode = 3;</code>
8151        */
8152       public Builder clearMode() {
8153         bitField0_ = (bitField0_ & ~0x00000004);
8154         mode_ = 0;
8155         onChanged();
8156         return this;
8157       }
8158
8159       // optional uint32 pid = 4;
8160       private int pid_ ;
8161       /**
8162        * <code>optional uint32 pid = 4;</code>
8163        */
8164       public boolean hasPid() {
8165         return ((bitField0_ & 0x00000008) == 0x00000008);
8166       }
8167       /**
8168        * <code>optional uint32 pid = 4;</code>
8169        */
8170       public int getPid() {
8171         return pid_;
8172       }
8173       /**
8174        * <code>optional uint32 pid = 4;</code>
8175        */
8176       public Builder setPid(int value) {
8177         bitField0_ |= 0x00000008;
8178         pid_ = value;
8179         onChanged();
8180         return this;
8181       }
8182       /**
8183        * <code>optional uint32 pid = 4;</code>
8184        */
8185       public Builder clearPid() {
8186         bitField0_ = (bitField0_ & ~0x00000008);
8187         pid_ = 0;
8188         onChanged();
8189         return this;
8190       }
8191
8192       // optional bool success = 5;
8193       private boolean success_ ;
8194       /**
8195        * <code>optional bool success = 5;</code>
8196        */
8197       public boolean hasSuccess() {
8198         return ((bitField0_ & 0x00000010) == 0x00000010);
8199       }
8200       /**
8201        * <code>optional bool success = 5;</code>
8202        */
8203       public boolean getSuccess() {
8204         return success_;
8205       }
8206       /**
8207        * <code>optional bool success = 5;</code>
8208        */
8209       public Builder setSuccess(boolean value) {
8210         bitField0_ |= 0x00000010;
8211         success_ = value;
8212         onChanged();
8213         return this;
8214       }
8215       /**
8216        * <code>optional bool success = 5;</code>
8217        */
8218       public Builder clearSuccess() {
8219         bitField0_ = (bitField0_ & ~0x00000010);
8220         success_ = false;
8221         onChanged();
8222         return this;
8223       }
8224
8225       // optional uint32 negative_response_code = 6;
8226       private int negativeResponseCode_ ;
8227       /**
8228        * <code>optional uint32 negative_response_code = 6;</code>
8229        */
8230       public boolean hasNegativeResponseCode() {
8231         return ((bitField0_ & 0x00000020) == 0x00000020);
8232       }
8233       /**
8234        * <code>optional uint32 negative_response_code = 6;</code>
8235        */
8236       public int getNegativeResponseCode() {
8237         return negativeResponseCode_;
8238       }
8239       /**
8240        * <code>optional uint32 negative_response_code = 6;</code>
8241        */
8242       public Builder setNegativeResponseCode(int value) {
8243         bitField0_ |= 0x00000020;
8244         negativeResponseCode_ = value;
8245         onChanged();
8246         return this;
8247       }
8248       /**
8249        * <code>optional uint32 negative_response_code = 6;</code>
8250        */
8251       public Builder clearNegativeResponseCode() {
8252         bitField0_ = (bitField0_ & ~0x00000020);
8253         negativeResponseCode_ = 0;
8254         onChanged();
8255         return this;
8256       }
8257
8258       // optional bytes payload = 7;
8259       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
8260       /**
8261        * <code>optional bytes payload = 7;</code>
8262        *
8263        * <pre>
8264        * TODO we are capping this at 8 bytes for now - need to change when we
8265        * support multi-frame responses
8266        * </pre>
8267        */
8268       public boolean hasPayload() {
8269         return ((bitField0_ & 0x00000040) == 0x00000040);
8270       }
8271       /**
8272        * <code>optional bytes payload = 7;</code>
8273        *
8274        * <pre>
8275        * TODO we are capping this at 8 bytes for now - need to change when we
8276        * support multi-frame responses
8277        * </pre>
8278        */
8279       public com.google.protobuf.ByteString getPayload() {
8280         return payload_;
8281       }
8282       /**
8283        * <code>optional bytes payload = 7;</code>
8284        *
8285        * <pre>
8286        * TODO we are capping this at 8 bytes for now - need to change when we
8287        * support multi-frame responses
8288        * </pre>
8289        */
8290       public Builder setPayload(com.google.protobuf.ByteString value) {
8291         if (value == null) {
8292     throw new NullPointerException();
8293   }
8294   bitField0_ |= 0x00000040;
8295         payload_ = value;
8296         onChanged();
8297         return this;
8298       }
8299       /**
8300        * <code>optional bytes payload = 7;</code>
8301        *
8302        * <pre>
8303        * TODO we are capping this at 8 bytes for now - need to change when we
8304        * support multi-frame responses
8305        * </pre>
8306        */
8307       public Builder clearPayload() {
8308         bitField0_ = (bitField0_ & ~0x00000040);
8309         payload_ = getDefaultInstance().getPayload();
8310         onChanged();
8311         return this;
8312       }
8313
8314       // optional double value = 8;
8315       private double value_ ;
8316       /**
8317        * <code>optional double value = 8;</code>
8318        */
8319       public boolean hasValue() {
8320         return ((bitField0_ & 0x00000080) == 0x00000080);
8321       }
8322       /**
8323        * <code>optional double value = 8;</code>
8324        */
8325       public double getValue() {
8326         return value_;
8327       }
8328       /**
8329        * <code>optional double value = 8;</code>
8330        */
8331       public Builder setValue(double value) {
8332         bitField0_ |= 0x00000080;
8333         value_ = value;
8334         onChanged();
8335         return this;
8336       }
8337       /**
8338        * <code>optional double value = 8;</code>
8339        */
8340       public Builder clearValue() {
8341         bitField0_ = (bitField0_ & ~0x00000080);
8342         value_ = 0D;
8343         onChanged();
8344         return this;
8345       }
8346
8347       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
8348     }
8349
8350     static {
8351       defaultInstance = new DiagnosticResponse(true);
8352       defaultInstance.initFields();
8353     }
8354
8355     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
8356   }
8357
8358   public interface DynamicFieldOrBuilder
8359       extends com.google.protobuf.MessageOrBuilder {
8360
8361     // optional .openxc.DynamicField.Type type = 1;
8362     /**
8363      * <code>optional .openxc.DynamicField.Type type = 1;</code>
8364      */
8365     boolean hasType();
8366     /**
8367      * <code>optional .openxc.DynamicField.Type type = 1;</code>
8368      */
8369     com.openxc.BinaryMessages.DynamicField.Type getType();
8370
8371     // optional string string_value = 2;
8372     /**
8373      * <code>optional string string_value = 2;</code>
8374      */
8375     boolean hasStringValue();
8376     /**
8377      * <code>optional string string_value = 2;</code>
8378      */
8379     java.lang.String getStringValue();
8380     /**
8381      * <code>optional string string_value = 2;</code>
8382      */
8383     com.google.protobuf.ByteString
8384         getStringValueBytes();
8385
8386     // optional double numeric_value = 3;
8387     /**
8388      * <code>optional double numeric_value = 3;</code>
8389      */
8390     boolean hasNumericValue();
8391     /**
8392      * <code>optional double numeric_value = 3;</code>
8393      */
8394     double getNumericValue();
8395
8396     // optional bool boolean_value = 4;
8397     /**
8398      * <code>optional bool boolean_value = 4;</code>
8399      */
8400     boolean hasBooleanValue();
8401     /**
8402      * <code>optional bool boolean_value = 4;</code>
8403      */
8404     boolean getBooleanValue();
8405   }
8406   /**
8407    * Protobuf type {@code openxc.DynamicField}
8408    */
8409   public static final class DynamicField extends
8410       com.google.protobuf.GeneratedMessage
8411       implements DynamicFieldOrBuilder {
8412     // Use DynamicField.newBuilder() to construct.
8413     private DynamicField(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
8414       super(builder);
8415       this.unknownFields = builder.getUnknownFields();
8416     }
8417     private DynamicField(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
8418
8419     private static final DynamicField defaultInstance;
8420     public static DynamicField getDefaultInstance() {
8421       return defaultInstance;
8422     }
8423
8424     public DynamicField getDefaultInstanceForType() {
8425       return defaultInstance;
8426     }
8427
8428     private final com.google.protobuf.UnknownFieldSet unknownFields;
8429     @java.lang.Override
8430     public final com.google.protobuf.UnknownFieldSet
8431         getUnknownFields() {
8432       return this.unknownFields;
8433     }
8434     private DynamicField(
8435         com.google.protobuf.CodedInputStream input,
8436         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8437         throws com.google.protobuf.InvalidProtocolBufferException {
8438       initFields();
8439       int mutable_bitField0_ = 0;
8440       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
8441           com.google.protobuf.UnknownFieldSet.newBuilder();
8442       try {
8443         boolean done = false;
8444         while (!done) {
8445           int tag = input.readTag();
8446           switch (tag) {
8447             case 0:
8448               done = true;
8449               break;
8450             default: {
8451               if (!parseUnknownField(input, unknownFields,
8452                                      extensionRegistry, tag)) {
8453                 done = true;
8454               }
8455               break;
8456             }
8457             case 8: {
8458               int rawValue = input.readEnum();
8459               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
8460               if (value == null) {
8461                 unknownFields.mergeVarintField(1, rawValue);
8462               } else {
8463                 bitField0_ |= 0x00000001;
8464                 type_ = value;
8465               }
8466               break;
8467             }
8468             case 18: {
8469               bitField0_ |= 0x00000002;
8470               stringValue_ = input.readBytes();
8471               break;
8472             }
8473             case 25: {
8474               bitField0_ |= 0x00000004;
8475               numericValue_ = input.readDouble();
8476               break;
8477             }
8478             case 32: {
8479               bitField0_ |= 0x00000008;
8480               booleanValue_ = input.readBool();
8481               break;
8482             }
8483           }
8484         }
8485       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8486         throw e.setUnfinishedMessage(this);
8487       } catch (java.io.IOException e) {
8488         throw new com.google.protobuf.InvalidProtocolBufferException(
8489             e.getMessage()).setUnfinishedMessage(this);
8490       } finally {
8491         this.unknownFields = unknownFields.build();
8492         makeExtensionsImmutable();
8493       }
8494     }
8495     public static final com.google.protobuf.Descriptors.Descriptor
8496         getDescriptor() {
8497       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
8498     }
8499
8500     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8501         internalGetFieldAccessorTable() {
8502       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
8503           .ensureFieldAccessorsInitialized(
8504               com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
8505     }
8506
8507     public static com.google.protobuf.Parser<DynamicField> PARSER =
8508         new com.google.protobuf.AbstractParser<DynamicField>() {
8509       public DynamicField parsePartialFrom(
8510           com.google.protobuf.CodedInputStream input,
8511           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8512           throws com.google.protobuf.InvalidProtocolBufferException {
8513         return new DynamicField(input, extensionRegistry);
8514       }
8515     };
8516
8517     @java.lang.Override
8518     public com.google.protobuf.Parser<DynamicField> getParserForType() {
8519       return PARSER;
8520     }
8521
8522     /**
8523      * Protobuf enum {@code openxc.DynamicField.Type}
8524      */
8525     public enum Type
8526         implements com.google.protobuf.ProtocolMessageEnum {
8527       /**
8528        * <code>STRING = 1;</code>
8529        */
8530       STRING(0, 1),
8531       /**
8532        * <code>NUM = 2;</code>
8533        */
8534       NUM(1, 2),
8535       /**
8536        * <code>BOOL = 3;</code>
8537        */
8538       BOOL(2, 3),
8539       ;
8540
8541       /**
8542        * <code>STRING = 1;</code>
8543        */
8544       public static final int STRING_VALUE = 1;
8545       /**
8546        * <code>NUM = 2;</code>
8547        */
8548       public static final int NUM_VALUE = 2;
8549       /**
8550        * <code>BOOL = 3;</code>
8551        */
8552       public static final int BOOL_VALUE = 3;
8553
8554
8555       public final int getNumber() { return value; }
8556
8557       public static Type valueOf(int value) {
8558         switch (value) {
8559           case 1: return STRING;
8560           case 2: return NUM;
8561           case 3: return BOOL;
8562           default: return null;
8563         }
8564       }
8565
8566       public static com.google.protobuf.Internal.EnumLiteMap<Type>
8567           internalGetValueMap() {
8568         return internalValueMap;
8569       }
8570       private static com.google.protobuf.Internal.EnumLiteMap<Type>
8571           internalValueMap =
8572             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
8573               public Type findValueByNumber(int number) {
8574                 return Type.valueOf(number);
8575               }
8576             };
8577
8578       public final com.google.protobuf.Descriptors.EnumValueDescriptor
8579           getValueDescriptor() {
8580         return getDescriptor().getValues().get(index);
8581       }
8582       public final com.google.protobuf.Descriptors.EnumDescriptor
8583           getDescriptorForType() {
8584         return getDescriptor();
8585       }
8586       public static final com.google.protobuf.Descriptors.EnumDescriptor
8587           getDescriptor() {
8588         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
8589       }
8590
8591       private static final Type[] VALUES = values();
8592
8593       public static Type valueOf(
8594           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
8595         if (desc.getType() != getDescriptor()) {
8596           throw new java.lang.IllegalArgumentException(
8597             "EnumValueDescriptor is not for this type.");
8598         }
8599         return VALUES[desc.getIndex()];
8600       }
8601
8602       private final int index;
8603       private final int value;
8604
8605       private Type(int index, int value) {
8606         this.index = index;
8607         this.value = value;
8608       }
8609
8610       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
8611     }
8612
8613     private int bitField0_;
8614     // optional .openxc.DynamicField.Type type = 1;
8615     public static final int TYPE_FIELD_NUMBER = 1;
8616     private com.openxc.BinaryMessages.DynamicField.Type type_;
8617     /**
8618      * <code>optional .openxc.DynamicField.Type type = 1;</code>
8619      */
8620     public boolean hasType() {
8621       return ((bitField0_ & 0x00000001) == 0x00000001);
8622     }
8623     /**
8624      * <code>optional .openxc.DynamicField.Type type = 1;</code>
8625      */
8626     public com.openxc.BinaryMessages.DynamicField.Type getType() {
8627       return type_;
8628     }
8629
8630     // optional string string_value = 2;
8631     public static final int STRING_VALUE_FIELD_NUMBER = 2;
8632     private java.lang.Object stringValue_;
8633     /**
8634      * <code>optional string string_value = 2;</code>
8635      */
8636     public boolean hasStringValue() {
8637       return ((bitField0_ & 0x00000002) == 0x00000002);
8638     }
8639     /**
8640      * <code>optional string string_value = 2;</code>
8641      */
8642     public java.lang.String getStringValue() {
8643       java.lang.Object ref = stringValue_;
8644       if (ref instanceof java.lang.String) {
8645         return (java.lang.String) ref;
8646       } else {
8647         com.google.protobuf.ByteString bs =
8648             (com.google.protobuf.ByteString) ref;
8649         java.lang.String s = bs.toStringUtf8();
8650         if (bs.isValidUtf8()) {
8651           stringValue_ = s;
8652         }
8653         return s;
8654       }
8655     }
8656     /**
8657      * <code>optional string string_value = 2;</code>
8658      */
8659     public com.google.protobuf.ByteString
8660         getStringValueBytes() {
8661       java.lang.Object ref = stringValue_;
8662       if (ref instanceof java.lang.String) {
8663         com.google.protobuf.ByteString b =
8664             com.google.protobuf.ByteString.copyFromUtf8(
8665                 (java.lang.String) ref);
8666         stringValue_ = b;
8667         return b;
8668       } else {
8669         return (com.google.protobuf.ByteString) ref;
8670       }
8671     }
8672
8673     // optional double numeric_value = 3;
8674     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
8675     private double numericValue_;
8676     /**
8677      * <code>optional double numeric_value = 3;</code>
8678      */
8679     public boolean hasNumericValue() {
8680       return ((bitField0_ & 0x00000004) == 0x00000004);
8681     }
8682     /**
8683      * <code>optional double numeric_value = 3;</code>
8684      */
8685     public double getNumericValue() {
8686       return numericValue_;
8687     }
8688
8689     // optional bool boolean_value = 4;
8690     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
8691     private boolean booleanValue_;
8692     /**
8693      * <code>optional bool boolean_value = 4;</code>
8694      */
8695     public boolean hasBooleanValue() {
8696       return ((bitField0_ & 0x00000008) == 0x00000008);
8697     }
8698     /**
8699      * <code>optional bool boolean_value = 4;</code>
8700      */
8701     public boolean getBooleanValue() {
8702       return booleanValue_;
8703     }
8704
8705     private void initFields() {
8706       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
8707       stringValue_ = "";
8708       numericValue_ = 0D;
8709       booleanValue_ = false;
8710     }
8711     private byte memoizedIsInitialized = -1;
8712     public final boolean isInitialized() {
8713       byte isInitialized = memoizedIsInitialized;
8714       if (isInitialized != -1) return isInitialized == 1;
8715
8716       memoizedIsInitialized = 1;
8717       return true;
8718     }
8719
8720     public void writeTo(com.google.protobuf.CodedOutputStream output)
8721                         throws java.io.IOException {
8722       getSerializedSize();
8723       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8724         output.writeEnum(1, type_.getNumber());
8725       }
8726       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8727         output.writeBytes(2, getStringValueBytes());
8728       }
8729       if (((bitField0_ & 0x00000004) == 0x00000004)) {
8730         output.writeDouble(3, numericValue_);
8731       }
8732       if (((bitField0_ & 0x00000008) == 0x00000008)) {
8733         output.writeBool(4, booleanValue_);
8734       }
8735       getUnknownFields().writeTo(output);
8736     }
8737
8738     private int memoizedSerializedSize = -1;
8739     public int getSerializedSize() {
8740       int size = memoizedSerializedSize;
8741       if (size != -1) return size;
8742
8743       size = 0;
8744       if (((bitField0_ & 0x00000001) == 0x00000001)) {
8745         size += com.google.protobuf.CodedOutputStream
8746           .computeEnumSize(1, type_.getNumber());
8747       }
8748       if (((bitField0_ & 0x00000002) == 0x00000002)) {
8749         size += com.google.protobuf.CodedOutputStream
8750           .computeBytesSize(2, getStringValueBytes());
8751       }
8752       if (((bitField0_ & 0x00000004) == 0x00000004)) {
8753         size += com.google.protobuf.CodedOutputStream
8754           .computeDoubleSize(3, numericValue_);
8755       }
8756       if (((bitField0_ & 0x00000008) == 0x00000008)) {
8757         size += com.google.protobuf.CodedOutputStream
8758           .computeBoolSize(4, booleanValue_);
8759       }
8760       size += getUnknownFields().getSerializedSize();
8761       memoizedSerializedSize = size;
8762       return size;
8763     }
8764
8765     private static final long serialVersionUID = 0L;
8766     @java.lang.Override
8767     protected java.lang.Object writeReplace()
8768         throws java.io.ObjectStreamException {
8769       return super.writeReplace();
8770     }
8771
8772     public static com.openxc.BinaryMessages.DynamicField parseFrom(
8773         com.google.protobuf.ByteString data)
8774         throws com.google.protobuf.InvalidProtocolBufferException {
8775       return PARSER.parseFrom(data);
8776     }
8777     public static com.openxc.BinaryMessages.DynamicField parseFrom(
8778         com.google.protobuf.ByteString data,
8779         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8780         throws com.google.protobuf.InvalidProtocolBufferException {
8781       return PARSER.parseFrom(data, extensionRegistry);
8782     }
8783     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
8784         throws com.google.protobuf.InvalidProtocolBufferException {
8785       return PARSER.parseFrom(data);
8786     }
8787     public static com.openxc.BinaryMessages.DynamicField parseFrom(
8788         byte[] data,
8789         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8790         throws com.google.protobuf.InvalidProtocolBufferException {
8791       return PARSER.parseFrom(data, extensionRegistry);
8792     }
8793     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
8794         throws java.io.IOException {
8795       return PARSER.parseFrom(input);
8796     }
8797     public static com.openxc.BinaryMessages.DynamicField parseFrom(
8798         java.io.InputStream input,
8799         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8800         throws java.io.IOException {
8801       return PARSER.parseFrom(input, extensionRegistry);
8802     }
8803     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
8804         throws java.io.IOException {
8805       return PARSER.parseDelimitedFrom(input);
8806     }
8807     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
8808         java.io.InputStream input,
8809         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8810         throws java.io.IOException {
8811       return PARSER.parseDelimitedFrom(input, extensionRegistry);
8812     }
8813     public static com.openxc.BinaryMessages.DynamicField parseFrom(
8814         com.google.protobuf.CodedInputStream input)
8815         throws java.io.IOException {
8816       return PARSER.parseFrom(input);
8817     }
8818     public static com.openxc.BinaryMessages.DynamicField parseFrom(
8819         com.google.protobuf.CodedInputStream input,
8820         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8821         throws java.io.IOException {
8822       return PARSER.parseFrom(input, extensionRegistry);
8823     }
8824
8825     public static Builder newBuilder() { return Builder.create(); }
8826     public Builder newBuilderForType() { return newBuilder(); }
8827     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
8828       return newBuilder().mergeFrom(prototype);
8829     }
8830     public Builder toBuilder() { return newBuilder(this); }
8831
8832     @java.lang.Override
8833     protected Builder newBuilderForType(
8834         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8835       Builder builder = new Builder(parent);
8836       return builder;
8837     }
8838     /**
8839      * Protobuf type {@code openxc.DynamicField}
8840      */
8841     public static final class Builder extends
8842         com.google.protobuf.GeneratedMessage.Builder<Builder>
8843        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
8844       public static final com.google.protobuf.Descriptors.Descriptor
8845           getDescriptor() {
8846         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
8847       }
8848
8849       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
8850           internalGetFieldAccessorTable() {
8851         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
8852             .ensureFieldAccessorsInitialized(
8853                 com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
8854       }
8855
8856       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
8857       private Builder() {
8858         maybeForceBuilderInitialization();
8859       }
8860
8861       private Builder(
8862           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
8863         super(parent);
8864         maybeForceBuilderInitialization();
8865       }
8866       private void maybeForceBuilderInitialization() {
8867         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
8868         }
8869       }
8870       private static Builder create() {
8871         return new Builder();
8872       }
8873
8874       public Builder clear() {
8875         super.clear();
8876         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
8877         bitField0_ = (bitField0_ & ~0x00000001);
8878         stringValue_ = "";
8879         bitField0_ = (bitField0_ & ~0x00000002);
8880         numericValue_ = 0D;
8881         bitField0_ = (bitField0_ & ~0x00000004);
8882         booleanValue_ = false;
8883         bitField0_ = (bitField0_ & ~0x00000008);
8884         return this;
8885       }
8886
8887       public Builder clone() {
8888         return create().mergeFrom(buildPartial());
8889       }
8890
8891       public com.google.protobuf.Descriptors.Descriptor
8892           getDescriptorForType() {
8893         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
8894       }
8895
8896       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
8897         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
8898       }
8899
8900       public com.openxc.BinaryMessages.DynamicField build() {
8901         com.openxc.BinaryMessages.DynamicField result = buildPartial();
8902         if (!result.isInitialized()) {
8903           throw newUninitializedMessageException(result);
8904         }
8905         return result;
8906       }
8907
8908       public com.openxc.BinaryMessages.DynamicField buildPartial() {
8909         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
8910         int from_bitField0_ = bitField0_;
8911         int to_bitField0_ = 0;
8912         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
8913           to_bitField0_ |= 0x00000001;
8914         }
8915         result.type_ = type_;
8916         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
8917           to_bitField0_ |= 0x00000002;
8918         }
8919         result.stringValue_ = stringValue_;
8920         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
8921           to_bitField0_ |= 0x00000004;
8922         }
8923         result.numericValue_ = numericValue_;
8924         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
8925           to_bitField0_ |= 0x00000008;
8926         }
8927         result.booleanValue_ = booleanValue_;
8928         result.bitField0_ = to_bitField0_;
8929         onBuilt();
8930         return result;
8931       }
8932
8933       public Builder mergeFrom(com.google.protobuf.Message other) {
8934         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
8935           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
8936         } else {
8937           super.mergeFrom(other);
8938           return this;
8939         }
8940       }
8941
8942       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
8943         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
8944         if (other.hasType()) {
8945           setType(other.getType());
8946         }
8947         if (other.hasStringValue()) {
8948           bitField0_ |= 0x00000002;
8949           stringValue_ = other.stringValue_;
8950           onChanged();
8951         }
8952         if (other.hasNumericValue()) {
8953           setNumericValue(other.getNumericValue());
8954         }
8955         if (other.hasBooleanValue()) {
8956           setBooleanValue(other.getBooleanValue());
8957         }
8958         this.mergeUnknownFields(other.getUnknownFields());
8959         return this;
8960       }
8961
8962       public final boolean isInitialized() {
8963         return true;
8964       }
8965
8966       public Builder mergeFrom(
8967           com.google.protobuf.CodedInputStream input,
8968           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
8969           throws java.io.IOException {
8970         com.openxc.BinaryMessages.DynamicField parsedMessage = null;
8971         try {
8972           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
8973         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
8974           parsedMessage = (com.openxc.BinaryMessages.DynamicField) e.getUnfinishedMessage();
8975           throw e;
8976         } finally {
8977           if (parsedMessage != null) {
8978             mergeFrom(parsedMessage);
8979           }
8980         }
8981         return this;
8982       }
8983       private int bitField0_;
8984
8985       // optional .openxc.DynamicField.Type type = 1;
8986       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
8987       /**
8988        * <code>optional .openxc.DynamicField.Type type = 1;</code>
8989        */
8990       public boolean hasType() {
8991         return ((bitField0_ & 0x00000001) == 0x00000001);
8992       }
8993       /**
8994        * <code>optional .openxc.DynamicField.Type type = 1;</code>
8995        */
8996       public com.openxc.BinaryMessages.DynamicField.Type getType() {
8997         return type_;
8998       }
8999       /**
9000        * <code>optional .openxc.DynamicField.Type type = 1;</code>
9001        */
9002       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
9003         if (value == null) {
9004           throw new NullPointerException();
9005         }
9006         bitField0_ |= 0x00000001;
9007         type_ = value;
9008         onChanged();
9009         return this;
9010       }
9011       /**
9012        * <code>optional .openxc.DynamicField.Type type = 1;</code>
9013        */
9014       public Builder clearType() {
9015         bitField0_ = (bitField0_ & ~0x00000001);
9016         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
9017         onChanged();
9018         return this;
9019       }
9020
9021       // optional string string_value = 2;
9022       private java.lang.Object stringValue_ = "";
9023       /**
9024        * <code>optional string string_value = 2;</code>
9025        */
9026       public boolean hasStringValue() {
9027         return ((bitField0_ & 0x00000002) == 0x00000002);
9028       }
9029       /**
9030        * <code>optional string string_value = 2;</code>
9031        */
9032       public java.lang.String getStringValue() {
9033         java.lang.Object ref = stringValue_;
9034         if (!(ref instanceof java.lang.String)) {
9035           java.lang.String s = ((com.google.protobuf.ByteString) ref)
9036               .toStringUtf8();
9037           stringValue_ = s;
9038           return s;
9039         } else {
9040           return (java.lang.String) ref;
9041         }
9042       }
9043       /**
9044        * <code>optional string string_value = 2;</code>
9045        */
9046       public com.google.protobuf.ByteString
9047           getStringValueBytes() {
9048         java.lang.Object ref = stringValue_;
9049         if (ref instanceof String) {
9050           com.google.protobuf.ByteString b =
9051               com.google.protobuf.ByteString.copyFromUtf8(
9052                   (java.lang.String) ref);
9053           stringValue_ = b;
9054           return b;
9055         } else {
9056           return (com.google.protobuf.ByteString) ref;
9057         }
9058       }
9059       /**
9060        * <code>optional string string_value = 2;</code>
9061        */
9062       public Builder setStringValue(
9063           java.lang.String value) {
9064         if (value == null) {
9065     throw new NullPointerException();
9066   }
9067   bitField0_ |= 0x00000002;
9068         stringValue_ = value;
9069         onChanged();
9070         return this;
9071       }
9072       /**
9073        * <code>optional string string_value = 2;</code>
9074        */
9075       public Builder clearStringValue() {
9076         bitField0_ = (bitField0_ & ~0x00000002);
9077         stringValue_ = getDefaultInstance().getStringValue();
9078         onChanged();
9079         return this;
9080       }
9081       /**
9082        * <code>optional string string_value = 2;</code>
9083        */
9084       public Builder setStringValueBytes(
9085           com.google.protobuf.ByteString value) {
9086         if (value == null) {
9087     throw new NullPointerException();
9088   }
9089   bitField0_ |= 0x00000002;
9090         stringValue_ = value;
9091         onChanged();
9092         return this;
9093       }
9094
9095       // optional double numeric_value = 3;
9096       private double numericValue_ ;
9097       /**
9098        * <code>optional double numeric_value = 3;</code>
9099        */
9100       public boolean hasNumericValue() {
9101         return ((bitField0_ & 0x00000004) == 0x00000004);
9102       }
9103       /**
9104        * <code>optional double numeric_value = 3;</code>
9105        */
9106       public double getNumericValue() {
9107         return numericValue_;
9108       }
9109       /**
9110        * <code>optional double numeric_value = 3;</code>
9111        */
9112       public Builder setNumericValue(double value) {
9113         bitField0_ |= 0x00000004;
9114         numericValue_ = value;
9115         onChanged();
9116         return this;
9117       }
9118       /**
9119        * <code>optional double numeric_value = 3;</code>
9120        */
9121       public Builder clearNumericValue() {
9122         bitField0_ = (bitField0_ & ~0x00000004);
9123         numericValue_ = 0D;
9124         onChanged();
9125         return this;
9126       }
9127
9128       // optional bool boolean_value = 4;
9129       private boolean booleanValue_ ;
9130       /**
9131        * <code>optional bool boolean_value = 4;</code>
9132        */
9133       public boolean hasBooleanValue() {
9134         return ((bitField0_ & 0x00000008) == 0x00000008);
9135       }
9136       /**
9137        * <code>optional bool boolean_value = 4;</code>
9138        */
9139       public boolean getBooleanValue() {
9140         return booleanValue_;
9141       }
9142       /**
9143        * <code>optional bool boolean_value = 4;</code>
9144        */
9145       public Builder setBooleanValue(boolean value) {
9146         bitField0_ |= 0x00000008;
9147         booleanValue_ = value;
9148         onChanged();
9149         return this;
9150       }
9151       /**
9152        * <code>optional bool boolean_value = 4;</code>
9153        */
9154       public Builder clearBooleanValue() {
9155         bitField0_ = (bitField0_ & ~0x00000008);
9156         booleanValue_ = false;
9157         onChanged();
9158         return this;
9159       }
9160
9161       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
9162     }
9163
9164     static {
9165       defaultInstance = new DynamicField(true);
9166       defaultInstance.initFields();
9167     }
9168
9169     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
9170   }
9171
9172   public interface TranslatedMessageOrBuilder
9173       extends com.google.protobuf.MessageOrBuilder {
9174
9175     // optional .openxc.TranslatedMessage.Type type = 1;
9176     /**
9177      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9178      */
9179     boolean hasType();
9180     /**
9181      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9182      */
9183     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
9184
9185     // optional string name = 2;
9186     /**
9187      * <code>optional string name = 2;</code>
9188      */
9189     boolean hasName();
9190     /**
9191      * <code>optional string name = 2;</code>
9192      */
9193     java.lang.String getName();
9194     /**
9195      * <code>optional string name = 2;</code>
9196      */
9197     com.google.protobuf.ByteString
9198         getNameBytes();
9199
9200     // optional .openxc.DynamicField value = 3;
9201     /**
9202      * <code>optional .openxc.DynamicField value = 3;</code>
9203      */
9204     boolean hasValue();
9205     /**
9206      * <code>optional .openxc.DynamicField value = 3;</code>
9207      */
9208     com.openxc.BinaryMessages.DynamicField getValue();
9209     /**
9210      * <code>optional .openxc.DynamicField value = 3;</code>
9211      */
9212     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
9213
9214     // optional .openxc.DynamicField event = 4;
9215     /**
9216      * <code>optional .openxc.DynamicField event = 4;</code>
9217      */
9218     boolean hasEvent();
9219     /**
9220      * <code>optional .openxc.DynamicField event = 4;</code>
9221      */
9222     com.openxc.BinaryMessages.DynamicField getEvent();
9223     /**
9224      * <code>optional .openxc.DynamicField event = 4;</code>
9225      */
9226     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
9227   }
9228   /**
9229    * Protobuf type {@code openxc.TranslatedMessage}
9230    */
9231   public static final class TranslatedMessage extends
9232       com.google.protobuf.GeneratedMessage
9233       implements TranslatedMessageOrBuilder {
9234     // Use TranslatedMessage.newBuilder() to construct.
9235     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
9236       super(builder);
9237       this.unknownFields = builder.getUnknownFields();
9238     }
9239     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
9240
9241     private static final TranslatedMessage defaultInstance;
9242     public static TranslatedMessage getDefaultInstance() {
9243       return defaultInstance;
9244     }
9245
9246     public TranslatedMessage getDefaultInstanceForType() {
9247       return defaultInstance;
9248     }
9249
9250     private final com.google.protobuf.UnknownFieldSet unknownFields;
9251     @java.lang.Override
9252     public final com.google.protobuf.UnknownFieldSet
9253         getUnknownFields() {
9254       return this.unknownFields;
9255     }
9256     private TranslatedMessage(
9257         com.google.protobuf.CodedInputStream input,
9258         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9259         throws com.google.protobuf.InvalidProtocolBufferException {
9260       initFields();
9261       int mutable_bitField0_ = 0;
9262       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
9263           com.google.protobuf.UnknownFieldSet.newBuilder();
9264       try {
9265         boolean done = false;
9266         while (!done) {
9267           int tag = input.readTag();
9268           switch (tag) {
9269             case 0:
9270               done = true;
9271               break;
9272             default: {
9273               if (!parseUnknownField(input, unknownFields,
9274                                      extensionRegistry, tag)) {
9275                 done = true;
9276               }
9277               break;
9278             }
9279             case 8: {
9280               int rawValue = input.readEnum();
9281               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
9282               if (value == null) {
9283                 unknownFields.mergeVarintField(1, rawValue);
9284               } else {
9285                 bitField0_ |= 0x00000001;
9286                 type_ = value;
9287               }
9288               break;
9289             }
9290             case 18: {
9291               bitField0_ |= 0x00000002;
9292               name_ = input.readBytes();
9293               break;
9294             }
9295             case 26: {
9296               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
9297               if (((bitField0_ & 0x00000004) == 0x00000004)) {
9298                 subBuilder = value_.toBuilder();
9299               }
9300               value_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
9301               if (subBuilder != null) {
9302                 subBuilder.mergeFrom(value_);
9303                 value_ = subBuilder.buildPartial();
9304               }
9305               bitField0_ |= 0x00000004;
9306               break;
9307             }
9308             case 34: {
9309               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
9310               if (((bitField0_ & 0x00000008) == 0x00000008)) {
9311                 subBuilder = event_.toBuilder();
9312               }
9313               event_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
9314               if (subBuilder != null) {
9315                 subBuilder.mergeFrom(event_);
9316                 event_ = subBuilder.buildPartial();
9317               }
9318               bitField0_ |= 0x00000008;
9319               break;
9320             }
9321           }
9322         }
9323       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
9324         throw e.setUnfinishedMessage(this);
9325       } catch (java.io.IOException e) {
9326         throw new com.google.protobuf.InvalidProtocolBufferException(
9327             e.getMessage()).setUnfinishedMessage(this);
9328       } finally {
9329         this.unknownFields = unknownFields.build();
9330         makeExtensionsImmutable();
9331       }
9332     }
9333     public static final com.google.protobuf.Descriptors.Descriptor
9334         getDescriptor() {
9335       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
9336     }
9337
9338     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
9339         internalGetFieldAccessorTable() {
9340       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
9341           .ensureFieldAccessorsInitialized(
9342               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
9343     }
9344
9345     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
9346         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
9347       public TranslatedMessage parsePartialFrom(
9348           com.google.protobuf.CodedInputStream input,
9349           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9350           throws com.google.protobuf.InvalidProtocolBufferException {
9351         return new TranslatedMessage(input, extensionRegistry);
9352       }
9353     };
9354
9355     @java.lang.Override
9356     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
9357       return PARSER;
9358     }
9359
9360     /**
9361      * Protobuf enum {@code openxc.TranslatedMessage.Type}
9362      */
9363     public enum Type
9364         implements com.google.protobuf.ProtocolMessageEnum {
9365       /**
9366        * <code>STRING = 1;</code>
9367        */
9368       STRING(0, 1),
9369       /**
9370        * <code>NUM = 2;</code>
9371        */
9372       NUM(1, 2),
9373       /**
9374        * <code>BOOL = 3;</code>
9375        */
9376       BOOL(2, 3),
9377       /**
9378        * <code>EVENTED_STRING = 4;</code>
9379        */
9380       EVENTED_STRING(3, 4),
9381       /**
9382        * <code>EVENTED_NUM = 5;</code>
9383        */
9384       EVENTED_NUM(4, 5),
9385       /**
9386        * <code>EVENTED_BOOL = 6;</code>
9387        */
9388       EVENTED_BOOL(5, 6),
9389       ;
9390
9391       /**
9392        * <code>STRING = 1;</code>
9393        */
9394       public static final int STRING_VALUE = 1;
9395       /**
9396        * <code>NUM = 2;</code>
9397        */
9398       public static final int NUM_VALUE = 2;
9399       /**
9400        * <code>BOOL = 3;</code>
9401        */
9402       public static final int BOOL_VALUE = 3;
9403       /**
9404        * <code>EVENTED_STRING = 4;</code>
9405        */
9406       public static final int EVENTED_STRING_VALUE = 4;
9407       /**
9408        * <code>EVENTED_NUM = 5;</code>
9409        */
9410       public static final int EVENTED_NUM_VALUE = 5;
9411       /**
9412        * <code>EVENTED_BOOL = 6;</code>
9413        */
9414       public static final int EVENTED_BOOL_VALUE = 6;
9415
9416
9417       public final int getNumber() { return value; }
9418
9419       public static Type valueOf(int value) {
9420         switch (value) {
9421           case 1: return STRING;
9422           case 2: return NUM;
9423           case 3: return BOOL;
9424           case 4: return EVENTED_STRING;
9425           case 5: return EVENTED_NUM;
9426           case 6: return EVENTED_BOOL;
9427           default: return null;
9428         }
9429       }
9430
9431       public static com.google.protobuf.Internal.EnumLiteMap<Type>
9432           internalGetValueMap() {
9433         return internalValueMap;
9434       }
9435       private static com.google.protobuf.Internal.EnumLiteMap<Type>
9436           internalValueMap =
9437             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
9438               public Type findValueByNumber(int number) {
9439                 return Type.valueOf(number);
9440               }
9441             };
9442
9443       public final com.google.protobuf.Descriptors.EnumValueDescriptor
9444           getValueDescriptor() {
9445         return getDescriptor().getValues().get(index);
9446       }
9447       public final com.google.protobuf.Descriptors.EnumDescriptor
9448           getDescriptorForType() {
9449         return getDescriptor();
9450       }
9451       public static final com.google.protobuf.Descriptors.EnumDescriptor
9452           getDescriptor() {
9453         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
9454       }
9455
9456       private static final Type[] VALUES = values();
9457
9458       public static Type valueOf(
9459           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
9460         if (desc.getType() != getDescriptor()) {
9461           throw new java.lang.IllegalArgumentException(
9462             "EnumValueDescriptor is not for this type.");
9463         }
9464         return VALUES[desc.getIndex()];
9465       }
9466
9467       private final int index;
9468       private final int value;
9469
9470       private Type(int index, int value) {
9471         this.index = index;
9472         this.value = value;
9473       }
9474
9475       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
9476     }
9477
9478     private int bitField0_;
9479     // optional .openxc.TranslatedMessage.Type type = 1;
9480     public static final int TYPE_FIELD_NUMBER = 1;
9481     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
9482     /**
9483      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9484      */
9485     public boolean hasType() {
9486       return ((bitField0_ & 0x00000001) == 0x00000001);
9487     }
9488     /**
9489      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9490      */
9491     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
9492       return type_;
9493     }
9494
9495     // optional string name = 2;
9496     public static final int NAME_FIELD_NUMBER = 2;
9497     private java.lang.Object name_;
9498     /**
9499      * <code>optional string name = 2;</code>
9500      */
9501     public boolean hasName() {
9502       return ((bitField0_ & 0x00000002) == 0x00000002);
9503     }
9504     /**
9505      * <code>optional string name = 2;</code>
9506      */
9507     public java.lang.String getName() {
9508       java.lang.Object ref = name_;
9509       if (ref instanceof java.lang.String) {
9510         return (java.lang.String) ref;
9511       } else {
9512         com.google.protobuf.ByteString bs =
9513             (com.google.protobuf.ByteString) ref;
9514         java.lang.String s = bs.toStringUtf8();
9515         if (bs.isValidUtf8()) {
9516           name_ = s;
9517         }
9518         return s;
9519       }
9520     }
9521     /**
9522      * <code>optional string name = 2;</code>
9523      */
9524     public com.google.protobuf.ByteString
9525         getNameBytes() {
9526       java.lang.Object ref = name_;
9527       if (ref instanceof java.lang.String) {
9528         com.google.protobuf.ByteString b =
9529             com.google.protobuf.ByteString.copyFromUtf8(
9530                 (java.lang.String) ref);
9531         name_ = b;
9532         return b;
9533       } else {
9534         return (com.google.protobuf.ByteString) ref;
9535       }
9536     }
9537
9538     // optional .openxc.DynamicField value = 3;
9539     public static final int VALUE_FIELD_NUMBER = 3;
9540     private com.openxc.BinaryMessages.DynamicField value_;
9541     /**
9542      * <code>optional .openxc.DynamicField value = 3;</code>
9543      */
9544     public boolean hasValue() {
9545       return ((bitField0_ & 0x00000004) == 0x00000004);
9546     }
9547     /**
9548      * <code>optional .openxc.DynamicField value = 3;</code>
9549      */
9550     public com.openxc.BinaryMessages.DynamicField getValue() {
9551       return value_;
9552     }
9553     /**
9554      * <code>optional .openxc.DynamicField value = 3;</code>
9555      */
9556     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
9557       return value_;
9558     }
9559
9560     // optional .openxc.DynamicField event = 4;
9561     public static final int EVENT_FIELD_NUMBER = 4;
9562     private com.openxc.BinaryMessages.DynamicField event_;
9563     /**
9564      * <code>optional .openxc.DynamicField event = 4;</code>
9565      */
9566     public boolean hasEvent() {
9567       return ((bitField0_ & 0x00000008) == 0x00000008);
9568     }
9569     /**
9570      * <code>optional .openxc.DynamicField event = 4;</code>
9571      */
9572     public com.openxc.BinaryMessages.DynamicField getEvent() {
9573       return event_;
9574     }
9575     /**
9576      * <code>optional .openxc.DynamicField event = 4;</code>
9577      */
9578     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
9579       return event_;
9580     }
9581
9582     private void initFields() {
9583       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
9584       name_ = "";
9585       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
9586       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
9587     }
9588     private byte memoizedIsInitialized = -1;
9589     public final boolean isInitialized() {
9590       byte isInitialized = memoizedIsInitialized;
9591       if (isInitialized != -1) return isInitialized == 1;
9592
9593       memoizedIsInitialized = 1;
9594       return true;
9595     }
9596
9597     public void writeTo(com.google.protobuf.CodedOutputStream output)
9598                         throws java.io.IOException {
9599       getSerializedSize();
9600       if (((bitField0_ & 0x00000001) == 0x00000001)) {
9601         output.writeEnum(1, type_.getNumber());
9602       }
9603       if (((bitField0_ & 0x00000002) == 0x00000002)) {
9604         output.writeBytes(2, getNameBytes());
9605       }
9606       if (((bitField0_ & 0x00000004) == 0x00000004)) {
9607         output.writeMessage(3, value_);
9608       }
9609       if (((bitField0_ & 0x00000008) == 0x00000008)) {
9610         output.writeMessage(4, event_);
9611       }
9612       getUnknownFields().writeTo(output);
9613     }
9614
9615     private int memoizedSerializedSize = -1;
9616     public int getSerializedSize() {
9617       int size = memoizedSerializedSize;
9618       if (size != -1) return size;
9619
9620       size = 0;
9621       if (((bitField0_ & 0x00000001) == 0x00000001)) {
9622         size += com.google.protobuf.CodedOutputStream
9623           .computeEnumSize(1, type_.getNumber());
9624       }
9625       if (((bitField0_ & 0x00000002) == 0x00000002)) {
9626         size += com.google.protobuf.CodedOutputStream
9627           .computeBytesSize(2, getNameBytes());
9628       }
9629       if (((bitField0_ & 0x00000004) == 0x00000004)) {
9630         size += com.google.protobuf.CodedOutputStream
9631           .computeMessageSize(3, value_);
9632       }
9633       if (((bitField0_ & 0x00000008) == 0x00000008)) {
9634         size += com.google.protobuf.CodedOutputStream
9635           .computeMessageSize(4, event_);
9636       }
9637       size += getUnknownFields().getSerializedSize();
9638       memoizedSerializedSize = size;
9639       return size;
9640     }
9641
9642     private static final long serialVersionUID = 0L;
9643     @java.lang.Override
9644     protected java.lang.Object writeReplace()
9645         throws java.io.ObjectStreamException {
9646       return super.writeReplace();
9647     }
9648
9649     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
9650         com.google.protobuf.ByteString data)
9651         throws com.google.protobuf.InvalidProtocolBufferException {
9652       return PARSER.parseFrom(data);
9653     }
9654     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
9655         com.google.protobuf.ByteString data,
9656         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9657         throws com.google.protobuf.InvalidProtocolBufferException {
9658       return PARSER.parseFrom(data, extensionRegistry);
9659     }
9660     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
9661         throws com.google.protobuf.InvalidProtocolBufferException {
9662       return PARSER.parseFrom(data);
9663     }
9664     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
9665         byte[] data,
9666         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9667         throws com.google.protobuf.InvalidProtocolBufferException {
9668       return PARSER.parseFrom(data, extensionRegistry);
9669     }
9670     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
9671         throws java.io.IOException {
9672       return PARSER.parseFrom(input);
9673     }
9674     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
9675         java.io.InputStream input,
9676         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9677         throws java.io.IOException {
9678       return PARSER.parseFrom(input, extensionRegistry);
9679     }
9680     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
9681         throws java.io.IOException {
9682       return PARSER.parseDelimitedFrom(input);
9683     }
9684     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
9685         java.io.InputStream input,
9686         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9687         throws java.io.IOException {
9688       return PARSER.parseDelimitedFrom(input, extensionRegistry);
9689     }
9690     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
9691         com.google.protobuf.CodedInputStream input)
9692         throws java.io.IOException {
9693       return PARSER.parseFrom(input);
9694     }
9695     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
9696         com.google.protobuf.CodedInputStream input,
9697         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9698         throws java.io.IOException {
9699       return PARSER.parseFrom(input, extensionRegistry);
9700     }
9701
9702     public static Builder newBuilder() { return Builder.create(); }
9703     public Builder newBuilderForType() { return newBuilder(); }
9704     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
9705       return newBuilder().mergeFrom(prototype);
9706     }
9707     public Builder toBuilder() { return newBuilder(this); }
9708
9709     @java.lang.Override
9710     protected Builder newBuilderForType(
9711         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
9712       Builder builder = new Builder(parent);
9713       return builder;
9714     }
9715     /**
9716      * Protobuf type {@code openxc.TranslatedMessage}
9717      */
9718     public static final class Builder extends
9719         com.google.protobuf.GeneratedMessage.Builder<Builder>
9720        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
9721       public static final com.google.protobuf.Descriptors.Descriptor
9722           getDescriptor() {
9723         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
9724       }
9725
9726       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
9727           internalGetFieldAccessorTable() {
9728         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
9729             .ensureFieldAccessorsInitialized(
9730                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
9731       }
9732
9733       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
9734       private Builder() {
9735         maybeForceBuilderInitialization();
9736       }
9737
9738       private Builder(
9739           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
9740         super(parent);
9741         maybeForceBuilderInitialization();
9742       }
9743       private void maybeForceBuilderInitialization() {
9744         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
9745           getValueFieldBuilder();
9746           getEventFieldBuilder();
9747         }
9748       }
9749       private static Builder create() {
9750         return new Builder();
9751       }
9752
9753       public Builder clear() {
9754         super.clear();
9755         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
9756         bitField0_ = (bitField0_ & ~0x00000001);
9757         name_ = "";
9758         bitField0_ = (bitField0_ & ~0x00000002);
9759         if (valueBuilder_ == null) {
9760           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
9761         } else {
9762           valueBuilder_.clear();
9763         }
9764         bitField0_ = (bitField0_ & ~0x00000004);
9765         if (eventBuilder_ == null) {
9766           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
9767         } else {
9768           eventBuilder_.clear();
9769         }
9770         bitField0_ = (bitField0_ & ~0x00000008);
9771         return this;
9772       }
9773
9774       public Builder clone() {
9775         return create().mergeFrom(buildPartial());
9776       }
9777
9778       public com.google.protobuf.Descriptors.Descriptor
9779           getDescriptorForType() {
9780         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
9781       }
9782
9783       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
9784         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
9785       }
9786
9787       public com.openxc.BinaryMessages.TranslatedMessage build() {
9788         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
9789         if (!result.isInitialized()) {
9790           throw newUninitializedMessageException(result);
9791         }
9792         return result;
9793       }
9794
9795       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
9796         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
9797         int from_bitField0_ = bitField0_;
9798         int to_bitField0_ = 0;
9799         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
9800           to_bitField0_ |= 0x00000001;
9801         }
9802         result.type_ = type_;
9803         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
9804           to_bitField0_ |= 0x00000002;
9805         }
9806         result.name_ = name_;
9807         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
9808           to_bitField0_ |= 0x00000004;
9809         }
9810         if (valueBuilder_ == null) {
9811           result.value_ = value_;
9812         } else {
9813           result.value_ = valueBuilder_.build();
9814         }
9815         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
9816           to_bitField0_ |= 0x00000008;
9817         }
9818         if (eventBuilder_ == null) {
9819           result.event_ = event_;
9820         } else {
9821           result.event_ = eventBuilder_.build();
9822         }
9823         result.bitField0_ = to_bitField0_;
9824         onBuilt();
9825         return result;
9826       }
9827
9828       public Builder mergeFrom(com.google.protobuf.Message other) {
9829         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
9830           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
9831         } else {
9832           super.mergeFrom(other);
9833           return this;
9834         }
9835       }
9836
9837       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
9838         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
9839         if (other.hasType()) {
9840           setType(other.getType());
9841         }
9842         if (other.hasName()) {
9843           bitField0_ |= 0x00000002;
9844           name_ = other.name_;
9845           onChanged();
9846         }
9847         if (other.hasValue()) {
9848           mergeValue(other.getValue());
9849         }
9850         if (other.hasEvent()) {
9851           mergeEvent(other.getEvent());
9852         }
9853         this.mergeUnknownFields(other.getUnknownFields());
9854         return this;
9855       }
9856
9857       public final boolean isInitialized() {
9858         return true;
9859       }
9860
9861       public Builder mergeFrom(
9862           com.google.protobuf.CodedInputStream input,
9863           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
9864           throws java.io.IOException {
9865         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
9866         try {
9867           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
9868         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
9869           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
9870           throw e;
9871         } finally {
9872           if (parsedMessage != null) {
9873             mergeFrom(parsedMessage);
9874           }
9875         }
9876         return this;
9877       }
9878       private int bitField0_;
9879
9880       // optional .openxc.TranslatedMessage.Type type = 1;
9881       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
9882       /**
9883        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9884        */
9885       public boolean hasType() {
9886         return ((bitField0_ & 0x00000001) == 0x00000001);
9887       }
9888       /**
9889        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9890        */
9891       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
9892         return type_;
9893       }
9894       /**
9895        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9896        */
9897       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
9898         if (value == null) {
9899           throw new NullPointerException();
9900         }
9901         bitField0_ |= 0x00000001;
9902         type_ = value;
9903         onChanged();
9904         return this;
9905       }
9906       /**
9907        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
9908        */
9909       public Builder clearType() {
9910         bitField0_ = (bitField0_ & ~0x00000001);
9911         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
9912         onChanged();
9913         return this;
9914       }
9915
9916       // optional string name = 2;
9917       private java.lang.Object name_ = "";
9918       /**
9919        * <code>optional string name = 2;</code>
9920        */
9921       public boolean hasName() {
9922         return ((bitField0_ & 0x00000002) == 0x00000002);
9923       }
9924       /**
9925        * <code>optional string name = 2;</code>
9926        */
9927       public java.lang.String getName() {
9928         java.lang.Object ref = name_;
9929         if (!(ref instanceof java.lang.String)) {
9930           java.lang.String s = ((com.google.protobuf.ByteString) ref)
9931               .toStringUtf8();
9932           name_ = s;
9933           return s;
9934         } else {
9935           return (java.lang.String) ref;
9936         }
9937       }
9938       /**
9939        * <code>optional string name = 2;</code>
9940        */
9941       public com.google.protobuf.ByteString
9942           getNameBytes() {
9943         java.lang.Object ref = name_;
9944         if (ref instanceof String) {
9945           com.google.protobuf.ByteString b =
9946               com.google.protobuf.ByteString.copyFromUtf8(
9947                   (java.lang.String) ref);
9948           name_ = b;
9949           return b;
9950         } else {
9951           return (com.google.protobuf.ByteString) ref;
9952         }
9953       }
9954       /**
9955        * <code>optional string name = 2;</code>
9956        */
9957       public Builder setName(
9958           java.lang.String value) {
9959         if (value == null) {
9960     throw new NullPointerException();
9961   }
9962   bitField0_ |= 0x00000002;
9963         name_ = value;
9964         onChanged();
9965         return this;
9966       }
9967       /**
9968        * <code>optional string name = 2;</code>
9969        */
9970       public Builder clearName() {
9971         bitField0_ = (bitField0_ & ~0x00000002);
9972         name_ = getDefaultInstance().getName();
9973         onChanged();
9974         return this;
9975       }
9976       /**
9977        * <code>optional string name = 2;</code>
9978        */
9979       public Builder setNameBytes(
9980           com.google.protobuf.ByteString value) {
9981         if (value == null) {
9982     throw new NullPointerException();
9983   }
9984   bitField0_ |= 0x00000002;
9985         name_ = value;
9986         onChanged();
9987         return this;
9988       }
9989
9990       // optional .openxc.DynamicField value = 3;
9991       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
9992       private com.google.protobuf.SingleFieldBuilder<
9993           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
9994       /**
9995        * <code>optional .openxc.DynamicField value = 3;</code>
9996        */
9997       public boolean hasValue() {
9998         return ((bitField0_ & 0x00000004) == 0x00000004);
9999       }
10000       /**
10001        * <code>optional .openxc.DynamicField value = 3;</code>
10002        */
10003       public com.openxc.BinaryMessages.DynamicField getValue() {
10004         if (valueBuilder_ == null) {
10005           return value_;
10006         } else {
10007           return valueBuilder_.getMessage();
10008         }
10009       }
10010       /**
10011        * <code>optional .openxc.DynamicField value = 3;</code>
10012        */
10013       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
10014         if (valueBuilder_ == null) {
10015           if (value == null) {
10016             throw new NullPointerException();
10017           }
10018           value_ = value;
10019           onChanged();
10020         } else {
10021           valueBuilder_.setMessage(value);
10022         }
10023         bitField0_ |= 0x00000004;
10024         return this;
10025       }
10026       /**
10027        * <code>optional .openxc.DynamicField value = 3;</code>
10028        */
10029       public Builder setValue(
10030           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
10031         if (valueBuilder_ == null) {
10032           value_ = builderForValue.build();
10033           onChanged();
10034         } else {
10035           valueBuilder_.setMessage(builderForValue.build());
10036         }
10037         bitField0_ |= 0x00000004;
10038         return this;
10039       }
10040       /**
10041        * <code>optional .openxc.DynamicField value = 3;</code>
10042        */
10043       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
10044         if (valueBuilder_ == null) {
10045           if (((bitField0_ & 0x00000004) == 0x00000004) &&
10046               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
10047             value_ =
10048               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
10049           } else {
10050             value_ = value;
10051           }
10052           onChanged();
10053         } else {
10054           valueBuilder_.mergeFrom(value);
10055         }
10056         bitField0_ |= 0x00000004;
10057         return this;
10058       }
10059       /**
10060        * <code>optional .openxc.DynamicField value = 3;</code>
10061        */
10062       public Builder clearValue() {
10063         if (valueBuilder_ == null) {
10064           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10065           onChanged();
10066         } else {
10067           valueBuilder_.clear();
10068         }
10069         bitField0_ = (bitField0_ & ~0x00000004);
10070         return this;
10071       }
10072       /**
10073        * <code>optional .openxc.DynamicField value = 3;</code>
10074        */
10075       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
10076         bitField0_ |= 0x00000004;
10077         onChanged();
10078         return getValueFieldBuilder().getBuilder();
10079       }
10080       /**
10081        * <code>optional .openxc.DynamicField value = 3;</code>
10082        */
10083       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
10084         if (valueBuilder_ != null) {
10085           return valueBuilder_.getMessageOrBuilder();
10086         } else {
10087           return value_;
10088         }
10089       }
10090       /**
10091        * <code>optional .openxc.DynamicField value = 3;</code>
10092        */
10093       private com.google.protobuf.SingleFieldBuilder<
10094           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
10095           getValueFieldBuilder() {
10096         if (valueBuilder_ == null) {
10097           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
10098               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
10099                   value_,
10100                   getParentForChildren(),
10101                   isClean());
10102           value_ = null;
10103         }
10104         return valueBuilder_;
10105       }
10106
10107       // optional .openxc.DynamicField event = 4;
10108       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10109       private com.google.protobuf.SingleFieldBuilder<
10110           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
10111       /**
10112        * <code>optional .openxc.DynamicField event = 4;</code>
10113        */
10114       public boolean hasEvent() {
10115         return ((bitField0_ & 0x00000008) == 0x00000008);
10116       }
10117       /**
10118        * <code>optional .openxc.DynamicField event = 4;</code>
10119        */
10120       public com.openxc.BinaryMessages.DynamicField getEvent() {
10121         if (eventBuilder_ == null) {
10122           return event_;
10123         } else {
10124           return eventBuilder_.getMessage();
10125         }
10126       }
10127       /**
10128        * <code>optional .openxc.DynamicField event = 4;</code>
10129        */
10130       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
10131         if (eventBuilder_ == null) {
10132           if (value == null) {
10133             throw new NullPointerException();
10134           }
10135           event_ = value;
10136           onChanged();
10137         } else {
10138           eventBuilder_.setMessage(value);
10139         }
10140         bitField0_ |= 0x00000008;
10141         return this;
10142       }
10143       /**
10144        * <code>optional .openxc.DynamicField event = 4;</code>
10145        */
10146       public Builder setEvent(
10147           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
10148         if (eventBuilder_ == null) {
10149           event_ = builderForValue.build();
10150           onChanged();
10151         } else {
10152           eventBuilder_.setMessage(builderForValue.build());
10153         }
10154         bitField0_ |= 0x00000008;
10155         return this;
10156       }
10157       /**
10158        * <code>optional .openxc.DynamicField event = 4;</code>
10159        */
10160       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
10161         if (eventBuilder_ == null) {
10162           if (((bitField0_ & 0x00000008) == 0x00000008) &&
10163               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
10164             event_ =
10165               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
10166           } else {
10167             event_ = value;
10168           }
10169           onChanged();
10170         } else {
10171           eventBuilder_.mergeFrom(value);
10172         }
10173         bitField0_ |= 0x00000008;
10174         return this;
10175       }
10176       /**
10177        * <code>optional .openxc.DynamicField event = 4;</code>
10178        */
10179       public Builder clearEvent() {
10180         if (eventBuilder_ == null) {
10181           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
10182           onChanged();
10183         } else {
10184           eventBuilder_.clear();
10185         }
10186         bitField0_ = (bitField0_ & ~0x00000008);
10187         return this;
10188       }
10189       /**
10190        * <code>optional .openxc.DynamicField event = 4;</code>
10191        */
10192       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
10193         bitField0_ |= 0x00000008;
10194         onChanged();
10195         return getEventFieldBuilder().getBuilder();
10196       }
10197       /**
10198        * <code>optional .openxc.DynamicField event = 4;</code>
10199        */
10200       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
10201         if (eventBuilder_ != null) {
10202           return eventBuilder_.getMessageOrBuilder();
10203         } else {
10204           return event_;
10205         }
10206       }
10207       /**
10208        * <code>optional .openxc.DynamicField event = 4;</code>
10209        */
10210       private com.google.protobuf.SingleFieldBuilder<
10211           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
10212           getEventFieldBuilder() {
10213         if (eventBuilder_ == null) {
10214           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
10215               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
10216                   event_,
10217                   getParentForChildren(),
10218                   isClean());
10219           event_ = null;
10220         }
10221         return eventBuilder_;
10222       }
10223
10224       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
10225     }
10226
10227     static {
10228       defaultInstance = new TranslatedMessage(true);
10229       defaultInstance.initFields();
10230     }
10231
10232     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
10233   }
10234
10235   private static com.google.protobuf.Descriptors.Descriptor
10236     internal_static_openxc_VehicleMessage_descriptor;
10237   private static
10238     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10239       internal_static_openxc_VehicleMessage_fieldAccessorTable;
10240   private static com.google.protobuf.Descriptors.Descriptor
10241     internal_static_openxc_RawMessage_descriptor;
10242   private static
10243     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10244       internal_static_openxc_RawMessage_fieldAccessorTable;
10245   private static com.google.protobuf.Descriptors.Descriptor
10246     internal_static_openxc_ControlCommand_descriptor;
10247   private static
10248     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10249       internal_static_openxc_ControlCommand_fieldAccessorTable;
10250   private static com.google.protobuf.Descriptors.Descriptor
10251     internal_static_openxc_DiagnosticControlCommand_descriptor;
10252   private static
10253     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10254       internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable;
10255   private static com.google.protobuf.Descriptors.Descriptor
10256     internal_static_openxc_PassthroughModeControlCommand_descriptor;
10257   private static
10258     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10259       internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable;
10260   private static com.google.protobuf.Descriptors.Descriptor
10261     internal_static_openxc_AcceptanceFilterBypassCommand_descriptor;
10262   private static
10263     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10264       internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable;
10265   private static com.google.protobuf.Descriptors.Descriptor
10266     internal_static_openxc_PayloadFormatCommand_descriptor;
10267   private static
10268     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10269       internal_static_openxc_PayloadFormatCommand_fieldAccessorTable;
10270   private static com.google.protobuf.Descriptors.Descriptor
10271     internal_static_openxc_CommandResponse_descriptor;
10272   private static
10273     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10274       internal_static_openxc_CommandResponse_fieldAccessorTable;
10275   private static com.google.protobuf.Descriptors.Descriptor
10276     internal_static_openxc_DiagnosticRequest_descriptor;
10277   private static
10278     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10279       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
10280   private static com.google.protobuf.Descriptors.Descriptor
10281     internal_static_openxc_DiagnosticResponse_descriptor;
10282   private static
10283     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10284       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
10285   private static com.google.protobuf.Descriptors.Descriptor
10286     internal_static_openxc_DynamicField_descriptor;
10287   private static
10288     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10289       internal_static_openxc_DynamicField_fieldAccessorTable;
10290   private static com.google.protobuf.Descriptors.Descriptor
10291     internal_static_openxc_TranslatedMessage_descriptor;
10292   private static
10293     com.google.protobuf.GeneratedMessage.FieldAccessorTable
10294       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
10295
10296   public static com.google.protobuf.Descriptors.FileDescriptor
10297       getDescriptor() {
10298     return descriptor;
10299   }
10300   private static com.google.protobuf.Descriptors.FileDescriptor
10301       descriptor;
10302   static {
10303     java.lang.String[] descriptorData = {
10304       "\n\014openxc.proto\022\006openxc\"\224\003\n\016VehicleMessag" +
10305       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
10306       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
10307       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
10308       "xc.TranslatedMessage\0227\n\023diagnostic_respo" +
10309       "nse\030\004 \001(\0132\032.openxc.DiagnosticResponse\022/\n" +
10310       "\017control_command\030\005 \001(\0132\026.openxc.ControlC" +
10311       "ommand\0221\n\020command_response\030\006 \001(\0132\027.openx" +
10312       "c.CommandResponse\"Z\n\004Type\022\007\n\003RAW\020\001\022\016\n\nTR" +
10313       "ANSLATED\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CONTROL_CO",
10314       "MMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\";\n\nRawMess" +
10315       "age\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004" +
10316       "data\030\003 \001(\014\"\310\003\n\016ControlCommand\022)\n\004type\030\001 " +
10317       "\001(\0162\033.openxc.ControlCommand.Type\022<\n\022diag" +
10318       "nostic_request\030\002 \001(\0132 .openxc.Diagnostic" +
10319       "ControlCommand\022G\n\030passthrough_mode_reque" +
10320       "st\030\003 \001(\0132%.openxc.PassthroughModeControl" +
10321       "Command\022O\n acceptance_filter_bypass_comm" +
10322       "and\030\004 \001(\0132%.openxc.AcceptanceFilterBypas" +
10323       "sCommand\022<\n\026payload_format_command\030\005 \001(\013",
10324       "2\034.openxc.PayloadFormatCommand\"u\n\004Type\022\013" +
10325       "\n\007VERSION\020\001\022\r\n\tDEVICE_ID\020\002\022\016\n\nDIAGNOSTIC" +
10326       "\020\003\022\017\n\013PASSTHROUGH\020\004\022\034\n\030ACCEPTANCE_FILTER" +
10327       "_BYPASS\020\005\022\022\n\016PAYLOAD_FORMAT\020\006\"\236\001\n\030Diagno" +
10328       "sticControlCommand\022*\n\007request\030\001 \001(\0132\031.op" +
10329       "enxc.DiagnosticRequest\0227\n\006action\030\002 \001(\0162\'" +
10330       ".openxc.DiagnosticControlCommand.Action\"" +
10331       "\035\n\006Action\022\007\n\003ADD\020\001\022\n\n\006CANCEL\020\002\"=\n\035Passth" +
10332       "roughModeControlCommand\022\013\n\003bus\030\001 \001(\005\022\017\n\007" +
10333       "enabled\030\002 \001(\010\"<\n\035AcceptanceFilterBypassC",
10334       "ommand\022\013\n\003bus\030\001 \001(\005\022\016\n\006bypass\030\002 \001(\010\"{\n\024P" +
10335       "ayloadFormatCommand\022:\n\006format\030\001 \001(\0162*.op" +
10336       "enxc.PayloadFormatCommand.PayloadFormat\"" +
10337       "\'\n\rPayloadFormat\022\010\n\004JSON\020\001\022\014\n\010PROTOBUF\020\002" +
10338       "\"]\n\017CommandResponse\022)\n\004type\030\001 \001(\0162\033.open" +
10339       "xc.ControlCommand.Type\022\017\n\007message\030\002 \001(\t\022" +
10340       "\016\n\006status\030\003 \001(\010\"\375\001\n\021DiagnosticRequest\022\013\n" +
10341       "\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mode\030\003" +
10342       " \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007payload\030\005 \001(\014\022\032\n\022mu" +
10343       "ltiple_responses\030\006 \001(\010\022\021\n\tfrequency\030\007 \001(",
10344       "\001\022\014\n\004name\030\010 \001(\t\022;\n\014decoded_type\030\t \001(\0162%." +
10345       "openxc.DiagnosticRequest.DecodedType\"!\n\013" +
10346       "DecodedType\022\010\n\004NONE\020\001\022\010\n\004OBD2\020\002\"\241\001\n\022Diag" +
10347       "nosticResponse\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_i" +
10348       "d\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007su" +
10349       "ccess\030\005 \001(\010\022\036\n\026negative_response_code\030\006 " +
10350       "\001(\r\022\017\n\007payload\030\007 \001(\014\022\r\n\005value\030\010 \001(\001\"\242\001\n\014" +
10351       "DynamicField\022\'\n\004type\030\001 \001(\0162\031.openxc.Dyna" +
10352       "micField.Type\022\024\n\014string_value\030\002 \001(\t\022\025\n\rn" +
10353       "umeric_value\030\003 \001(\001\022\025\n\rboolean_value\030\004 \001(",
10354       "\010\"%\n\004Type\022\n\n\006STRING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003" +
10355       "\"\367\001\n\021TranslatedMessage\022,\n\004type\030\001 \001(\0162\036.o" +
10356       "penxc.TranslatedMessage.Type\022\014\n\004name\030\002 \001" +
10357       "(\t\022#\n\005value\030\003 \001(\0132\024.openxc.DynamicField\022" +
10358       "#\n\005event\030\004 \001(\0132\024.openxc.DynamicField\"\\\n\004" +
10359       "Type\022\n\n\006STRING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\022\022\n\016E" +
10360       "VENTED_STRING\020\004\022\017\n\013EVENTED_NUM\020\005\022\020\n\014EVEN" +
10361       "TED_BOOL\020\006B\034\n\ncom.openxcB\016BinaryMessages"
10362     };
10363     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
10364       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
10365         public com.google.protobuf.ExtensionRegistry assignDescriptors(
10366             com.google.protobuf.Descriptors.FileDescriptor root) {
10367           descriptor = root;
10368           internal_static_openxc_VehicleMessage_descriptor =
10369             getDescriptor().getMessageTypes().get(0);
10370           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
10371             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10372               internal_static_openxc_VehicleMessage_descriptor,
10373               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", });
10374           internal_static_openxc_RawMessage_descriptor =
10375             getDescriptor().getMessageTypes().get(1);
10376           internal_static_openxc_RawMessage_fieldAccessorTable = new
10377             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10378               internal_static_openxc_RawMessage_descriptor,
10379               new java.lang.String[] { "Bus", "MessageId", "Data", });
10380           internal_static_openxc_ControlCommand_descriptor =
10381             getDescriptor().getMessageTypes().get(2);
10382           internal_static_openxc_ControlCommand_fieldAccessorTable = new
10383             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10384               internal_static_openxc_ControlCommand_descriptor,
10385               new java.lang.String[] { "Type", "DiagnosticRequest", "PassthroughModeRequest", "AcceptanceFilterBypassCommand", "PayloadFormatCommand", });
10386           internal_static_openxc_DiagnosticControlCommand_descriptor =
10387             getDescriptor().getMessageTypes().get(3);
10388           internal_static_openxc_DiagnosticControlCommand_fieldAccessorTable = new
10389             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10390               internal_static_openxc_DiagnosticControlCommand_descriptor,
10391               new java.lang.String[] { "Request", "Action", });
10392           internal_static_openxc_PassthroughModeControlCommand_descriptor =
10393             getDescriptor().getMessageTypes().get(4);
10394           internal_static_openxc_PassthroughModeControlCommand_fieldAccessorTable = new
10395             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10396               internal_static_openxc_PassthroughModeControlCommand_descriptor,
10397               new java.lang.String[] { "Bus", "Enabled", });
10398           internal_static_openxc_AcceptanceFilterBypassCommand_descriptor =
10399             getDescriptor().getMessageTypes().get(5);
10400           internal_static_openxc_AcceptanceFilterBypassCommand_fieldAccessorTable = new
10401             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10402               internal_static_openxc_AcceptanceFilterBypassCommand_descriptor,
10403               new java.lang.String[] { "Bus", "Bypass", });
10404           internal_static_openxc_PayloadFormatCommand_descriptor =
10405             getDescriptor().getMessageTypes().get(6);
10406           internal_static_openxc_PayloadFormatCommand_fieldAccessorTable = new
10407             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10408               internal_static_openxc_PayloadFormatCommand_descriptor,
10409               new java.lang.String[] { "Format", });
10410           internal_static_openxc_CommandResponse_descriptor =
10411             getDescriptor().getMessageTypes().get(7);
10412           internal_static_openxc_CommandResponse_fieldAccessorTable = new
10413             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10414               internal_static_openxc_CommandResponse_descriptor,
10415               new java.lang.String[] { "Type", "Message", "Status", });
10416           internal_static_openxc_DiagnosticRequest_descriptor =
10417             getDescriptor().getMessageTypes().get(8);
10418           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
10419             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10420               internal_static_openxc_DiagnosticRequest_descriptor,
10421               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Frequency", "Name", "DecodedType", });
10422           internal_static_openxc_DiagnosticResponse_descriptor =
10423             getDescriptor().getMessageTypes().get(9);
10424           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
10425             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10426               internal_static_openxc_DiagnosticResponse_descriptor,
10427               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", });
10428           internal_static_openxc_DynamicField_descriptor =
10429             getDescriptor().getMessageTypes().get(10);
10430           internal_static_openxc_DynamicField_fieldAccessorTable = new
10431             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10432               internal_static_openxc_DynamicField_descriptor,
10433               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", });
10434           internal_static_openxc_TranslatedMessage_descriptor =
10435             getDescriptor().getMessageTypes().get(11);
10436           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
10437             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
10438               internal_static_openxc_TranslatedMessage_descriptor,
10439               new java.lang.String[] { "Type", "Name", "Value", "Event", });
10440           return null;
10441         }
10442       };
10443     com.google.protobuf.Descriptors.FileDescriptor
10444       .internalBuildGeneratedFileFrom(descriptorData,
10445         new com.google.protobuf.Descriptors.FileDescriptor[] {
10446         }, assigner);
10447   }
10448
10449   // @@protoc_insertion_point(outer_class_scope)
10450 }