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