gen/java/com/openxc/BinaryMessages.java

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: openxc.proto
   3
   4 package com.openxc;
   5
   6 public final class BinaryMessages {
   7   private BinaryMessages() {}
   8   public static void registerAllExtensions(
   9       com.google.protobuf.ExtensionRegistry registry) {
  10   }
  11   public interface VehicleMessageOrBuilder
  12       extends com.google.protobuf.MessageOrBuilder {
  13
  14     // optional .openxc.VehicleMessage.Type type = 1;
  15     /**
  16      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
  17      */
  18     boolean hasType();
  19     /**
  20      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
  21      */
  22     com.openxc.BinaryMessages.VehicleMessage.Type getType();
  23
  24     // optional .openxc.RawMessage raw_message = 2;
  25     /**
  26      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  27      */
  28     boolean hasRawMessage();
  29     /**
  30      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  31      */
  32     com.openxc.BinaryMessages.RawMessage getRawMessage();
  33     /**
  34      * <code>optional .openxc.RawMessage raw_message = 2;</code>
  35      */
  36     com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder();
  37
  38     // optional .openxc.TranslatedMessage translated_message = 3;
  39     /**
  40      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  41      */
  42     boolean hasTranslatedMessage();
  43     /**
  44      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  45      */
  46     com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage();
  47     /**
  48      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
  49      */
  50     com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder();
  51
  52     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
  53     /**
  54      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  55      */
  56     boolean hasDiagnosticResponse();
  57     /**
  58      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  59      */
  60     com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse();
  61     /**
  62      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
  63      */
  64     com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder();
  65
  66     // optional .openxc.ControlCommand control_command = 5;
  67     /**
  68      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  69      */
  70     boolean hasControlCommand();
  71     /**
  72      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  73      */
  74     com.openxc.BinaryMessages.ControlCommand getControlCommand();
  75     /**
  76      * <code>optional .openxc.ControlCommand control_command = 5;</code>
  77      */
  78     com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder();
  79
  80     // optional .openxc.CommandResponse command_response = 6;
  81     /**
  82      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  83      */
  84     boolean hasCommandResponse();
  85     /**
  86      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  87      */
  88     com.openxc.BinaryMessages.CommandResponse getCommandResponse();
  89     /**
  90      * <code>optional .openxc.CommandResponse command_response = 6;</code>
  91      */
  92     com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder();
  93   }
  94   /**
  95    * Protobuf type {@code openxc.VehicleMessage}
  96    */
  97   public static final class VehicleMessage extends
  98       com.google.protobuf.GeneratedMessage
  99       implements VehicleMessageOrBuilder {
 100     // Use VehicleMessage.newBuilder() to construct.
 101     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 102       super(builder);
 103       this.unknownFields = builder.getUnknownFields();
 104     }
 105     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 106
 107     private static final VehicleMessage defaultInstance;
 108     public static VehicleMessage getDefaultInstance() {
 109       return defaultInstance;
 110     }
 111
 112     public VehicleMessage getDefaultInstanceForType() {
 113       return defaultInstance;
 114     }
 115
 116     private final com.google.protobuf.UnknownFieldSet unknownFields;
 117     @java.lang.Override
 118     public final com.google.protobuf.UnknownFieldSet
 119         getUnknownFields() {
 120       return this.unknownFields;
 121     }
 122     private VehicleMessage(
 123         com.google.protobuf.CodedInputStream input,
 124         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 125         throws com.google.protobuf.InvalidProtocolBufferException {
 126       initFields();
 127       int mutable_bitField0_ = 0;
 128       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 129           com.google.protobuf.UnknownFieldSet.newBuilder();
 130       try {
 131         boolean done = false;
 132         while (!done) {
 133           int tag = input.readTag();
 134           switch (tag) {
 135             case 0:
 136               done = true;
 137               break;
 138             default: {
 139               if (!parseUnknownField(input, unknownFields,
 140                                      extensionRegistry, tag)) {
 141                 done = true;
 142               }
 143               break;
 144             }
 145             case 8: {
 146               int rawValue = input.readEnum();
 147               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 148               if (value == null) {
 149                 unknownFields.mergeVarintField(1, rawValue);
 150               } else {
 151                 bitField0_ |= 0x00000001;
 152                 type_ = value;
 153               }
 154               break;
 155             }
 156             case 18: {
 157               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
 158               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 159                 subBuilder = rawMessage_.toBuilder();
 160               }
 161               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
 162               if (subBuilder != null) {
 163                 subBuilder.mergeFrom(rawMessage_);
 164                 rawMessage_ = subBuilder.buildPartial();
 165               }
 166               bitField0_ |= 0x00000002;
 167               break;
 168             }
 169             case 26: {
 170               com.openxc.BinaryMessages.TranslatedMessage.Builder subBuilder = null;
 171               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 172                 subBuilder = translatedMessage_.toBuilder();
 173               }
 174               translatedMessage_ = input.readMessage(com.openxc.BinaryMessages.TranslatedMessage.PARSER, extensionRegistry);
 175               if (subBuilder != null) {
 176                 subBuilder.mergeFrom(translatedMessage_);
 177                 translatedMessage_ = subBuilder.buildPartial();
 178               }
 179               bitField0_ |= 0x00000004;
 180               break;
 181             }
 182             case 34: {
 183               com.openxc.BinaryMessages.DiagnosticResponse.Builder subBuilder = null;
 184               if (((bitField0_ & 0x00000008) == 0x00000008)) {
 185                 subBuilder = diagnosticResponse_.toBuilder();
 186               }
 187               diagnosticResponse_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticResponse.PARSER, extensionRegistry);
 188               if (subBuilder != null) {
 189                 subBuilder.mergeFrom(diagnosticResponse_);
 190                 diagnosticResponse_ = subBuilder.buildPartial();
 191               }
 192               bitField0_ |= 0x00000008;
 193               break;
 194             }
 195             case 42: {
 196               com.openxc.BinaryMessages.ControlCommand.Builder subBuilder = null;
 197               if (((bitField0_ & 0x00000010) == 0x00000010)) {
 198                 subBuilder = controlCommand_.toBuilder();
 199               }
 200               controlCommand_ = input.readMessage(com.openxc.BinaryMessages.ControlCommand.PARSER, extensionRegistry);
 201               if (subBuilder != null) {
 202                 subBuilder.mergeFrom(controlCommand_);
 203                 controlCommand_ = subBuilder.buildPartial();
 204               }
 205               bitField0_ |= 0x00000010;
 206               break;
 207             }
 208             case 50: {
 209               com.openxc.BinaryMessages.CommandResponse.Builder subBuilder = null;
 210               if (((bitField0_ & 0x00000020) == 0x00000020)) {
 211                 subBuilder = commandResponse_.toBuilder();
 212               }
 213               commandResponse_ = input.readMessage(com.openxc.BinaryMessages.CommandResponse.PARSER, extensionRegistry);
 214               if (subBuilder != null) {
 215                 subBuilder.mergeFrom(commandResponse_);
 216                 commandResponse_ = subBuilder.buildPartial();
 217               }
 218               bitField0_ |= 0x00000020;
 219               break;
 220             }
 221           }
 222         }
 223       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 224         throw e.setUnfinishedMessage(this);
 225       } catch (java.io.IOException e) {
 226         throw new com.google.protobuf.InvalidProtocolBufferException(
 227             e.getMessage()).setUnfinishedMessage(this);
 228       } finally {
 229         this.unknownFields = unknownFields.build();
 230         makeExtensionsImmutable();
 231       }
 232     }
 233     public static final com.google.protobuf.Descriptors.Descriptor
 234         getDescriptor() {
 235       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 236     }
 237
 238     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 239         internalGetFieldAccessorTable() {
 240       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 241           .ensureFieldAccessorsInitialized(
 242               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 243     }
 244
 245     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 246         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 247       public VehicleMessage parsePartialFrom(
 248           com.google.protobuf.CodedInputStream input,
 249           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 250           throws com.google.protobuf.InvalidProtocolBufferException {
 251         return new VehicleMessage(input, extensionRegistry);
 252       }
 253     };
 254
 255     @java.lang.Override
 256     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 257       return PARSER;
 258     }
 259
 260     /**
 261      * Protobuf enum {@code openxc.VehicleMessage.Type}
 262      */
 263     public enum Type
 264         implements com.google.protobuf.ProtocolMessageEnum {
 265       /**
 266        * <code>RAW = 1;</code>
 267        */
 268       RAW(0, 1),
 269       /**
 270        * <code>TRANSLATED = 2;</code>
 271        */
 272       TRANSLATED(1, 2),
 273       /**
 274        * <code>DIAGNOSTIC = 3;</code>
 275        */
 276       DIAGNOSTIC(2, 3),
 277       /**
 278        * <code>CONTROL_COMMAND = 4;</code>
 279        */
 280       CONTROL_COMMAND(3, 4),
 281       /**
 282        * <code>COMMAND_RESPONSE = 5;</code>
 283        */
 284       COMMAND_RESPONSE(4, 5),
 285       ;
 286
 287       /**
 288        * <code>RAW = 1;</code>
 289        */
 290       public static final int RAW_VALUE = 1;
 291       /**
 292        * <code>TRANSLATED = 2;</code>
 293        */
 294       public static final int TRANSLATED_VALUE = 2;
 295       /**
 296        * <code>DIAGNOSTIC = 3;</code>
 297        */
 298       public static final int DIAGNOSTIC_VALUE = 3;
 299       /**
 300        * <code>CONTROL_COMMAND = 4;</code>
 301        */
 302       public static final int CONTROL_COMMAND_VALUE = 4;
 303       /**
 304        * <code>COMMAND_RESPONSE = 5;</code>
 305        */
 306       public static final int COMMAND_RESPONSE_VALUE = 5;
 307
 308
 309       public final int getNumber() { return value; }
 310
 311       public static Type valueOf(int value) {
 312         switch (value) {
 313           case 1: return RAW;
 314           case 2: return TRANSLATED;
 315           case 3: return DIAGNOSTIC;
 316           case 4: return CONTROL_COMMAND;
 317           case 5: return COMMAND_RESPONSE;
 318           default: return null;
 319         }
 320       }
 321
 322       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 323           internalGetValueMap() {
 324         return internalValueMap;
 325       }
 326       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 327           internalValueMap =
 328             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 329               public Type findValueByNumber(int number) {
 330                 return Type.valueOf(number);
 331               }
 332             };
 333
 334       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 335           getValueDescriptor() {
 336         return getDescriptor().getValues().get(index);
 337       }
 338       public final com.google.protobuf.Descriptors.EnumDescriptor
 339           getDescriptorForType() {
 340         return getDescriptor();
 341       }
 342       public static final com.google.protobuf.Descriptors.EnumDescriptor
 343           getDescriptor() {
 344         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 345       }
 346
 347       private static final Type[] VALUES = values();
 348
 349       public static Type valueOf(
 350           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 351         if (desc.getType() != getDescriptor()) {
 352           throw new java.lang.IllegalArgumentException(
 353             "EnumValueDescriptor is not for this type.");
 354         }
 355         return VALUES[desc.getIndex()];
 356       }
 357
 358       private final int index;
 359       private final int value;
 360
 361       private Type(int index, int value) {
 362         this.index = index;
 363         this.value = value;
 364       }
 365
 366       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 367     }
 368
 369     private int bitField0_;
 370     // optional .openxc.VehicleMessage.Type type = 1;
 371     public static final int TYPE_FIELD_NUMBER = 1;
 372     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 373     /**
 374      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 375      */
 376     public boolean hasType() {
 377       return ((bitField0_ & 0x00000001) == 0x00000001);
 378     }
 379     /**
 380      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 381      */
 382     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 383       return type_;
 384     }
 385
 386     // optional .openxc.RawMessage raw_message = 2;
 387     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
 388     private com.openxc.BinaryMessages.RawMessage rawMessage_;
 389     /**
 390      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 391      */
 392     public boolean hasRawMessage() {
 393       return ((bitField0_ & 0x00000002) == 0x00000002);
 394     }
 395     /**
 396      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 397      */
 398     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 399       return rawMessage_;
 400     }
 401     /**
 402      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 403      */
 404     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 405       return rawMessage_;
 406     }
 407
 408     // optional .openxc.TranslatedMessage translated_message = 3;
 409     public static final int TRANSLATED_MESSAGE_FIELD_NUMBER = 3;
 410     private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_;
 411     /**
 412      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 413      */
 414     public boolean hasTranslatedMessage() {
 415       return ((bitField0_ & 0x00000004) == 0x00000004);
 416     }
 417     /**
 418      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 419      */
 420     public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 421       return translatedMessage_;
 422     }
 423     /**
 424      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 425      */
 426     public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 427       return translatedMessage_;
 428     }
 429
 430     // optional .openxc.DiagnosticResponse diagnostic_response = 4;
 431     public static final int DIAGNOSTIC_RESPONSE_FIELD_NUMBER = 4;
 432     private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_;
 433     /**
 434      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 435      */
 436     public boolean hasDiagnosticResponse() {
 437       return ((bitField0_ & 0x00000008) == 0x00000008);
 438     }
 439     /**
 440      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 441      */
 442     public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
 443       return diagnosticResponse_;
 444     }
 445     /**
 446      * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
 447      */
 448     public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
 449       return diagnosticResponse_;
 450     }
 451
 452     // optional .openxc.ControlCommand control_command = 5;
 453     public static final int CONTROL_COMMAND_FIELD_NUMBER = 5;
 454     private com.openxc.BinaryMessages.ControlCommand controlCommand_;
 455     /**
 456      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 457      */
 458     public boolean hasControlCommand() {
 459       return ((bitField0_ & 0x00000010) == 0x00000010);
 460     }
 461     /**
 462      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 463      */
 464     public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
 465       return controlCommand_;
 466     }
 467     /**
 468      * <code>optional .openxc.ControlCommand control_command = 5;</code>
 469      */
 470     public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
 471       return controlCommand_;
 472     }
 473
 474     // optional .openxc.CommandResponse command_response = 6;
 475     public static final int COMMAND_RESPONSE_FIELD_NUMBER = 6;
 476     private com.openxc.BinaryMessages.CommandResponse commandResponse_;
 477     /**
 478      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 479      */
 480     public boolean hasCommandResponse() {
 481       return ((bitField0_ & 0x00000020) == 0x00000020);
 482     }
 483     /**
 484      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 485      */
 486     public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
 487       return commandResponse_;
 488     }
 489     /**
 490      * <code>optional .openxc.CommandResponse command_response = 6;</code>
 491      */
 492     public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
 493       return commandResponse_;
 494     }
 495
 496     private void initFields() {
 497       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 498       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 499       translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 500       diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 501       controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 502       commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 503     }
 504     private byte memoizedIsInitialized = -1;
 505     public final boolean isInitialized() {
 506       byte isInitialized = memoizedIsInitialized;
 507       if (isInitialized != -1) return isInitialized == 1;
 508
 509       memoizedIsInitialized = 1;
 510       return true;
 511     }
 512
 513     public void writeTo(com.google.protobuf.CodedOutputStream output)
 514                         throws java.io.IOException {
 515       getSerializedSize();
 516       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 517         output.writeEnum(1, type_.getNumber());
 518       }
 519       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 520         output.writeMessage(2, rawMessage_);
 521       }
 522       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 523         output.writeMessage(3, translatedMessage_);
 524       }
 525       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 526         output.writeMessage(4, diagnosticResponse_);
 527       }
 528       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 529         output.writeMessage(5, controlCommand_);
 530       }
 531       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 532         output.writeMessage(6, commandResponse_);
 533       }
 534       getUnknownFields().writeTo(output);
 535     }
 536
 537     private int memoizedSerializedSize = -1;
 538     public int getSerializedSize() {
 539       int size = memoizedSerializedSize;
 540       if (size != -1) return size;
 541
 542       size = 0;
 543       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 544         size += com.google.protobuf.CodedOutputStream
 545           .computeEnumSize(1, type_.getNumber());
 546       }
 547       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 548         size += com.google.protobuf.CodedOutputStream
 549           .computeMessageSize(2, rawMessage_);
 550       }
 551       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 552         size += com.google.protobuf.CodedOutputStream
 553           .computeMessageSize(3, translatedMessage_);
 554       }
 555       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 556         size += com.google.protobuf.CodedOutputStream
 557           .computeMessageSize(4, diagnosticResponse_);
 558       }
 559       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 560         size += com.google.protobuf.CodedOutputStream
 561           .computeMessageSize(5, controlCommand_);
 562       }
 563       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 564         size += com.google.protobuf.CodedOutputStream
 565           .computeMessageSize(6, commandResponse_);
 566       }
 567       size += getUnknownFields().getSerializedSize();
 568       memoizedSerializedSize = size;
 569       return size;
 570     }
 571
 572     private static final long serialVersionUID = 0L;
 573     @java.lang.Override
 574     protected java.lang.Object writeReplace()
 575         throws java.io.ObjectStreamException {
 576       return super.writeReplace();
 577     }
 578
 579     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 580         com.google.protobuf.ByteString data)
 581         throws com.google.protobuf.InvalidProtocolBufferException {
 582       return PARSER.parseFrom(data);
 583     }
 584     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 585         com.google.protobuf.ByteString data,
 586         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 587         throws com.google.protobuf.InvalidProtocolBufferException {
 588       return PARSER.parseFrom(data, extensionRegistry);
 589     }
 590     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 591         throws com.google.protobuf.InvalidProtocolBufferException {
 592       return PARSER.parseFrom(data);
 593     }
 594     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 595         byte[] data,
 596         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 597         throws com.google.protobuf.InvalidProtocolBufferException {
 598       return PARSER.parseFrom(data, extensionRegistry);
 599     }
 600     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 601         throws java.io.IOException {
 602       return PARSER.parseFrom(input);
 603     }
 604     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 605         java.io.InputStream input,
 606         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 607         throws java.io.IOException {
 608       return PARSER.parseFrom(input, extensionRegistry);
 609     }
 610     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 611         throws java.io.IOException {
 612       return PARSER.parseDelimitedFrom(input);
 613     }
 614     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 615         java.io.InputStream input,
 616         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 617         throws java.io.IOException {
 618       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 619     }
 620     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 621         com.google.protobuf.CodedInputStream input)
 622         throws java.io.IOException {
 623       return PARSER.parseFrom(input);
 624     }
 625     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 626         com.google.protobuf.CodedInputStream input,
 627         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 628         throws java.io.IOException {
 629       return PARSER.parseFrom(input, extensionRegistry);
 630     }
 631
 632     public static Builder newBuilder() { return Builder.create(); }
 633     public Builder newBuilderForType() { return newBuilder(); }
 634     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 635       return newBuilder().mergeFrom(prototype);
 636     }
 637     public Builder toBuilder() { return newBuilder(this); }
 638
 639     @java.lang.Override
 640     protected Builder newBuilderForType(
 641         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 642       Builder builder = new Builder(parent);
 643       return builder;
 644     }
 645     /**
 646      * Protobuf type {@code openxc.VehicleMessage}
 647      */
 648     public static final class Builder extends
 649         com.google.protobuf.GeneratedMessage.Builder<Builder>
 650        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 651       public static final com.google.protobuf.Descriptors.Descriptor
 652           getDescriptor() {
 653         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 654       }
 655
 656       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 657           internalGetFieldAccessorTable() {
 658         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 659             .ensureFieldAccessorsInitialized(
 660                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 661       }
 662
 663       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 664       private Builder() {
 665         maybeForceBuilderInitialization();
 666       }
 667
 668       private Builder(
 669           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 670         super(parent);
 671         maybeForceBuilderInitialization();
 672       }
 673       private void maybeForceBuilderInitialization() {
 674         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 675           getRawMessageFieldBuilder();
 676           getTranslatedMessageFieldBuilder();
 677           getDiagnosticResponseFieldBuilder();
 678           getControlCommandFieldBuilder();
 679           getCommandResponseFieldBuilder();
 680         }
 681       }
 682       private static Builder create() {
 683         return new Builder();
 684       }
 685
 686       public Builder clear() {
 687         super.clear();
 688         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 689         bitField0_ = (bitField0_ & ~0x00000001);
 690         if (rawMessageBuilder_ == null) {
 691           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 692         } else {
 693           rawMessageBuilder_.clear();
 694         }
 695         bitField0_ = (bitField0_ & ~0x00000002);
 696         if (translatedMessageBuilder_ == null) {
 697           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 698         } else {
 699           translatedMessageBuilder_.clear();
 700         }
 701         bitField0_ = (bitField0_ & ~0x00000004);
 702         if (diagnosticResponseBuilder_ == null) {
 703           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
 704         } else {
 705           diagnosticResponseBuilder_.clear();
 706         }
 707         bitField0_ = (bitField0_ & ~0x00000008);
 708         if (controlCommandBuilder_ == null) {
 709           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
 710         } else {
 711           controlCommandBuilder_.clear();
 712         }
 713         bitField0_ = (bitField0_ & ~0x00000010);
 714         if (commandResponseBuilder_ == null) {
 715           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
 716         } else {
 717           commandResponseBuilder_.clear();
 718         }
 719         bitField0_ = (bitField0_ & ~0x00000020);
 720         return this;
 721       }
 722
 723       public Builder clone() {
 724         return create().mergeFrom(buildPartial());
 725       }
 726
 727       public com.google.protobuf.Descriptors.Descriptor
 728           getDescriptorForType() {
 729         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 730       }
 731
 732       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 733         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 734       }
 735
 736       public com.openxc.BinaryMessages.VehicleMessage build() {
 737         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 738         if (!result.isInitialized()) {
 739           throw newUninitializedMessageException(result);
 740         }
 741         return result;
 742       }
 743
 744       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 745         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 746         int from_bitField0_ = bitField0_;
 747         int to_bitField0_ = 0;
 748         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 749           to_bitField0_ |= 0x00000001;
 750         }
 751         result.type_ = type_;
 752         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 753           to_bitField0_ |= 0x00000002;
 754         }
 755         if (rawMessageBuilder_ == null) {
 756           result.rawMessage_ = rawMessage_;
 757         } else {
 758           result.rawMessage_ = rawMessageBuilder_.build();
 759         }
 760         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 761           to_bitField0_ |= 0x00000004;
 762         }
 763         if (translatedMessageBuilder_ == null) {
 764           result.translatedMessage_ = translatedMessage_;
 765         } else {
 766           result.translatedMessage_ = translatedMessageBuilder_.build();
 767         }
 768         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 769           to_bitField0_ |= 0x00000008;
 770         }
 771         if (diagnosticResponseBuilder_ == null) {
 772           result.diagnosticResponse_ = diagnosticResponse_;
 773         } else {
 774           result.diagnosticResponse_ = diagnosticResponseBuilder_.build();
 775         }
 776         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
 777           to_bitField0_ |= 0x00000010;
 778         }
 779         if (controlCommandBuilder_ == null) {
 780           result.controlCommand_ = controlCommand_;
 781         } else {
 782           result.controlCommand_ = controlCommandBuilder_.build();
 783         }
 784         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
 785           to_bitField0_ |= 0x00000020;
 786         }
 787         if (commandResponseBuilder_ == null) {
 788           result.commandResponse_ = commandResponse_;
 789         } else {
 790           result.commandResponse_ = commandResponseBuilder_.build();
 791         }
 792         result.bitField0_ = to_bitField0_;
 793         onBuilt();
 794         return result;
 795       }
 796
 797       public Builder mergeFrom(com.google.protobuf.Message other) {
 798         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 799           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 800         } else {
 801           super.mergeFrom(other);
 802           return this;
 803         }
 804       }
 805
 806       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 807         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 808         if (other.hasType()) {
 809           setType(other.getType());
 810         }
 811         if (other.hasRawMessage()) {
 812           mergeRawMessage(other.getRawMessage());
 813         }
 814         if (other.hasTranslatedMessage()) {
 815           mergeTranslatedMessage(other.getTranslatedMessage());
 816         }
 817         if (other.hasDiagnosticResponse()) {
 818           mergeDiagnosticResponse(other.getDiagnosticResponse());
 819         }
 820         if (other.hasControlCommand()) {
 821           mergeControlCommand(other.getControlCommand());
 822         }
 823         if (other.hasCommandResponse()) {
 824           mergeCommandResponse(other.getCommandResponse());
 825         }
 826         this.mergeUnknownFields(other.getUnknownFields());
 827         return this;
 828       }
 829
 830       public final boolean isInitialized() {
 831         return true;
 832       }
 833
 834       public Builder mergeFrom(
 835           com.google.protobuf.CodedInputStream input,
 836           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 837           throws java.io.IOException {
 838         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
 839         try {
 840           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 841         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 842           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
 843           throw e;
 844         } finally {
 845           if (parsedMessage != null) {
 846             mergeFrom(parsedMessage);
 847           }
 848         }
 849         return this;
 850       }
 851       private int bitField0_;
 852
 853       // optional .openxc.VehicleMessage.Type type = 1;
 854       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 855       /**
 856        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 857        */
 858       public boolean hasType() {
 859         return ((bitField0_ & 0x00000001) == 0x00000001);
 860       }
 861       /**
 862        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 863        */
 864       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 865         return type_;
 866       }
 867       /**
 868        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 869        */
 870       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 871         if (value == null) {
 872           throw new NullPointerException();
 873         }
 874         bitField0_ |= 0x00000001;
 875         type_ = value;
 876         onChanged();
 877         return this;
 878       }
 879       /**
 880        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 881        */
 882       public Builder clearType() {
 883         bitField0_ = (bitField0_ & ~0x00000001);
 884         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 885         onChanged();
 886         return this;
 887       }
 888
 889       // optional .openxc.RawMessage raw_message = 2;
 890       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 891       private com.google.protobuf.SingleFieldBuilder<
 892           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
 893       /**
 894        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 895        */
 896       public boolean hasRawMessage() {
 897         return ((bitField0_ & 0x00000002) == 0x00000002);
 898       }
 899       /**
 900        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 901        */
 902       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 903         if (rawMessageBuilder_ == null) {
 904           return rawMessage_;
 905         } else {
 906           return rawMessageBuilder_.getMessage();
 907         }
 908       }
 909       /**
 910        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 911        */
 912       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 913         if (rawMessageBuilder_ == null) {
 914           if (value == null) {
 915             throw new NullPointerException();
 916           }
 917           rawMessage_ = value;
 918           onChanged();
 919         } else {
 920           rawMessageBuilder_.setMessage(value);
 921         }
 922         bitField0_ |= 0x00000002;
 923         return this;
 924       }
 925       /**
 926        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 927        */
 928       public Builder setRawMessage(
 929           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
 930         if (rawMessageBuilder_ == null) {
 931           rawMessage_ = builderForValue.build();
 932           onChanged();
 933         } else {
 934           rawMessageBuilder_.setMessage(builderForValue.build());
 935         }
 936         bitField0_ |= 0x00000002;
 937         return this;
 938       }
 939       /**
 940        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 941        */
 942       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 943         if (rawMessageBuilder_ == null) {
 944           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 945               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
 946             rawMessage_ =
 947               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
 948           } else {
 949             rawMessage_ = value;
 950           }
 951           onChanged();
 952         } else {
 953           rawMessageBuilder_.mergeFrom(value);
 954         }
 955         bitField0_ |= 0x00000002;
 956         return this;
 957       }
 958       /**
 959        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 960        */
 961       public Builder clearRawMessage() {
 962         if (rawMessageBuilder_ == null) {
 963           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 964           onChanged();
 965         } else {
 966           rawMessageBuilder_.clear();
 967         }
 968         bitField0_ = (bitField0_ & ~0x00000002);
 969         return this;
 970       }
 971       /**
 972        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 973        */
 974       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
 975         bitField0_ |= 0x00000002;
 976         onChanged();
 977         return getRawMessageFieldBuilder().getBuilder();
 978       }
 979       /**
 980        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 981        */
 982       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 983         if (rawMessageBuilder_ != null) {
 984           return rawMessageBuilder_.getMessageOrBuilder();
 985         } else {
 986           return rawMessage_;
 987         }
 988       }
 989       /**
 990        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 991        */
 992       private com.google.protobuf.SingleFieldBuilder<
 993           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>
 994           getRawMessageFieldBuilder() {
 995         if (rawMessageBuilder_ == null) {
 996           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 997               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
 998                   rawMessage_,
 999                   getParentForChildren(),
1000                   isClean());
1001           rawMessage_ = null;
1002         }
1003         return rawMessageBuilder_;
1004       }
1005
1006       // optional .openxc.TranslatedMessage translated_message = 3;
1007       private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1008       private com.google.protobuf.SingleFieldBuilder<
1009           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> translatedMessageBuilder_;
1010       /**
1011        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1012        */
1013       public boolean hasTranslatedMessage() {
1014         return ((bitField0_ & 0x00000004) == 0x00000004);
1015       }
1016       /**
1017        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1018        */
1019       public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
1020         if (translatedMessageBuilder_ == null) {
1021           return translatedMessage_;
1022         } else {
1023           return translatedMessageBuilder_.getMessage();
1024         }
1025       }
1026       /**
1027        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1028        */
1029       public Builder setTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1030         if (translatedMessageBuilder_ == null) {
1031           if (value == null) {
1032             throw new NullPointerException();
1033           }
1034           translatedMessage_ = value;
1035           onChanged();
1036         } else {
1037           translatedMessageBuilder_.setMessage(value);
1038         }
1039         bitField0_ |= 0x00000004;
1040         return this;
1041       }
1042       /**
1043        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1044        */
1045       public Builder setTranslatedMessage(
1046           com.openxc.BinaryMessages.TranslatedMessage.Builder builderForValue) {
1047         if (translatedMessageBuilder_ == null) {
1048           translatedMessage_ = builderForValue.build();
1049           onChanged();
1050         } else {
1051           translatedMessageBuilder_.setMessage(builderForValue.build());
1052         }
1053         bitField0_ |= 0x00000004;
1054         return this;
1055       }
1056       /**
1057        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1058        */
1059       public Builder mergeTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
1060         if (translatedMessageBuilder_ == null) {
1061           if (((bitField0_ & 0x00000004) == 0x00000004) &&
1062               translatedMessage_ != com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) {
1063             translatedMessage_ =
1064               com.openxc.BinaryMessages.TranslatedMessage.newBuilder(translatedMessage_).mergeFrom(value).buildPartial();
1065           } else {
1066             translatedMessage_ = value;
1067           }
1068           onChanged();
1069         } else {
1070           translatedMessageBuilder_.mergeFrom(value);
1071         }
1072         bitField0_ |= 0x00000004;
1073         return this;
1074       }
1075       /**
1076        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1077        */
1078       public Builder clearTranslatedMessage() {
1079         if (translatedMessageBuilder_ == null) {
1080           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
1081           onChanged();
1082         } else {
1083           translatedMessageBuilder_.clear();
1084         }
1085         bitField0_ = (bitField0_ & ~0x00000004);
1086         return this;
1087       }
1088       /**
1089        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1090        */
1091       public com.openxc.BinaryMessages.TranslatedMessage.Builder getTranslatedMessageBuilder() {
1092         bitField0_ |= 0x00000004;
1093         onChanged();
1094         return getTranslatedMessageFieldBuilder().getBuilder();
1095       }
1096       /**
1097        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1098        */
1099       public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
1100         if (translatedMessageBuilder_ != null) {
1101           return translatedMessageBuilder_.getMessageOrBuilder();
1102         } else {
1103           return translatedMessage_;
1104         }
1105       }
1106       /**
1107        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
1108        */
1109       private com.google.protobuf.SingleFieldBuilder<
1110           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>
1111           getTranslatedMessageFieldBuilder() {
1112         if (translatedMessageBuilder_ == null) {
1113           translatedMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1114               com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>(
1115                   translatedMessage_,
1116                   getParentForChildren(),
1117                   isClean());
1118           translatedMessage_ = null;
1119         }
1120         return translatedMessageBuilder_;
1121       }
1122
1123       // optional .openxc.DiagnosticResponse diagnostic_response = 4;
1124       private com.openxc.BinaryMessages.DiagnosticResponse diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1125       private com.google.protobuf.SingleFieldBuilder<
1126           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder> diagnosticResponseBuilder_;
1127       /**
1128        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1129        */
1130       public boolean hasDiagnosticResponse() {
1131         return ((bitField0_ & 0x00000008) == 0x00000008);
1132       }
1133       /**
1134        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1135        */
1136       public com.openxc.BinaryMessages.DiagnosticResponse getDiagnosticResponse() {
1137         if (diagnosticResponseBuilder_ == null) {
1138           return diagnosticResponse_;
1139         } else {
1140           return diagnosticResponseBuilder_.getMessage();
1141         }
1142       }
1143       /**
1144        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1145        */
1146       public Builder setDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1147         if (diagnosticResponseBuilder_ == null) {
1148           if (value == null) {
1149             throw new NullPointerException();
1150           }
1151           diagnosticResponse_ = value;
1152           onChanged();
1153         } else {
1154           diagnosticResponseBuilder_.setMessage(value);
1155         }
1156         bitField0_ |= 0x00000008;
1157         return this;
1158       }
1159       /**
1160        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1161        */
1162       public Builder setDiagnosticResponse(
1163           com.openxc.BinaryMessages.DiagnosticResponse.Builder builderForValue) {
1164         if (diagnosticResponseBuilder_ == null) {
1165           diagnosticResponse_ = builderForValue.build();
1166           onChanged();
1167         } else {
1168           diagnosticResponseBuilder_.setMessage(builderForValue.build());
1169         }
1170         bitField0_ |= 0x00000008;
1171         return this;
1172       }
1173       /**
1174        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1175        */
1176       public Builder mergeDiagnosticResponse(com.openxc.BinaryMessages.DiagnosticResponse value) {
1177         if (diagnosticResponseBuilder_ == null) {
1178           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1179               diagnosticResponse_ != com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) {
1180             diagnosticResponse_ =
1181               com.openxc.BinaryMessages.DiagnosticResponse.newBuilder(diagnosticResponse_).mergeFrom(value).buildPartial();
1182           } else {
1183             diagnosticResponse_ = value;
1184           }
1185           onChanged();
1186         } else {
1187           diagnosticResponseBuilder_.mergeFrom(value);
1188         }
1189         bitField0_ |= 0x00000008;
1190         return this;
1191       }
1192       /**
1193        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1194        */
1195       public Builder clearDiagnosticResponse() {
1196         if (diagnosticResponseBuilder_ == null) {
1197           diagnosticResponse_ = com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
1198           onChanged();
1199         } else {
1200           diagnosticResponseBuilder_.clear();
1201         }
1202         bitField0_ = (bitField0_ & ~0x00000008);
1203         return this;
1204       }
1205       /**
1206        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1207        */
1208       public com.openxc.BinaryMessages.DiagnosticResponse.Builder getDiagnosticResponseBuilder() {
1209         bitField0_ |= 0x00000008;
1210         onChanged();
1211         return getDiagnosticResponseFieldBuilder().getBuilder();
1212       }
1213       /**
1214        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1215        */
1216       public com.openxc.BinaryMessages.DiagnosticResponseOrBuilder getDiagnosticResponseOrBuilder() {
1217         if (diagnosticResponseBuilder_ != null) {
1218           return diagnosticResponseBuilder_.getMessageOrBuilder();
1219         } else {
1220           return diagnosticResponse_;
1221         }
1222       }
1223       /**
1224        * <code>optional .openxc.DiagnosticResponse diagnostic_response = 4;</code>
1225        */
1226       private com.google.protobuf.SingleFieldBuilder<
1227           com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>
1228           getDiagnosticResponseFieldBuilder() {
1229         if (diagnosticResponseBuilder_ == null) {
1230           diagnosticResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1231               com.openxc.BinaryMessages.DiagnosticResponse, com.openxc.BinaryMessages.DiagnosticResponse.Builder, com.openxc.BinaryMessages.DiagnosticResponseOrBuilder>(
1232                   diagnosticResponse_,
1233                   getParentForChildren(),
1234                   isClean());
1235           diagnosticResponse_ = null;
1236         }
1237         return diagnosticResponseBuilder_;
1238       }
1239
1240       // optional .openxc.ControlCommand control_command = 5;
1241       private com.openxc.BinaryMessages.ControlCommand controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1242       private com.google.protobuf.SingleFieldBuilder<
1243           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder> controlCommandBuilder_;
1244       /**
1245        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1246        */
1247       public boolean hasControlCommand() {
1248         return ((bitField0_ & 0x00000010) == 0x00000010);
1249       }
1250       /**
1251        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1252        */
1253       public com.openxc.BinaryMessages.ControlCommand getControlCommand() {
1254         if (controlCommandBuilder_ == null) {
1255           return controlCommand_;
1256         } else {
1257           return controlCommandBuilder_.getMessage();
1258         }
1259       }
1260       /**
1261        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1262        */
1263       public Builder setControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1264         if (controlCommandBuilder_ == null) {
1265           if (value == null) {
1266             throw new NullPointerException();
1267           }
1268           controlCommand_ = value;
1269           onChanged();
1270         } else {
1271           controlCommandBuilder_.setMessage(value);
1272         }
1273         bitField0_ |= 0x00000010;
1274         return this;
1275       }
1276       /**
1277        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1278        */
1279       public Builder setControlCommand(
1280           com.openxc.BinaryMessages.ControlCommand.Builder builderForValue) {
1281         if (controlCommandBuilder_ == null) {
1282           controlCommand_ = builderForValue.build();
1283           onChanged();
1284         } else {
1285           controlCommandBuilder_.setMessage(builderForValue.build());
1286         }
1287         bitField0_ |= 0x00000010;
1288         return this;
1289       }
1290       /**
1291        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1292        */
1293       public Builder mergeControlCommand(com.openxc.BinaryMessages.ControlCommand value) {
1294         if (controlCommandBuilder_ == null) {
1295           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1296               controlCommand_ != com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) {
1297             controlCommand_ =
1298               com.openxc.BinaryMessages.ControlCommand.newBuilder(controlCommand_).mergeFrom(value).buildPartial();
1299           } else {
1300             controlCommand_ = value;
1301           }
1302           onChanged();
1303         } else {
1304           controlCommandBuilder_.mergeFrom(value);
1305         }
1306         bitField0_ |= 0x00000010;
1307         return this;
1308       }
1309       /**
1310        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1311        */
1312       public Builder clearControlCommand() {
1313         if (controlCommandBuilder_ == null) {
1314           controlCommand_ = com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
1315           onChanged();
1316         } else {
1317           controlCommandBuilder_.clear();
1318         }
1319         bitField0_ = (bitField0_ & ~0x00000010);
1320         return this;
1321       }
1322       /**
1323        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1324        */
1325       public com.openxc.BinaryMessages.ControlCommand.Builder getControlCommandBuilder() {
1326         bitField0_ |= 0x00000010;
1327         onChanged();
1328         return getControlCommandFieldBuilder().getBuilder();
1329       }
1330       /**
1331        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1332        */
1333       public com.openxc.BinaryMessages.ControlCommandOrBuilder getControlCommandOrBuilder() {
1334         if (controlCommandBuilder_ != null) {
1335           return controlCommandBuilder_.getMessageOrBuilder();
1336         } else {
1337           return controlCommand_;
1338         }
1339       }
1340       /**
1341        * <code>optional .openxc.ControlCommand control_command = 5;</code>
1342        */
1343       private com.google.protobuf.SingleFieldBuilder<
1344           com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>
1345           getControlCommandFieldBuilder() {
1346         if (controlCommandBuilder_ == null) {
1347           controlCommandBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1348               com.openxc.BinaryMessages.ControlCommand, com.openxc.BinaryMessages.ControlCommand.Builder, com.openxc.BinaryMessages.ControlCommandOrBuilder>(
1349                   controlCommand_,
1350                   getParentForChildren(),
1351                   isClean());
1352           controlCommand_ = null;
1353         }
1354         return controlCommandBuilder_;
1355       }
1356
1357       // optional .openxc.CommandResponse command_response = 6;
1358       private com.openxc.BinaryMessages.CommandResponse commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1359       private com.google.protobuf.SingleFieldBuilder<
1360           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder> commandResponseBuilder_;
1361       /**
1362        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1363        */
1364       public boolean hasCommandResponse() {
1365         return ((bitField0_ & 0x00000020) == 0x00000020);
1366       }
1367       /**
1368        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1369        */
1370       public com.openxc.BinaryMessages.CommandResponse getCommandResponse() {
1371         if (commandResponseBuilder_ == null) {
1372           return commandResponse_;
1373         } else {
1374           return commandResponseBuilder_.getMessage();
1375         }
1376       }
1377       /**
1378        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1379        */
1380       public Builder setCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1381         if (commandResponseBuilder_ == null) {
1382           if (value == null) {
1383             throw new NullPointerException();
1384           }
1385           commandResponse_ = value;
1386           onChanged();
1387         } else {
1388           commandResponseBuilder_.setMessage(value);
1389         }
1390         bitField0_ |= 0x00000020;
1391         return this;
1392       }
1393       /**
1394        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1395        */
1396       public Builder setCommandResponse(
1397           com.openxc.BinaryMessages.CommandResponse.Builder builderForValue) {
1398         if (commandResponseBuilder_ == null) {
1399           commandResponse_ = builderForValue.build();
1400           onChanged();
1401         } else {
1402           commandResponseBuilder_.setMessage(builderForValue.build());
1403         }
1404         bitField0_ |= 0x00000020;
1405         return this;
1406       }
1407       /**
1408        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1409        */
1410       public Builder mergeCommandResponse(com.openxc.BinaryMessages.CommandResponse value) {
1411         if (commandResponseBuilder_ == null) {
1412           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1413               commandResponse_ != com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) {
1414             commandResponse_ =
1415               com.openxc.BinaryMessages.CommandResponse.newBuilder(commandResponse_).mergeFrom(value).buildPartial();
1416           } else {
1417             commandResponse_ = value;
1418           }
1419           onChanged();
1420         } else {
1421           commandResponseBuilder_.mergeFrom(value);
1422         }
1423         bitField0_ |= 0x00000020;
1424         return this;
1425       }
1426       /**
1427        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1428        */
1429       public Builder clearCommandResponse() {
1430         if (commandResponseBuilder_ == null) {
1431           commandResponse_ = com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
1432           onChanged();
1433         } else {
1434           commandResponseBuilder_.clear();
1435         }
1436         bitField0_ = (bitField0_ & ~0x00000020);
1437         return this;
1438       }
1439       /**
1440        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1441        */
1442       public com.openxc.BinaryMessages.CommandResponse.Builder getCommandResponseBuilder() {
1443         bitField0_ |= 0x00000020;
1444         onChanged();
1445         return getCommandResponseFieldBuilder().getBuilder();
1446       }
1447       /**
1448        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1449        */
1450       public com.openxc.BinaryMessages.CommandResponseOrBuilder getCommandResponseOrBuilder() {
1451         if (commandResponseBuilder_ != null) {
1452           return commandResponseBuilder_.getMessageOrBuilder();
1453         } else {
1454           return commandResponse_;
1455         }
1456       }
1457       /**
1458        * <code>optional .openxc.CommandResponse command_response = 6;</code>
1459        */
1460       private com.google.protobuf.SingleFieldBuilder<
1461           com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>
1462           getCommandResponseFieldBuilder() {
1463         if (commandResponseBuilder_ == null) {
1464           commandResponseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1465               com.openxc.BinaryMessages.CommandResponse, com.openxc.BinaryMessages.CommandResponse.Builder, com.openxc.BinaryMessages.CommandResponseOrBuilder>(
1466                   commandResponse_,
1467                   getParentForChildren(),
1468                   isClean());
1469           commandResponse_ = null;
1470         }
1471         return commandResponseBuilder_;
1472       }
1473
1474       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1475     }
1476
1477     static {
1478       defaultInstance = new VehicleMessage(true);
1479       defaultInstance.initFields();
1480     }
1481
1482     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1483   }
1484
1485   public interface RawMessageOrBuilder
1486       extends com.google.protobuf.MessageOrBuilder {
1487
1488     // optional int32 bus = 1;
1489     /**
1490      * <code>optional int32 bus = 1;</code>
1491      */
1492     boolean hasBus();
1493     /**
1494      * <code>optional int32 bus = 1;</code>
1495      */
1496     int getBus();
1497
1498     // optional uint32 message_id = 2;
1499     /**
1500      * <code>optional uint32 message_id = 2;</code>
1501      */
1502     boolean hasMessageId();
1503     /**
1504      * <code>optional uint32 message_id = 2;</code>
1505      */
1506     int getMessageId();
1507
1508     // optional bytes data = 3;
1509     /**
1510      * <code>optional bytes data = 3;</code>
1511      */
1512     boolean hasData();
1513     /**
1514      * <code>optional bytes data = 3;</code>
1515      */
1516     com.google.protobuf.ByteString getData();
1517   }
1518   /**
1519    * Protobuf type {@code openxc.RawMessage}
1520    */
1521   public static final class RawMessage extends
1522       com.google.protobuf.GeneratedMessage
1523       implements RawMessageOrBuilder {
1524     // Use RawMessage.newBuilder() to construct.
1525     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1526       super(builder);
1527       this.unknownFields = builder.getUnknownFields();
1528     }
1529     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1530
1531     private static final RawMessage defaultInstance;
1532     public static RawMessage getDefaultInstance() {
1533       return defaultInstance;
1534     }
1535
1536     public RawMessage getDefaultInstanceForType() {
1537       return defaultInstance;
1538     }
1539
1540     private final com.google.protobuf.UnknownFieldSet unknownFields;
1541     @java.lang.Override
1542     public final com.google.protobuf.UnknownFieldSet
1543         getUnknownFields() {
1544       return this.unknownFields;
1545     }
1546     private RawMessage(
1547         com.google.protobuf.CodedInputStream input,
1548         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1549         throws com.google.protobuf.InvalidProtocolBufferException {
1550       initFields();
1551       int mutable_bitField0_ = 0;
1552       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1553           com.google.protobuf.UnknownFieldSet.newBuilder();
1554       try {
1555         boolean done = false;
1556         while (!done) {
1557           int tag = input.readTag();
1558           switch (tag) {
1559             case 0:
1560               done = true;
1561               break;
1562             default: {
1563               if (!parseUnknownField(input, unknownFields,
1564                                      extensionRegistry, tag)) {
1565                 done = true;
1566               }
1567               break;
1568             }
1569             case 8: {
1570               bitField0_ |= 0x00000001;
1571               bus_ = input.readInt32();
1572               break;
1573             }
1574             case 16: {
1575               bitField0_ |= 0x00000002;
1576               messageId_ = input.readUInt32();
1577               break;
1578             }
1579             case 26: {
1580               bitField0_ |= 0x00000004;
1581               data_ = input.readBytes();
1582               break;
1583             }
1584           }
1585         }
1586       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1587         throw e.setUnfinishedMessage(this);
1588       } catch (java.io.IOException e) {
1589         throw new com.google.protobuf.InvalidProtocolBufferException(
1590             e.getMessage()).setUnfinishedMessage(this);
1591       } finally {
1592         this.unknownFields = unknownFields.build();
1593         makeExtensionsImmutable();
1594       }
1595     }
1596     public static final com.google.protobuf.Descriptors.Descriptor
1597         getDescriptor() {
1598       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1599     }
1600
1601     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1602         internalGetFieldAccessorTable() {
1603       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1604           .ensureFieldAccessorsInitialized(
1605               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1606     }
1607
1608     public static com.google.protobuf.Parser<RawMessage> PARSER =
1609         new com.google.protobuf.AbstractParser<RawMessage>() {
1610       public RawMessage parsePartialFrom(
1611           com.google.protobuf.CodedInputStream input,
1612           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1613           throws com.google.protobuf.InvalidProtocolBufferException {
1614         return new RawMessage(input, extensionRegistry);
1615       }
1616     };
1617
1618     @java.lang.Override
1619     public com.google.protobuf.Parser<RawMessage> getParserForType() {
1620       return PARSER;
1621     }
1622
1623     private int bitField0_;
1624     // optional int32 bus = 1;
1625     public static final int BUS_FIELD_NUMBER = 1;
1626     private int bus_;
1627     /**
1628      * <code>optional int32 bus = 1;</code>
1629      */
1630     public boolean hasBus() {
1631       return ((bitField0_ & 0x00000001) == 0x00000001);
1632     }
1633     /**
1634      * <code>optional int32 bus = 1;</code>
1635      */
1636     public int getBus() {
1637       return bus_;
1638     }
1639
1640     // optional uint32 message_id = 2;
1641     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1642     private int messageId_;
1643     /**
1644      * <code>optional uint32 message_id = 2;</code>
1645      */
1646     public boolean hasMessageId() {
1647       return ((bitField0_ & 0x00000002) == 0x00000002);
1648     }
1649     /**
1650      * <code>optional uint32 message_id = 2;</code>
1651      */
1652     public int getMessageId() {
1653       return messageId_;
1654     }
1655
1656     // optional bytes data = 3;
1657     public static final int DATA_FIELD_NUMBER = 3;
1658     private com.google.protobuf.ByteString data_;
1659     /**
1660      * <code>optional bytes data = 3;</code>
1661      */
1662     public boolean hasData() {
1663       return ((bitField0_ & 0x00000004) == 0x00000004);
1664     }
1665     /**
1666      * <code>optional bytes data = 3;</code>
1667      */
1668     public com.google.protobuf.ByteString getData() {
1669       return data_;
1670     }
1671
1672     private void initFields() {
1673       bus_ = 0;
1674       messageId_ = 0;
1675       data_ = com.google.protobuf.ByteString.EMPTY;
1676     }
1677     private byte memoizedIsInitialized = -1;
1678     public final boolean isInitialized() {
1679       byte isInitialized = memoizedIsInitialized;
1680       if (isInitialized != -1) return isInitialized == 1;
1681
1682       memoizedIsInitialized = 1;
1683       return true;
1684     }
1685
1686     public void writeTo(com.google.protobuf.CodedOutputStream output)
1687                         throws java.io.IOException {
1688       getSerializedSize();
1689       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1690         output.writeInt32(1, bus_);
1691       }
1692       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1693         output.writeUInt32(2, messageId_);
1694       }
1695       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1696         output.writeBytes(3, data_);
1697       }
1698       getUnknownFields().writeTo(output);
1699     }
1700
1701     private int memoizedSerializedSize = -1;
1702     public int getSerializedSize() {
1703       int size = memoizedSerializedSize;
1704       if (size != -1) return size;
1705
1706       size = 0;
1707       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1708         size += com.google.protobuf.CodedOutputStream
1709           .computeInt32Size(1, bus_);
1710       }
1711       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1712         size += com.google.protobuf.CodedOutputStream
1713           .computeUInt32Size(2, messageId_);
1714       }
1715       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1716         size += com.google.protobuf.CodedOutputStream
1717           .computeBytesSize(3, data_);
1718       }
1719       size += getUnknownFields().getSerializedSize();
1720       memoizedSerializedSize = size;
1721       return size;
1722     }
1723
1724     private static final long serialVersionUID = 0L;
1725     @java.lang.Override
1726     protected java.lang.Object writeReplace()
1727         throws java.io.ObjectStreamException {
1728       return super.writeReplace();
1729     }
1730
1731     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1732         com.google.protobuf.ByteString data)
1733         throws com.google.protobuf.InvalidProtocolBufferException {
1734       return PARSER.parseFrom(data);
1735     }
1736     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1737         com.google.protobuf.ByteString data,
1738         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1739         throws com.google.protobuf.InvalidProtocolBufferException {
1740       return PARSER.parseFrom(data, extensionRegistry);
1741     }
1742     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
1743         throws com.google.protobuf.InvalidProtocolBufferException {
1744       return PARSER.parseFrom(data);
1745     }
1746     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1747         byte[] data,
1748         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1749         throws com.google.protobuf.InvalidProtocolBufferException {
1750       return PARSER.parseFrom(data, extensionRegistry);
1751     }
1752     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
1753         throws java.io.IOException {
1754       return PARSER.parseFrom(input);
1755     }
1756     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1757         java.io.InputStream input,
1758         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1759         throws java.io.IOException {
1760       return PARSER.parseFrom(input, extensionRegistry);
1761     }
1762     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
1763         throws java.io.IOException {
1764       return PARSER.parseDelimitedFrom(input);
1765     }
1766     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
1767         java.io.InputStream input,
1768         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1769         throws java.io.IOException {
1770       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1771     }
1772     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1773         com.google.protobuf.CodedInputStream input)
1774         throws java.io.IOException {
1775       return PARSER.parseFrom(input);
1776     }
1777     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1778         com.google.protobuf.CodedInputStream input,
1779         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1780         throws java.io.IOException {
1781       return PARSER.parseFrom(input, extensionRegistry);
1782     }
1783
1784     public static Builder newBuilder() { return Builder.create(); }
1785     public Builder newBuilderForType() { return newBuilder(); }
1786     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
1787       return newBuilder().mergeFrom(prototype);
1788     }
1789     public Builder toBuilder() { return newBuilder(this); }
1790
1791     @java.lang.Override
1792     protected Builder newBuilderForType(
1793         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1794       Builder builder = new Builder(parent);
1795       return builder;
1796     }
1797     /**
1798      * Protobuf type {@code openxc.RawMessage}
1799      */
1800     public static final class Builder extends
1801         com.google.protobuf.GeneratedMessage.Builder<Builder>
1802        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
1803       public static final com.google.protobuf.Descriptors.Descriptor
1804           getDescriptor() {
1805         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1806       }
1807
1808       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1809           internalGetFieldAccessorTable() {
1810         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1811             .ensureFieldAccessorsInitialized(
1812                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1813       }
1814
1815       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
1816       private Builder() {
1817         maybeForceBuilderInitialization();
1818       }
1819
1820       private Builder(
1821           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1822         super(parent);
1823         maybeForceBuilderInitialization();
1824       }
1825       private void maybeForceBuilderInitialization() {
1826         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1827         }
1828       }
1829       private static Builder create() {
1830         return new Builder();
1831       }
1832
1833       public Builder clear() {
1834         super.clear();
1835         bus_ = 0;
1836         bitField0_ = (bitField0_ & ~0x00000001);
1837         messageId_ = 0;
1838         bitField0_ = (bitField0_ & ~0x00000002);
1839         data_ = com.google.protobuf.ByteString.EMPTY;
1840         bitField0_ = (bitField0_ & ~0x00000004);
1841         return this;
1842       }
1843
1844       public Builder clone() {
1845         return create().mergeFrom(buildPartial());
1846       }
1847
1848       public com.google.protobuf.Descriptors.Descriptor
1849           getDescriptorForType() {
1850         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1851       }
1852
1853       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
1854         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1855       }
1856
1857       public com.openxc.BinaryMessages.RawMessage build() {
1858         com.openxc.BinaryMessages.RawMessage result = buildPartial();
1859         if (!result.isInitialized()) {
1860           throw newUninitializedMessageException(result);
1861         }
1862         return result;
1863       }
1864
1865       public com.openxc.BinaryMessages.RawMessage buildPartial() {
1866         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
1867         int from_bitField0_ = bitField0_;
1868         int to_bitField0_ = 0;
1869         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1870           to_bitField0_ |= 0x00000001;
1871         }
1872         result.bus_ = bus_;
1873         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1874           to_bitField0_ |= 0x00000002;
1875         }
1876         result.messageId_ = messageId_;
1877         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1878           to_bitField0_ |= 0x00000004;
1879         }
1880         result.data_ = data_;
1881         result.bitField0_ = to_bitField0_;
1882         onBuilt();
1883         return result;
1884       }
1885
1886       public Builder mergeFrom(com.google.protobuf.Message other) {
1887         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
1888           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
1889         } else {
1890           super.mergeFrom(other);
1891           return this;
1892         }
1893       }
1894
1895       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
1896         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
1897         if (other.hasBus()) {
1898           setBus(other.getBus());
1899         }
1900         if (other.hasMessageId()) {
1901           setMessageId(other.getMessageId());
1902         }
1903         if (other.hasData()) {
1904           setData(other.getData());
1905         }
1906         this.mergeUnknownFields(other.getUnknownFields());
1907         return this;
1908       }
1909
1910       public final boolean isInitialized() {
1911         return true;
1912       }
1913
1914       public Builder mergeFrom(
1915           com.google.protobuf.CodedInputStream input,
1916           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1917           throws java.io.IOException {
1918         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
1919         try {
1920           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1921         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1922           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
1923           throw e;
1924         } finally {
1925           if (parsedMessage != null) {
1926             mergeFrom(parsedMessage);
1927           }
1928         }
1929         return this;
1930       }
1931       private int bitField0_;
1932
1933       // optional int32 bus = 1;
1934       private int bus_ ;
1935       /**
1936        * <code>optional int32 bus = 1;</code>
1937        */
1938       public boolean hasBus() {
1939         return ((bitField0_ & 0x00000001) == 0x00000001);
1940       }
1941       /**
1942        * <code>optional int32 bus = 1;</code>
1943        */
1944       public int getBus() {
1945         return bus_;
1946       }
1947       /**
1948        * <code>optional int32 bus = 1;</code>
1949        */
1950       public Builder setBus(int value) {
1951         bitField0_ |= 0x00000001;
1952         bus_ = value;
1953         onChanged();
1954         return this;
1955       }
1956       /**
1957        * <code>optional int32 bus = 1;</code>
1958        */
1959       public Builder clearBus() {
1960         bitField0_ = (bitField0_ & ~0x00000001);
1961         bus_ = 0;
1962         onChanged();
1963         return this;
1964       }
1965
1966       // optional uint32 message_id = 2;
1967       private int messageId_ ;
1968       /**
1969        * <code>optional uint32 message_id = 2;</code>
1970        */
1971       public boolean hasMessageId() {
1972         return ((bitField0_ & 0x00000002) == 0x00000002);
1973       }
1974       /**
1975        * <code>optional uint32 message_id = 2;</code>
1976        */
1977       public int getMessageId() {
1978         return messageId_;
1979       }
1980       /**
1981        * <code>optional uint32 message_id = 2;</code>
1982        */
1983       public Builder setMessageId(int value) {
1984         bitField0_ |= 0x00000002;
1985         messageId_ = value;
1986         onChanged();
1987         return this;
1988       }
1989       /**
1990        * <code>optional uint32 message_id = 2;</code>
1991        */
1992       public Builder clearMessageId() {
1993         bitField0_ = (bitField0_ & ~0x00000002);
1994         messageId_ = 0;
1995         onChanged();
1996         return this;
1997       }
1998
1999       // optional bytes data = 3;
2000       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
2001       /**
2002        * <code>optional bytes data = 3;</code>
2003        */
2004       public boolean hasData() {
2005         return ((bitField0_ & 0x00000004) == 0x00000004);
2006       }
2007       /**
2008        * <code>optional bytes data = 3;</code>
2009        */
2010       public com.google.protobuf.ByteString getData() {
2011         return data_;
2012       }
2013       /**
2014        * <code>optional bytes data = 3;</code>
2015        */
2016       public Builder setData(com.google.protobuf.ByteString value) {
2017         if (value == null) {
2018     throw new NullPointerException();
2019   }
2020   bitField0_ |= 0x00000004;
2021         data_ = value;
2022         onChanged();
2023         return this;
2024       }
2025       /**
2026        * <code>optional bytes data = 3;</code>
2027        */
2028       public Builder clearData() {
2029         bitField0_ = (bitField0_ & ~0x00000004);
2030         data_ = getDefaultInstance().getData();
2031         onChanged();
2032         return this;
2033       }
2034
2035       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
2036     }
2037
2038     static {
2039       defaultInstance = new RawMessage(true);
2040       defaultInstance.initFields();
2041     }
2042
2043     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
2044   }
2045
2046   public interface ControlCommandOrBuilder
2047       extends com.google.protobuf.MessageOrBuilder {
2048
2049     // optional .openxc.ControlCommand.Type type = 1;
2050     /**
2051      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2052      */
2053     boolean hasType();
2054     /**
2055      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2056      */
2057     com.openxc.BinaryMessages.ControlCommand.Type getType();
2058
2059     // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2060     /**
2061      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2062      */
2063     boolean hasDiagnosticRequest();
2064     /**
2065      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2066      */
2067     com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest();
2068     /**
2069      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2070      */
2071     com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder();
2072   }
2073   /**
2074    * Protobuf type {@code openxc.ControlCommand}
2075    */
2076   public static final class ControlCommand extends
2077       com.google.protobuf.GeneratedMessage
2078       implements ControlCommandOrBuilder {
2079     // Use ControlCommand.newBuilder() to construct.
2080     private ControlCommand(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2081       super(builder);
2082       this.unknownFields = builder.getUnknownFields();
2083     }
2084     private ControlCommand(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2085
2086     private static final ControlCommand defaultInstance;
2087     public static ControlCommand getDefaultInstance() {
2088       return defaultInstance;
2089     }
2090
2091     public ControlCommand getDefaultInstanceForType() {
2092       return defaultInstance;
2093     }
2094
2095     private final com.google.protobuf.UnknownFieldSet unknownFields;
2096     @java.lang.Override
2097     public final com.google.protobuf.UnknownFieldSet
2098         getUnknownFields() {
2099       return this.unknownFields;
2100     }
2101     private ControlCommand(
2102         com.google.protobuf.CodedInputStream input,
2103         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2104         throws com.google.protobuf.InvalidProtocolBufferException {
2105       initFields();
2106       int mutable_bitField0_ = 0;
2107       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2108           com.google.protobuf.UnknownFieldSet.newBuilder();
2109       try {
2110         boolean done = false;
2111         while (!done) {
2112           int tag = input.readTag();
2113           switch (tag) {
2114             case 0:
2115               done = true;
2116               break;
2117             default: {
2118               if (!parseUnknownField(input, unknownFields,
2119                                      extensionRegistry, tag)) {
2120                 done = true;
2121               }
2122               break;
2123             }
2124             case 8: {
2125               int rawValue = input.readEnum();
2126               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2127               if (value == null) {
2128                 unknownFields.mergeVarintField(1, rawValue);
2129               } else {
2130                 bitField0_ |= 0x00000001;
2131                 type_ = value;
2132               }
2133               break;
2134             }
2135             case 18: {
2136               com.openxc.BinaryMessages.DiagnosticRequest.Builder subBuilder = null;
2137               if (((bitField0_ & 0x00000002) == 0x00000002)) {
2138                 subBuilder = diagnosticRequest_.toBuilder();
2139               }
2140               diagnosticRequest_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticRequest.PARSER, extensionRegistry);
2141               if (subBuilder != null) {
2142                 subBuilder.mergeFrom(diagnosticRequest_);
2143                 diagnosticRequest_ = subBuilder.buildPartial();
2144               }
2145               bitField0_ |= 0x00000002;
2146               break;
2147             }
2148           }
2149         }
2150       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2151         throw e.setUnfinishedMessage(this);
2152       } catch (java.io.IOException e) {
2153         throw new com.google.protobuf.InvalidProtocolBufferException(
2154             e.getMessage()).setUnfinishedMessage(this);
2155       } finally {
2156         this.unknownFields = unknownFields.build();
2157         makeExtensionsImmutable();
2158       }
2159     }
2160     public static final com.google.protobuf.Descriptors.Descriptor
2161         getDescriptor() {
2162       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2163     }
2164
2165     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2166         internalGetFieldAccessorTable() {
2167       return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2168           .ensureFieldAccessorsInitialized(
2169               com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2170     }
2171
2172     public static com.google.protobuf.Parser<ControlCommand> PARSER =
2173         new com.google.protobuf.AbstractParser<ControlCommand>() {
2174       public ControlCommand parsePartialFrom(
2175           com.google.protobuf.CodedInputStream input,
2176           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2177           throws com.google.protobuf.InvalidProtocolBufferException {
2178         return new ControlCommand(input, extensionRegistry);
2179       }
2180     };
2181
2182     @java.lang.Override
2183     public com.google.protobuf.Parser<ControlCommand> getParserForType() {
2184       return PARSER;
2185     }
2186
2187     /**
2188      * Protobuf enum {@code openxc.ControlCommand.Type}
2189      */
2190     public enum Type
2191         implements com.google.protobuf.ProtocolMessageEnum {
2192       /**
2193        * <code>VERSION = 1;</code>
2194        */
2195       VERSION(0, 1),
2196       /**
2197        * <code>DEVICE_ID = 2;</code>
2198        */
2199       DEVICE_ID(1, 2),
2200       /**
2201        * <code>DIAGNOSTIC = 3;</code>
2202        */
2203       DIAGNOSTIC(2, 3),
2204       ;
2205
2206       /**
2207        * <code>VERSION = 1;</code>
2208        */
2209       public static final int VERSION_VALUE = 1;
2210       /**
2211        * <code>DEVICE_ID = 2;</code>
2212        */
2213       public static final int DEVICE_ID_VALUE = 2;
2214       /**
2215        * <code>DIAGNOSTIC = 3;</code>
2216        */
2217       public static final int DIAGNOSTIC_VALUE = 3;
2218
2219
2220       public final int getNumber() { return value; }
2221
2222       public static Type valueOf(int value) {
2223         switch (value) {
2224           case 1: return VERSION;
2225           case 2: return DEVICE_ID;
2226           case 3: return DIAGNOSTIC;
2227           default: return null;
2228         }
2229       }
2230
2231       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2232           internalGetValueMap() {
2233         return internalValueMap;
2234       }
2235       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2236           internalValueMap =
2237             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2238               public Type findValueByNumber(int number) {
2239                 return Type.valueOf(number);
2240               }
2241             };
2242
2243       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2244           getValueDescriptor() {
2245         return getDescriptor().getValues().get(index);
2246       }
2247       public final com.google.protobuf.Descriptors.EnumDescriptor
2248           getDescriptorForType() {
2249         return getDescriptor();
2250       }
2251       public static final com.google.protobuf.Descriptors.EnumDescriptor
2252           getDescriptor() {
2253         return com.openxc.BinaryMessages.ControlCommand.getDescriptor().getEnumTypes().get(0);
2254       }
2255
2256       private static final Type[] VALUES = values();
2257
2258       public static Type valueOf(
2259           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2260         if (desc.getType() != getDescriptor()) {
2261           throw new java.lang.IllegalArgumentException(
2262             "EnumValueDescriptor is not for this type.");
2263         }
2264         return VALUES[desc.getIndex()];
2265       }
2266
2267       private final int index;
2268       private final int value;
2269
2270       private Type(int index, int value) {
2271         this.index = index;
2272         this.value = value;
2273       }
2274
2275       // @@protoc_insertion_point(enum_scope:openxc.ControlCommand.Type)
2276     }
2277
2278     private int bitField0_;
2279     // optional .openxc.ControlCommand.Type type = 1;
2280     public static final int TYPE_FIELD_NUMBER = 1;
2281     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2282     /**
2283      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2284      */
2285     public boolean hasType() {
2286       return ((bitField0_ & 0x00000001) == 0x00000001);
2287     }
2288     /**
2289      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2290      */
2291     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2292       return type_;
2293     }
2294
2295     // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2296     public static final int DIAGNOSTIC_REQUEST_FIELD_NUMBER = 2;
2297     private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_;
2298     /**
2299      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2300      */
2301     public boolean hasDiagnosticRequest() {
2302       return ((bitField0_ & 0x00000002) == 0x00000002);
2303     }
2304     /**
2305      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2306      */
2307     public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2308       return diagnosticRequest_;
2309     }
2310     /**
2311      * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2312      */
2313     public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2314       return diagnosticRequest_;
2315     }
2316
2317     private void initFields() {
2318       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2319       diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2320     }
2321     private byte memoizedIsInitialized = -1;
2322     public final boolean isInitialized() {
2323       byte isInitialized = memoizedIsInitialized;
2324       if (isInitialized != -1) return isInitialized == 1;
2325
2326       memoizedIsInitialized = 1;
2327       return true;
2328     }
2329
2330     public void writeTo(com.google.protobuf.CodedOutputStream output)
2331                         throws java.io.IOException {
2332       getSerializedSize();
2333       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2334         output.writeEnum(1, type_.getNumber());
2335       }
2336       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2337         output.writeMessage(2, diagnosticRequest_);
2338       }
2339       getUnknownFields().writeTo(output);
2340     }
2341
2342     private int memoizedSerializedSize = -1;
2343     public int getSerializedSize() {
2344       int size = memoizedSerializedSize;
2345       if (size != -1) return size;
2346
2347       size = 0;
2348       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2349         size += com.google.protobuf.CodedOutputStream
2350           .computeEnumSize(1, type_.getNumber());
2351       }
2352       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2353         size += com.google.protobuf.CodedOutputStream
2354           .computeMessageSize(2, diagnosticRequest_);
2355       }
2356       size += getUnknownFields().getSerializedSize();
2357       memoizedSerializedSize = size;
2358       return size;
2359     }
2360
2361     private static final long serialVersionUID = 0L;
2362     @java.lang.Override
2363     protected java.lang.Object writeReplace()
2364         throws java.io.ObjectStreamException {
2365       return super.writeReplace();
2366     }
2367
2368     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2369         com.google.protobuf.ByteString data)
2370         throws com.google.protobuf.InvalidProtocolBufferException {
2371       return PARSER.parseFrom(data);
2372     }
2373     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2374         com.google.protobuf.ByteString data,
2375         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2376         throws com.google.protobuf.InvalidProtocolBufferException {
2377       return PARSER.parseFrom(data, extensionRegistry);
2378     }
2379     public static com.openxc.BinaryMessages.ControlCommand parseFrom(byte[] data)
2380         throws com.google.protobuf.InvalidProtocolBufferException {
2381       return PARSER.parseFrom(data);
2382     }
2383     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2384         byte[] data,
2385         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2386         throws com.google.protobuf.InvalidProtocolBufferException {
2387       return PARSER.parseFrom(data, extensionRegistry);
2388     }
2389     public static com.openxc.BinaryMessages.ControlCommand parseFrom(java.io.InputStream input)
2390         throws java.io.IOException {
2391       return PARSER.parseFrom(input);
2392     }
2393     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2394         java.io.InputStream input,
2395         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2396         throws java.io.IOException {
2397       return PARSER.parseFrom(input, extensionRegistry);
2398     }
2399     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(java.io.InputStream input)
2400         throws java.io.IOException {
2401       return PARSER.parseDelimitedFrom(input);
2402     }
2403     public static com.openxc.BinaryMessages.ControlCommand parseDelimitedFrom(
2404         java.io.InputStream input,
2405         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2406         throws java.io.IOException {
2407       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2408     }
2409     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2410         com.google.protobuf.CodedInputStream input)
2411         throws java.io.IOException {
2412       return PARSER.parseFrom(input);
2413     }
2414     public static com.openxc.BinaryMessages.ControlCommand parseFrom(
2415         com.google.protobuf.CodedInputStream input,
2416         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2417         throws java.io.IOException {
2418       return PARSER.parseFrom(input, extensionRegistry);
2419     }
2420
2421     public static Builder newBuilder() { return Builder.create(); }
2422     public Builder newBuilderForType() { return newBuilder(); }
2423     public static Builder newBuilder(com.openxc.BinaryMessages.ControlCommand prototype) {
2424       return newBuilder().mergeFrom(prototype);
2425     }
2426     public Builder toBuilder() { return newBuilder(this); }
2427
2428     @java.lang.Override
2429     protected Builder newBuilderForType(
2430         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2431       Builder builder = new Builder(parent);
2432       return builder;
2433     }
2434     /**
2435      * Protobuf type {@code openxc.ControlCommand}
2436      */
2437     public static final class Builder extends
2438         com.google.protobuf.GeneratedMessage.Builder<Builder>
2439        implements com.openxc.BinaryMessages.ControlCommandOrBuilder {
2440       public static final com.google.protobuf.Descriptors.Descriptor
2441           getDescriptor() {
2442         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2443       }
2444
2445       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2446           internalGetFieldAccessorTable() {
2447         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_fieldAccessorTable
2448             .ensureFieldAccessorsInitialized(
2449                 com.openxc.BinaryMessages.ControlCommand.class, com.openxc.BinaryMessages.ControlCommand.Builder.class);
2450       }
2451
2452       // Construct using com.openxc.BinaryMessages.ControlCommand.newBuilder()
2453       private Builder() {
2454         maybeForceBuilderInitialization();
2455       }
2456
2457       private Builder(
2458           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2459         super(parent);
2460         maybeForceBuilderInitialization();
2461       }
2462       private void maybeForceBuilderInitialization() {
2463         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2464           getDiagnosticRequestFieldBuilder();
2465         }
2466       }
2467       private static Builder create() {
2468         return new Builder();
2469       }
2470
2471       public Builder clear() {
2472         super.clear();
2473         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2474         bitField0_ = (bitField0_ & ~0x00000001);
2475         if (diagnosticRequestBuilder_ == null) {
2476           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2477         } else {
2478           diagnosticRequestBuilder_.clear();
2479         }
2480         bitField0_ = (bitField0_ & ~0x00000002);
2481         return this;
2482       }
2483
2484       public Builder clone() {
2485         return create().mergeFrom(buildPartial());
2486       }
2487
2488       public com.google.protobuf.Descriptors.Descriptor
2489           getDescriptorForType() {
2490         return com.openxc.BinaryMessages.internal_static_openxc_ControlCommand_descriptor;
2491       }
2492
2493       public com.openxc.BinaryMessages.ControlCommand getDefaultInstanceForType() {
2494         return com.openxc.BinaryMessages.ControlCommand.getDefaultInstance();
2495       }
2496
2497       public com.openxc.BinaryMessages.ControlCommand build() {
2498         com.openxc.BinaryMessages.ControlCommand result = buildPartial();
2499         if (!result.isInitialized()) {
2500           throw newUninitializedMessageException(result);
2501         }
2502         return result;
2503       }
2504
2505       public com.openxc.BinaryMessages.ControlCommand buildPartial() {
2506         com.openxc.BinaryMessages.ControlCommand result = new com.openxc.BinaryMessages.ControlCommand(this);
2507         int from_bitField0_ = bitField0_;
2508         int to_bitField0_ = 0;
2509         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2510           to_bitField0_ |= 0x00000001;
2511         }
2512         result.type_ = type_;
2513         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2514           to_bitField0_ |= 0x00000002;
2515         }
2516         if (diagnosticRequestBuilder_ == null) {
2517           result.diagnosticRequest_ = diagnosticRequest_;
2518         } else {
2519           result.diagnosticRequest_ = diagnosticRequestBuilder_.build();
2520         }
2521         result.bitField0_ = to_bitField0_;
2522         onBuilt();
2523         return result;
2524       }
2525
2526       public Builder mergeFrom(com.google.protobuf.Message other) {
2527         if (other instanceof com.openxc.BinaryMessages.ControlCommand) {
2528           return mergeFrom((com.openxc.BinaryMessages.ControlCommand)other);
2529         } else {
2530           super.mergeFrom(other);
2531           return this;
2532         }
2533       }
2534
2535       public Builder mergeFrom(com.openxc.BinaryMessages.ControlCommand other) {
2536         if (other == com.openxc.BinaryMessages.ControlCommand.getDefaultInstance()) return this;
2537         if (other.hasType()) {
2538           setType(other.getType());
2539         }
2540         if (other.hasDiagnosticRequest()) {
2541           mergeDiagnosticRequest(other.getDiagnosticRequest());
2542         }
2543         this.mergeUnknownFields(other.getUnknownFields());
2544         return this;
2545       }
2546
2547       public final boolean isInitialized() {
2548         return true;
2549       }
2550
2551       public Builder mergeFrom(
2552           com.google.protobuf.CodedInputStream input,
2553           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2554           throws java.io.IOException {
2555         com.openxc.BinaryMessages.ControlCommand parsedMessage = null;
2556         try {
2557           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2558         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2559           parsedMessage = (com.openxc.BinaryMessages.ControlCommand) e.getUnfinishedMessage();
2560           throw e;
2561         } finally {
2562           if (parsedMessage != null) {
2563             mergeFrom(parsedMessage);
2564           }
2565         }
2566         return this;
2567       }
2568       private int bitField0_;
2569
2570       // optional .openxc.ControlCommand.Type type = 1;
2571       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2572       /**
2573        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2574        */
2575       public boolean hasType() {
2576         return ((bitField0_ & 0x00000001) == 0x00000001);
2577       }
2578       /**
2579        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2580        */
2581       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2582         return type_;
2583       }
2584       /**
2585        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2586        */
2587       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
2588         if (value == null) {
2589           throw new NullPointerException();
2590         }
2591         bitField0_ |= 0x00000001;
2592         type_ = value;
2593         onChanged();
2594         return this;
2595       }
2596       /**
2597        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2598        */
2599       public Builder clearType() {
2600         bitField0_ = (bitField0_ & ~0x00000001);
2601         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2602         onChanged();
2603         return this;
2604       }
2605
2606       // optional .openxc.DiagnosticRequest diagnostic_request = 2;
2607       private com.openxc.BinaryMessages.DiagnosticRequest diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2608       private com.google.protobuf.SingleFieldBuilder<
2609           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder> diagnosticRequestBuilder_;
2610       /**
2611        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2612        */
2613       public boolean hasDiagnosticRequest() {
2614         return ((bitField0_ & 0x00000002) == 0x00000002);
2615       }
2616       /**
2617        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2618        */
2619       public com.openxc.BinaryMessages.DiagnosticRequest getDiagnosticRequest() {
2620         if (diagnosticRequestBuilder_ == null) {
2621           return diagnosticRequest_;
2622         } else {
2623           return diagnosticRequestBuilder_.getMessage();
2624         }
2625       }
2626       /**
2627        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2628        */
2629       public Builder setDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2630         if (diagnosticRequestBuilder_ == null) {
2631           if (value == null) {
2632             throw new NullPointerException();
2633           }
2634           diagnosticRequest_ = value;
2635           onChanged();
2636         } else {
2637           diagnosticRequestBuilder_.setMessage(value);
2638         }
2639         bitField0_ |= 0x00000002;
2640         return this;
2641       }
2642       /**
2643        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2644        */
2645       public Builder setDiagnosticRequest(
2646           com.openxc.BinaryMessages.DiagnosticRequest.Builder builderForValue) {
2647         if (diagnosticRequestBuilder_ == null) {
2648           diagnosticRequest_ = builderForValue.build();
2649           onChanged();
2650         } else {
2651           diagnosticRequestBuilder_.setMessage(builderForValue.build());
2652         }
2653         bitField0_ |= 0x00000002;
2654         return this;
2655       }
2656       /**
2657        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2658        */
2659       public Builder mergeDiagnosticRequest(com.openxc.BinaryMessages.DiagnosticRequest value) {
2660         if (diagnosticRequestBuilder_ == null) {
2661           if (((bitField0_ & 0x00000002) == 0x00000002) &&
2662               diagnosticRequest_ != com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) {
2663             diagnosticRequest_ =
2664               com.openxc.BinaryMessages.DiagnosticRequest.newBuilder(diagnosticRequest_).mergeFrom(value).buildPartial();
2665           } else {
2666             diagnosticRequest_ = value;
2667           }
2668           onChanged();
2669         } else {
2670           diagnosticRequestBuilder_.mergeFrom(value);
2671         }
2672         bitField0_ |= 0x00000002;
2673         return this;
2674       }
2675       /**
2676        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2677        */
2678       public Builder clearDiagnosticRequest() {
2679         if (diagnosticRequestBuilder_ == null) {
2680           diagnosticRequest_ = com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
2681           onChanged();
2682         } else {
2683           diagnosticRequestBuilder_.clear();
2684         }
2685         bitField0_ = (bitField0_ & ~0x00000002);
2686         return this;
2687       }
2688       /**
2689        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2690        */
2691       public com.openxc.BinaryMessages.DiagnosticRequest.Builder getDiagnosticRequestBuilder() {
2692         bitField0_ |= 0x00000002;
2693         onChanged();
2694         return getDiagnosticRequestFieldBuilder().getBuilder();
2695       }
2696       /**
2697        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2698        */
2699       public com.openxc.BinaryMessages.DiagnosticRequestOrBuilder getDiagnosticRequestOrBuilder() {
2700         if (diagnosticRequestBuilder_ != null) {
2701           return diagnosticRequestBuilder_.getMessageOrBuilder();
2702         } else {
2703           return diagnosticRequest_;
2704         }
2705       }
2706       /**
2707        * <code>optional .openxc.DiagnosticRequest diagnostic_request = 2;</code>
2708        */
2709       private com.google.protobuf.SingleFieldBuilder<
2710           com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>
2711           getDiagnosticRequestFieldBuilder() {
2712         if (diagnosticRequestBuilder_ == null) {
2713           diagnosticRequestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
2714               com.openxc.BinaryMessages.DiagnosticRequest, com.openxc.BinaryMessages.DiagnosticRequest.Builder, com.openxc.BinaryMessages.DiagnosticRequestOrBuilder>(
2715                   diagnosticRequest_,
2716                   getParentForChildren(),
2717                   isClean());
2718           diagnosticRequest_ = null;
2719         }
2720         return diagnosticRequestBuilder_;
2721       }
2722
2723       // @@protoc_insertion_point(builder_scope:openxc.ControlCommand)
2724     }
2725
2726     static {
2727       defaultInstance = new ControlCommand(true);
2728       defaultInstance.initFields();
2729     }
2730
2731     // @@protoc_insertion_point(class_scope:openxc.ControlCommand)
2732   }
2733
2734   public interface CommandResponseOrBuilder
2735       extends com.google.protobuf.MessageOrBuilder {
2736
2737     // optional .openxc.ControlCommand.Type type = 1;
2738     /**
2739      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2740      */
2741     boolean hasType();
2742     /**
2743      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2744      */
2745     com.openxc.BinaryMessages.ControlCommand.Type getType();
2746
2747     // optional string message = 2;
2748     /**
2749      * <code>optional string message = 2;</code>
2750      */
2751     boolean hasMessage();
2752     /**
2753      * <code>optional string message = 2;</code>
2754      */
2755     java.lang.String getMessage();
2756     /**
2757      * <code>optional string message = 2;</code>
2758      */
2759     com.google.protobuf.ByteString
2760         getMessageBytes();
2761   }
2762   /**
2763    * Protobuf type {@code openxc.CommandResponse}
2764    */
2765   public static final class CommandResponse extends
2766       com.google.protobuf.GeneratedMessage
2767       implements CommandResponseOrBuilder {
2768     // Use CommandResponse.newBuilder() to construct.
2769     private CommandResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2770       super(builder);
2771       this.unknownFields = builder.getUnknownFields();
2772     }
2773     private CommandResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2774
2775     private static final CommandResponse defaultInstance;
2776     public static CommandResponse getDefaultInstance() {
2777       return defaultInstance;
2778     }
2779
2780     public CommandResponse getDefaultInstanceForType() {
2781       return defaultInstance;
2782     }
2783
2784     private final com.google.protobuf.UnknownFieldSet unknownFields;
2785     @java.lang.Override
2786     public final com.google.protobuf.UnknownFieldSet
2787         getUnknownFields() {
2788       return this.unknownFields;
2789     }
2790     private CommandResponse(
2791         com.google.protobuf.CodedInputStream input,
2792         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2793         throws com.google.protobuf.InvalidProtocolBufferException {
2794       initFields();
2795       int mutable_bitField0_ = 0;
2796       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2797           com.google.protobuf.UnknownFieldSet.newBuilder();
2798       try {
2799         boolean done = false;
2800         while (!done) {
2801           int tag = input.readTag();
2802           switch (tag) {
2803             case 0:
2804               done = true;
2805               break;
2806             default: {
2807               if (!parseUnknownField(input, unknownFields,
2808                                      extensionRegistry, tag)) {
2809                 done = true;
2810               }
2811               break;
2812             }
2813             case 8: {
2814               int rawValue = input.readEnum();
2815               com.openxc.BinaryMessages.ControlCommand.Type value = com.openxc.BinaryMessages.ControlCommand.Type.valueOf(rawValue);
2816               if (value == null) {
2817                 unknownFields.mergeVarintField(1, rawValue);
2818               } else {
2819                 bitField0_ |= 0x00000001;
2820                 type_ = value;
2821               }
2822               break;
2823             }
2824             case 18: {
2825               bitField0_ |= 0x00000002;
2826               message_ = input.readBytes();
2827               break;
2828             }
2829           }
2830         }
2831       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2832         throw e.setUnfinishedMessage(this);
2833       } catch (java.io.IOException e) {
2834         throw new com.google.protobuf.InvalidProtocolBufferException(
2835             e.getMessage()).setUnfinishedMessage(this);
2836       } finally {
2837         this.unknownFields = unknownFields.build();
2838         makeExtensionsImmutable();
2839       }
2840     }
2841     public static final com.google.protobuf.Descriptors.Descriptor
2842         getDescriptor() {
2843       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
2844     }
2845
2846     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2847         internalGetFieldAccessorTable() {
2848       return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
2849           .ensureFieldAccessorsInitialized(
2850               com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
2851     }
2852
2853     public static com.google.protobuf.Parser<CommandResponse> PARSER =
2854         new com.google.protobuf.AbstractParser<CommandResponse>() {
2855       public CommandResponse parsePartialFrom(
2856           com.google.protobuf.CodedInputStream input,
2857           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2858           throws com.google.protobuf.InvalidProtocolBufferException {
2859         return new CommandResponse(input, extensionRegistry);
2860       }
2861     };
2862
2863     @java.lang.Override
2864     public com.google.protobuf.Parser<CommandResponse> getParserForType() {
2865       return PARSER;
2866     }
2867
2868     private int bitField0_;
2869     // optional .openxc.ControlCommand.Type type = 1;
2870     public static final int TYPE_FIELD_NUMBER = 1;
2871     private com.openxc.BinaryMessages.ControlCommand.Type type_;
2872     /**
2873      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2874      */
2875     public boolean hasType() {
2876       return ((bitField0_ & 0x00000001) == 0x00000001);
2877     }
2878     /**
2879      * <code>optional .openxc.ControlCommand.Type type = 1;</code>
2880      */
2881     public com.openxc.BinaryMessages.ControlCommand.Type getType() {
2882       return type_;
2883     }
2884
2885     // optional string message = 2;
2886     public static final int MESSAGE_FIELD_NUMBER = 2;
2887     private java.lang.Object message_;
2888     /**
2889      * <code>optional string message = 2;</code>
2890      */
2891     public boolean hasMessage() {
2892       return ((bitField0_ & 0x00000002) == 0x00000002);
2893     }
2894     /**
2895      * <code>optional string message = 2;</code>
2896      */
2897     public java.lang.String getMessage() {
2898       java.lang.Object ref = message_;
2899       if (ref instanceof java.lang.String) {
2900         return (java.lang.String) ref;
2901       } else {
2902         com.google.protobuf.ByteString bs =
2903             (com.google.protobuf.ByteString) ref;
2904         java.lang.String s = bs.toStringUtf8();
2905         if (bs.isValidUtf8()) {
2906           message_ = s;
2907         }
2908         return s;
2909       }
2910     }
2911     /**
2912      * <code>optional string message = 2;</code>
2913      */
2914     public com.google.protobuf.ByteString
2915         getMessageBytes() {
2916       java.lang.Object ref = message_;
2917       if (ref instanceof java.lang.String) {
2918         com.google.protobuf.ByteString b =
2919             com.google.protobuf.ByteString.copyFromUtf8(
2920                 (java.lang.String) ref);
2921         message_ = b;
2922         return b;
2923       } else {
2924         return (com.google.protobuf.ByteString) ref;
2925       }
2926     }
2927
2928     private void initFields() {
2929       type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
2930       message_ = "";
2931     }
2932     private byte memoizedIsInitialized = -1;
2933     public final boolean isInitialized() {
2934       byte isInitialized = memoizedIsInitialized;
2935       if (isInitialized != -1) return isInitialized == 1;
2936
2937       memoizedIsInitialized = 1;
2938       return true;
2939     }
2940
2941     public void writeTo(com.google.protobuf.CodedOutputStream output)
2942                         throws java.io.IOException {
2943       getSerializedSize();
2944       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2945         output.writeEnum(1, type_.getNumber());
2946       }
2947       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2948         output.writeBytes(2, getMessageBytes());
2949       }
2950       getUnknownFields().writeTo(output);
2951     }
2952
2953     private int memoizedSerializedSize = -1;
2954     public int getSerializedSize() {
2955       int size = memoizedSerializedSize;
2956       if (size != -1) return size;
2957
2958       size = 0;
2959       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2960         size += com.google.protobuf.CodedOutputStream
2961           .computeEnumSize(1, type_.getNumber());
2962       }
2963       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2964         size += com.google.protobuf.CodedOutputStream
2965           .computeBytesSize(2, getMessageBytes());
2966       }
2967       size += getUnknownFields().getSerializedSize();
2968       memoizedSerializedSize = size;
2969       return size;
2970     }
2971
2972     private static final long serialVersionUID = 0L;
2973     @java.lang.Override
2974     protected java.lang.Object writeReplace()
2975         throws java.io.ObjectStreamException {
2976       return super.writeReplace();
2977     }
2978
2979     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
2980         com.google.protobuf.ByteString data)
2981         throws com.google.protobuf.InvalidProtocolBufferException {
2982       return PARSER.parseFrom(data);
2983     }
2984     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
2985         com.google.protobuf.ByteString data,
2986         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2987         throws com.google.protobuf.InvalidProtocolBufferException {
2988       return PARSER.parseFrom(data, extensionRegistry);
2989     }
2990     public static com.openxc.BinaryMessages.CommandResponse parseFrom(byte[] data)
2991         throws com.google.protobuf.InvalidProtocolBufferException {
2992       return PARSER.parseFrom(data);
2993     }
2994     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
2995         byte[] data,
2996         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2997         throws com.google.protobuf.InvalidProtocolBufferException {
2998       return PARSER.parseFrom(data, extensionRegistry);
2999     }
3000     public static com.openxc.BinaryMessages.CommandResponse parseFrom(java.io.InputStream input)
3001         throws java.io.IOException {
3002       return PARSER.parseFrom(input);
3003     }
3004     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3005         java.io.InputStream input,
3006         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3007         throws java.io.IOException {
3008       return PARSER.parseFrom(input, extensionRegistry);
3009     }
3010     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(java.io.InputStream input)
3011         throws java.io.IOException {
3012       return PARSER.parseDelimitedFrom(input);
3013     }
3014     public static com.openxc.BinaryMessages.CommandResponse parseDelimitedFrom(
3015         java.io.InputStream input,
3016         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3017         throws java.io.IOException {
3018       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3019     }
3020     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3021         com.google.protobuf.CodedInputStream input)
3022         throws java.io.IOException {
3023       return PARSER.parseFrom(input);
3024     }
3025     public static com.openxc.BinaryMessages.CommandResponse parseFrom(
3026         com.google.protobuf.CodedInputStream input,
3027         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3028         throws java.io.IOException {
3029       return PARSER.parseFrom(input, extensionRegistry);
3030     }
3031
3032     public static Builder newBuilder() { return Builder.create(); }
3033     public Builder newBuilderForType() { return newBuilder(); }
3034     public static Builder newBuilder(com.openxc.BinaryMessages.CommandResponse prototype) {
3035       return newBuilder().mergeFrom(prototype);
3036     }
3037     public Builder toBuilder() { return newBuilder(this); }
3038
3039     @java.lang.Override
3040     protected Builder newBuilderForType(
3041         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3042       Builder builder = new Builder(parent);
3043       return builder;
3044     }
3045     /**
3046      * Protobuf type {@code openxc.CommandResponse}
3047      */
3048     public static final class Builder extends
3049         com.google.protobuf.GeneratedMessage.Builder<Builder>
3050        implements com.openxc.BinaryMessages.CommandResponseOrBuilder {
3051       public static final com.google.protobuf.Descriptors.Descriptor
3052           getDescriptor() {
3053         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3054       }
3055
3056       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3057           internalGetFieldAccessorTable() {
3058         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_fieldAccessorTable
3059             .ensureFieldAccessorsInitialized(
3060                 com.openxc.BinaryMessages.CommandResponse.class, com.openxc.BinaryMessages.CommandResponse.Builder.class);
3061       }
3062
3063       // Construct using com.openxc.BinaryMessages.CommandResponse.newBuilder()
3064       private Builder() {
3065         maybeForceBuilderInitialization();
3066       }
3067
3068       private Builder(
3069           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3070         super(parent);
3071         maybeForceBuilderInitialization();
3072       }
3073       private void maybeForceBuilderInitialization() {
3074         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3075         }
3076       }
3077       private static Builder create() {
3078         return new Builder();
3079       }
3080
3081       public Builder clear() {
3082         super.clear();
3083         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3084         bitField0_ = (bitField0_ & ~0x00000001);
3085         message_ = "";
3086         bitField0_ = (bitField0_ & ~0x00000002);
3087         return this;
3088       }
3089
3090       public Builder clone() {
3091         return create().mergeFrom(buildPartial());
3092       }
3093
3094       public com.google.protobuf.Descriptors.Descriptor
3095           getDescriptorForType() {
3096         return com.openxc.BinaryMessages.internal_static_openxc_CommandResponse_descriptor;
3097       }
3098
3099       public com.openxc.BinaryMessages.CommandResponse getDefaultInstanceForType() {
3100         return com.openxc.BinaryMessages.CommandResponse.getDefaultInstance();
3101       }
3102
3103       public com.openxc.BinaryMessages.CommandResponse build() {
3104         com.openxc.BinaryMessages.CommandResponse result = buildPartial();
3105         if (!result.isInitialized()) {
3106           throw newUninitializedMessageException(result);
3107         }
3108         return result;
3109       }
3110
3111       public com.openxc.BinaryMessages.CommandResponse buildPartial() {
3112         com.openxc.BinaryMessages.CommandResponse result = new com.openxc.BinaryMessages.CommandResponse(this);
3113         int from_bitField0_ = bitField0_;
3114         int to_bitField0_ = 0;
3115         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3116           to_bitField0_ |= 0x00000001;
3117         }
3118         result.type_ = type_;
3119         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3120           to_bitField0_ |= 0x00000002;
3121         }
3122         result.message_ = message_;
3123         result.bitField0_ = to_bitField0_;
3124         onBuilt();
3125         return result;
3126       }
3127
3128       public Builder mergeFrom(com.google.protobuf.Message other) {
3129         if (other instanceof com.openxc.BinaryMessages.CommandResponse) {
3130           return mergeFrom((com.openxc.BinaryMessages.CommandResponse)other);
3131         } else {
3132           super.mergeFrom(other);
3133           return this;
3134         }
3135       }
3136
3137       public Builder mergeFrom(com.openxc.BinaryMessages.CommandResponse other) {
3138         if (other == com.openxc.BinaryMessages.CommandResponse.getDefaultInstance()) return this;
3139         if (other.hasType()) {
3140           setType(other.getType());
3141         }
3142         if (other.hasMessage()) {
3143           bitField0_ |= 0x00000002;
3144           message_ = other.message_;
3145           onChanged();
3146         }
3147         this.mergeUnknownFields(other.getUnknownFields());
3148         return this;
3149       }
3150
3151       public final boolean isInitialized() {
3152         return true;
3153       }
3154
3155       public Builder mergeFrom(
3156           com.google.protobuf.CodedInputStream input,
3157           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3158           throws java.io.IOException {
3159         com.openxc.BinaryMessages.CommandResponse parsedMessage = null;
3160         try {
3161           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3162         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3163           parsedMessage = (com.openxc.BinaryMessages.CommandResponse) e.getUnfinishedMessage();
3164           throw e;
3165         } finally {
3166           if (parsedMessage != null) {
3167             mergeFrom(parsedMessage);
3168           }
3169         }
3170         return this;
3171       }
3172       private int bitField0_;
3173
3174       // optional .openxc.ControlCommand.Type type = 1;
3175       private com.openxc.BinaryMessages.ControlCommand.Type type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3176       /**
3177        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3178        */
3179       public boolean hasType() {
3180         return ((bitField0_ & 0x00000001) == 0x00000001);
3181       }
3182       /**
3183        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3184        */
3185       public com.openxc.BinaryMessages.ControlCommand.Type getType() {
3186         return type_;
3187       }
3188       /**
3189        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3190        */
3191       public Builder setType(com.openxc.BinaryMessages.ControlCommand.Type value) {
3192         if (value == null) {
3193           throw new NullPointerException();
3194         }
3195         bitField0_ |= 0x00000001;
3196         type_ = value;
3197         onChanged();
3198         return this;
3199       }
3200       /**
3201        * <code>optional .openxc.ControlCommand.Type type = 1;</code>
3202        */
3203       public Builder clearType() {
3204         bitField0_ = (bitField0_ & ~0x00000001);
3205         type_ = com.openxc.BinaryMessages.ControlCommand.Type.VERSION;
3206         onChanged();
3207         return this;
3208       }
3209
3210       // optional string message = 2;
3211       private java.lang.Object message_ = "";
3212       /**
3213        * <code>optional string message = 2;</code>
3214        */
3215       public boolean hasMessage() {
3216         return ((bitField0_ & 0x00000002) == 0x00000002);
3217       }
3218       /**
3219        * <code>optional string message = 2;</code>
3220        */
3221       public java.lang.String getMessage() {
3222         java.lang.Object ref = message_;
3223         if (!(ref instanceof java.lang.String)) {
3224           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3225               .toStringUtf8();
3226           message_ = s;
3227           return s;
3228         } else {
3229           return (java.lang.String) ref;
3230         }
3231       }
3232       /**
3233        * <code>optional string message = 2;</code>
3234        */
3235       public com.google.protobuf.ByteString
3236           getMessageBytes() {
3237         java.lang.Object ref = message_;
3238         if (ref instanceof String) {
3239           com.google.protobuf.ByteString b =
3240               com.google.protobuf.ByteString.copyFromUtf8(
3241                   (java.lang.String) ref);
3242           message_ = b;
3243           return b;
3244         } else {
3245           return (com.google.protobuf.ByteString) ref;
3246         }
3247       }
3248       /**
3249        * <code>optional string message = 2;</code>
3250        */
3251       public Builder setMessage(
3252           java.lang.String value) {
3253         if (value == null) {
3254     throw new NullPointerException();
3255   }
3256   bitField0_ |= 0x00000002;
3257         message_ = value;
3258         onChanged();
3259         return this;
3260       }
3261       /**
3262        * <code>optional string message = 2;</code>
3263        */
3264       public Builder clearMessage() {
3265         bitField0_ = (bitField0_ & ~0x00000002);
3266         message_ = getDefaultInstance().getMessage();
3267         onChanged();
3268         return this;
3269       }
3270       /**
3271        * <code>optional string message = 2;</code>
3272        */
3273       public Builder setMessageBytes(
3274           com.google.protobuf.ByteString value) {
3275         if (value == null) {
3276     throw new NullPointerException();
3277   }
3278   bitField0_ |= 0x00000002;
3279         message_ = value;
3280         onChanged();
3281         return this;
3282       }
3283
3284       // @@protoc_insertion_point(builder_scope:openxc.CommandResponse)
3285     }
3286
3287     static {
3288       defaultInstance = new CommandResponse(true);
3289       defaultInstance.initFields();
3290     }
3291
3292     // @@protoc_insertion_point(class_scope:openxc.CommandResponse)
3293   }
3294
3295   public interface DiagnosticRequestOrBuilder
3296       extends com.google.protobuf.MessageOrBuilder {
3297
3298     // optional int32 bus = 1;
3299     /**
3300      * <code>optional int32 bus = 1;</code>
3301      */
3302     boolean hasBus();
3303     /**
3304      * <code>optional int32 bus = 1;</code>
3305      */
3306     int getBus();
3307
3308     // optional uint32 message_id = 2;
3309     /**
3310      * <code>optional uint32 message_id = 2;</code>
3311      */
3312     boolean hasMessageId();
3313     /**
3314      * <code>optional uint32 message_id = 2;</code>
3315      */
3316     int getMessageId();
3317
3318     // optional uint32 mode = 3;
3319     /**
3320      * <code>optional uint32 mode = 3;</code>
3321      */
3322     boolean hasMode();
3323     /**
3324      * <code>optional uint32 mode = 3;</code>
3325      */
3326     int getMode();
3327
3328     // optional uint32 pid = 4;
3329     /**
3330      * <code>optional uint32 pid = 4;</code>
3331      */
3332     boolean hasPid();
3333     /**
3334      * <code>optional uint32 pid = 4;</code>
3335      */
3336     int getPid();
3337
3338     // optional bytes payload = 5;
3339     /**
3340      * <code>optional bytes payload = 5;</code>
3341      *
3342      * <pre>
3343      * TODO we are capping this at 8 bytes for now - need to change when we
3344      * support multi-frame responses
3345      * </pre>
3346      */
3347     boolean hasPayload();
3348     /**
3349      * <code>optional bytes payload = 5;</code>
3350      *
3351      * <pre>
3352      * TODO we are capping this at 8 bytes for now - need to change when we
3353      * support multi-frame responses
3354      * </pre>
3355      */
3356     com.google.protobuf.ByteString getPayload();
3357
3358     // optional bool multiple_responses = 6;
3359     /**
3360      * <code>optional bool multiple_responses = 6;</code>
3361      */
3362     boolean hasMultipleResponses();
3363     /**
3364      * <code>optional bool multiple_responses = 6;</code>
3365      */
3366     boolean getMultipleResponses();
3367
3368     // optional double frequency = 7;
3369     /**
3370      * <code>optional double frequency = 7;</code>
3371      */
3372     boolean hasFrequency();
3373     /**
3374      * <code>optional double frequency = 7;</code>
3375      */
3376     double getFrequency();
3377
3378     // optional string name = 8;
3379     /**
3380      * <code>optional string name = 8;</code>
3381      */
3382     boolean hasName();
3383     /**
3384      * <code>optional string name = 8;</code>
3385      */
3386     java.lang.String getName();
3387     /**
3388      * <code>optional string name = 8;</code>
3389      */
3390     com.google.protobuf.ByteString
3391         getNameBytes();
3392
3393     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
3394     /**
3395      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3396      */
3397     boolean hasDecodedType();
3398     /**
3399      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3400      */
3401     com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType();
3402
3403     // optional .openxc.DiagnosticRequest.Action action = 10;
3404     /**
3405      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3406      */
3407     boolean hasAction();
3408     /**
3409      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3410      */
3411     com.openxc.BinaryMessages.DiagnosticRequest.Action getAction();
3412   }
3413   /**
3414    * Protobuf type {@code openxc.DiagnosticRequest}
3415    */
3416   public static final class DiagnosticRequest extends
3417       com.google.protobuf.GeneratedMessage
3418       implements DiagnosticRequestOrBuilder {
3419     // Use DiagnosticRequest.newBuilder() to construct.
3420     private DiagnosticRequest(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3421       super(builder);
3422       this.unknownFields = builder.getUnknownFields();
3423     }
3424     private DiagnosticRequest(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3425
3426     private static final DiagnosticRequest defaultInstance;
3427     public static DiagnosticRequest getDefaultInstance() {
3428       return defaultInstance;
3429     }
3430
3431     public DiagnosticRequest getDefaultInstanceForType() {
3432       return defaultInstance;
3433     }
3434
3435     private final com.google.protobuf.UnknownFieldSet unknownFields;
3436     @java.lang.Override
3437     public final com.google.protobuf.UnknownFieldSet
3438         getUnknownFields() {
3439       return this.unknownFields;
3440     }
3441     private DiagnosticRequest(
3442         com.google.protobuf.CodedInputStream input,
3443         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3444         throws com.google.protobuf.InvalidProtocolBufferException {
3445       initFields();
3446       int mutable_bitField0_ = 0;
3447       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3448           com.google.protobuf.UnknownFieldSet.newBuilder();
3449       try {
3450         boolean done = false;
3451         while (!done) {
3452           int tag = input.readTag();
3453           switch (tag) {
3454             case 0:
3455               done = true;
3456               break;
3457             default: {
3458               if (!parseUnknownField(input, unknownFields,
3459                                      extensionRegistry, tag)) {
3460                 done = true;
3461               }
3462               break;
3463             }
3464             case 8: {
3465               bitField0_ |= 0x00000001;
3466               bus_ = input.readInt32();
3467               break;
3468             }
3469             case 16: {
3470               bitField0_ |= 0x00000002;
3471               messageId_ = input.readUInt32();
3472               break;
3473             }
3474             case 24: {
3475               bitField0_ |= 0x00000004;
3476               mode_ = input.readUInt32();
3477               break;
3478             }
3479             case 32: {
3480               bitField0_ |= 0x00000008;
3481               pid_ = input.readUInt32();
3482               break;
3483             }
3484             case 42: {
3485               bitField0_ |= 0x00000010;
3486               payload_ = input.readBytes();
3487               break;
3488             }
3489             case 48: {
3490               bitField0_ |= 0x00000020;
3491               multipleResponses_ = input.readBool();
3492               break;
3493             }
3494             case 57: {
3495               bitField0_ |= 0x00000040;
3496               frequency_ = input.readDouble();
3497               break;
3498             }
3499             case 66: {
3500               bitField0_ |= 0x00000080;
3501               name_ = input.readBytes();
3502               break;
3503             }
3504             case 72: {
3505               int rawValue = input.readEnum();
3506               com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.valueOf(rawValue);
3507               if (value == null) {
3508                 unknownFields.mergeVarintField(9, rawValue);
3509               } else {
3510                 bitField0_ |= 0x00000100;
3511                 decodedType_ = value;
3512               }
3513               break;
3514             }
3515             case 80: {
3516               int rawValue = input.readEnum();
3517               com.openxc.BinaryMessages.DiagnosticRequest.Action value = com.openxc.BinaryMessages.DiagnosticRequest.Action.valueOf(rawValue);
3518               if (value == null) {
3519                 unknownFields.mergeVarintField(10, rawValue);
3520               } else {
3521                 bitField0_ |= 0x00000200;
3522                 action_ = value;
3523               }
3524               break;
3525             }
3526           }
3527         }
3528       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3529         throw e.setUnfinishedMessage(this);
3530       } catch (java.io.IOException e) {
3531         throw new com.google.protobuf.InvalidProtocolBufferException(
3532             e.getMessage()).setUnfinishedMessage(this);
3533       } finally {
3534         this.unknownFields = unknownFields.build();
3535         makeExtensionsImmutable();
3536       }
3537     }
3538     public static final com.google.protobuf.Descriptors.Descriptor
3539         getDescriptor() {
3540       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
3541     }
3542
3543     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3544         internalGetFieldAccessorTable() {
3545       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
3546           .ensureFieldAccessorsInitialized(
3547               com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
3548     }
3549
3550     public static com.google.protobuf.Parser<DiagnosticRequest> PARSER =
3551         new com.google.protobuf.AbstractParser<DiagnosticRequest>() {
3552       public DiagnosticRequest parsePartialFrom(
3553           com.google.protobuf.CodedInputStream input,
3554           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3555           throws com.google.protobuf.InvalidProtocolBufferException {
3556         return new DiagnosticRequest(input, extensionRegistry);
3557       }
3558     };
3559
3560     @java.lang.Override
3561     public com.google.protobuf.Parser<DiagnosticRequest> getParserForType() {
3562       return PARSER;
3563     }
3564
3565     /**
3566      * Protobuf enum {@code openxc.DiagnosticRequest.DecodedType}
3567      */
3568     public enum DecodedType
3569         implements com.google.protobuf.ProtocolMessageEnum {
3570       /**
3571        * <code>NONE = 1;</code>
3572        */
3573       NONE(0, 1),
3574       /**
3575        * <code>OBD2 = 2;</code>
3576        */
3577       OBD2(1, 2),
3578       ;
3579
3580       /**
3581        * <code>NONE = 1;</code>
3582        */
3583       public static final int NONE_VALUE = 1;
3584       /**
3585        * <code>OBD2 = 2;</code>
3586        */
3587       public static final int OBD2_VALUE = 2;
3588
3589
3590       public final int getNumber() { return value; }
3591
3592       public static DecodedType valueOf(int value) {
3593         switch (value) {
3594           case 1: return NONE;
3595           case 2: return OBD2;
3596           default: return null;
3597         }
3598       }
3599
3600       public static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
3601           internalGetValueMap() {
3602         return internalValueMap;
3603       }
3604       private static com.google.protobuf.Internal.EnumLiteMap<DecodedType>
3605           internalValueMap =
3606             new com.google.protobuf.Internal.EnumLiteMap<DecodedType>() {
3607               public DecodedType findValueByNumber(int number) {
3608                 return DecodedType.valueOf(number);
3609               }
3610             };
3611
3612       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3613           getValueDescriptor() {
3614         return getDescriptor().getValues().get(index);
3615       }
3616       public final com.google.protobuf.Descriptors.EnumDescriptor
3617           getDescriptorForType() {
3618         return getDescriptor();
3619       }
3620       public static final com.google.protobuf.Descriptors.EnumDescriptor
3621           getDescriptor() {
3622         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(0);
3623       }
3624
3625       private static final DecodedType[] VALUES = values();
3626
3627       public static DecodedType valueOf(
3628           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3629         if (desc.getType() != getDescriptor()) {
3630           throw new java.lang.IllegalArgumentException(
3631             "EnumValueDescriptor is not for this type.");
3632         }
3633         return VALUES[desc.getIndex()];
3634       }
3635
3636       private final int index;
3637       private final int value;
3638
3639       private DecodedType(int index, int value) {
3640         this.index = index;
3641         this.value = value;
3642       }
3643
3644       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.DecodedType)
3645     }
3646
3647     /**
3648      * Protobuf enum {@code openxc.DiagnosticRequest.Action}
3649      */
3650     public enum Action
3651         implements com.google.protobuf.ProtocolMessageEnum {
3652       /**
3653        * <code>ADD = 1;</code>
3654        */
3655       ADD(0, 1),
3656       /**
3657        * <code>CANCEL = 3;</code>
3658        */
3659       CANCEL(1, 3),
3660       ;
3661
3662       /**
3663        * <code>ADD = 1;</code>
3664        */
3665       public static final int ADD_VALUE = 1;
3666       /**
3667        * <code>CANCEL = 3;</code>
3668        */
3669       public static final int CANCEL_VALUE = 3;
3670
3671
3672       public final int getNumber() { return value; }
3673
3674       public static Action valueOf(int value) {
3675         switch (value) {
3676           case 1: return ADD;
3677           case 3: return CANCEL;
3678           default: return null;
3679         }
3680       }
3681
3682       public static com.google.protobuf.Internal.EnumLiteMap<Action>
3683           internalGetValueMap() {
3684         return internalValueMap;
3685       }
3686       private static com.google.protobuf.Internal.EnumLiteMap<Action>
3687           internalValueMap =
3688             new com.google.protobuf.Internal.EnumLiteMap<Action>() {
3689               public Action findValueByNumber(int number) {
3690                 return Action.valueOf(number);
3691               }
3692             };
3693
3694       public final com.google.protobuf.Descriptors.EnumValueDescriptor
3695           getValueDescriptor() {
3696         return getDescriptor().getValues().get(index);
3697       }
3698       public final com.google.protobuf.Descriptors.EnumDescriptor
3699           getDescriptorForType() {
3700         return getDescriptor();
3701       }
3702       public static final com.google.protobuf.Descriptors.EnumDescriptor
3703           getDescriptor() {
3704         return com.openxc.BinaryMessages.DiagnosticRequest.getDescriptor().getEnumTypes().get(1);
3705       }
3706
3707       private static final Action[] VALUES = values();
3708
3709       public static Action valueOf(
3710           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3711         if (desc.getType() != getDescriptor()) {
3712           throw new java.lang.IllegalArgumentException(
3713             "EnumValueDescriptor is not for this type.");
3714         }
3715         return VALUES[desc.getIndex()];
3716       }
3717
3718       private final int index;
3719       private final int value;
3720
3721       private Action(int index, int value) {
3722         this.index = index;
3723         this.value = value;
3724       }
3725
3726       // @@protoc_insertion_point(enum_scope:openxc.DiagnosticRequest.Action)
3727     }
3728
3729     private int bitField0_;
3730     // optional int32 bus = 1;
3731     public static final int BUS_FIELD_NUMBER = 1;
3732     private int bus_;
3733     /**
3734      * <code>optional int32 bus = 1;</code>
3735      */
3736     public boolean hasBus() {
3737       return ((bitField0_ & 0x00000001) == 0x00000001);
3738     }
3739     /**
3740      * <code>optional int32 bus = 1;</code>
3741      */
3742     public int getBus() {
3743       return bus_;
3744     }
3745
3746     // optional uint32 message_id = 2;
3747     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
3748     private int messageId_;
3749     /**
3750      * <code>optional uint32 message_id = 2;</code>
3751      */
3752     public boolean hasMessageId() {
3753       return ((bitField0_ & 0x00000002) == 0x00000002);
3754     }
3755     /**
3756      * <code>optional uint32 message_id = 2;</code>
3757      */
3758     public int getMessageId() {
3759       return messageId_;
3760     }
3761
3762     // optional uint32 mode = 3;
3763     public static final int MODE_FIELD_NUMBER = 3;
3764     private int mode_;
3765     /**
3766      * <code>optional uint32 mode = 3;</code>
3767      */
3768     public boolean hasMode() {
3769       return ((bitField0_ & 0x00000004) == 0x00000004);
3770     }
3771     /**
3772      * <code>optional uint32 mode = 3;</code>
3773      */
3774     public int getMode() {
3775       return mode_;
3776     }
3777
3778     // optional uint32 pid = 4;
3779     public static final int PID_FIELD_NUMBER = 4;
3780     private int pid_;
3781     /**
3782      * <code>optional uint32 pid = 4;</code>
3783      */
3784     public boolean hasPid() {
3785       return ((bitField0_ & 0x00000008) == 0x00000008);
3786     }
3787     /**
3788      * <code>optional uint32 pid = 4;</code>
3789      */
3790     public int getPid() {
3791       return pid_;
3792     }
3793
3794     // optional bytes payload = 5;
3795     public static final int PAYLOAD_FIELD_NUMBER = 5;
3796     private com.google.protobuf.ByteString payload_;
3797     /**
3798      * <code>optional bytes payload = 5;</code>
3799      *
3800      * <pre>
3801      * TODO we are capping this at 8 bytes for now - need to change when we
3802      * support multi-frame responses
3803      * </pre>
3804      */
3805     public boolean hasPayload() {
3806       return ((bitField0_ & 0x00000010) == 0x00000010);
3807     }
3808     /**
3809      * <code>optional bytes payload = 5;</code>
3810      *
3811      * <pre>
3812      * TODO we are capping this at 8 bytes for now - need to change when we
3813      * support multi-frame responses
3814      * </pre>
3815      */
3816     public com.google.protobuf.ByteString getPayload() {
3817       return payload_;
3818     }
3819
3820     // optional bool multiple_responses = 6;
3821     public static final int MULTIPLE_RESPONSES_FIELD_NUMBER = 6;
3822     private boolean multipleResponses_;
3823     /**
3824      * <code>optional bool multiple_responses = 6;</code>
3825      */
3826     public boolean hasMultipleResponses() {
3827       return ((bitField0_ & 0x00000020) == 0x00000020);
3828     }
3829     /**
3830      * <code>optional bool multiple_responses = 6;</code>
3831      */
3832     public boolean getMultipleResponses() {
3833       return multipleResponses_;
3834     }
3835
3836     // optional double frequency = 7;
3837     public static final int FREQUENCY_FIELD_NUMBER = 7;
3838     private double frequency_;
3839     /**
3840      * <code>optional double frequency = 7;</code>
3841      */
3842     public boolean hasFrequency() {
3843       return ((bitField0_ & 0x00000040) == 0x00000040);
3844     }
3845     /**
3846      * <code>optional double frequency = 7;</code>
3847      */
3848     public double getFrequency() {
3849       return frequency_;
3850     }
3851
3852     // optional string name = 8;
3853     public static final int NAME_FIELD_NUMBER = 8;
3854     private java.lang.Object name_;
3855     /**
3856      * <code>optional string name = 8;</code>
3857      */
3858     public boolean hasName() {
3859       return ((bitField0_ & 0x00000080) == 0x00000080);
3860     }
3861     /**
3862      * <code>optional string name = 8;</code>
3863      */
3864     public java.lang.String getName() {
3865       java.lang.Object ref = name_;
3866       if (ref instanceof java.lang.String) {
3867         return (java.lang.String) ref;
3868       } else {
3869         com.google.protobuf.ByteString bs =
3870             (com.google.protobuf.ByteString) ref;
3871         java.lang.String s = bs.toStringUtf8();
3872         if (bs.isValidUtf8()) {
3873           name_ = s;
3874         }
3875         return s;
3876       }
3877     }
3878     /**
3879      * <code>optional string name = 8;</code>
3880      */
3881     public com.google.protobuf.ByteString
3882         getNameBytes() {
3883       java.lang.Object ref = name_;
3884       if (ref instanceof java.lang.String) {
3885         com.google.protobuf.ByteString b =
3886             com.google.protobuf.ByteString.copyFromUtf8(
3887                 (java.lang.String) ref);
3888         name_ = b;
3889         return b;
3890       } else {
3891         return (com.google.protobuf.ByteString) ref;
3892       }
3893     }
3894
3895     // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
3896     public static final int DECODED_TYPE_FIELD_NUMBER = 9;
3897     private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_;
3898     /**
3899      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3900      */
3901     public boolean hasDecodedType() {
3902       return ((bitField0_ & 0x00000100) == 0x00000100);
3903     }
3904     /**
3905      * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
3906      */
3907     public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
3908       return decodedType_;
3909     }
3910
3911     // optional .openxc.DiagnosticRequest.Action action = 10;
3912     public static final int ACTION_FIELD_NUMBER = 10;
3913     private com.openxc.BinaryMessages.DiagnosticRequest.Action action_;
3914     /**
3915      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3916      */
3917     public boolean hasAction() {
3918       return ((bitField0_ & 0x00000200) == 0x00000200);
3919     }
3920     /**
3921      * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
3922      */
3923     public com.openxc.BinaryMessages.DiagnosticRequest.Action getAction() {
3924       return action_;
3925     }
3926
3927     private void initFields() {
3928       bus_ = 0;
3929       messageId_ = 0;
3930       mode_ = 0;
3931       pid_ = 0;
3932       payload_ = com.google.protobuf.ByteString.EMPTY;
3933       multipleResponses_ = false;
3934       frequency_ = 0D;
3935       name_ = "";
3936       decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
3937       action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
3938     }
3939     private byte memoizedIsInitialized = -1;
3940     public final boolean isInitialized() {
3941       byte isInitialized = memoizedIsInitialized;
3942       if (isInitialized != -1) return isInitialized == 1;
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.writeInt32(1, bus_);
3953       }
3954       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3955         output.writeUInt32(2, messageId_);
3956       }
3957       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3958         output.writeUInt32(3, mode_);
3959       }
3960       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3961         output.writeUInt32(4, pid_);
3962       }
3963       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3964         output.writeBytes(5, payload_);
3965       }
3966       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3967         output.writeBool(6, multipleResponses_);
3968       }
3969       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3970         output.writeDouble(7, frequency_);
3971       }
3972       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3973         output.writeBytes(8, getNameBytes());
3974       }
3975       if (((bitField0_ & 0x00000100) == 0x00000100)) {
3976         output.writeEnum(9, decodedType_.getNumber());
3977       }
3978       if (((bitField0_ & 0x00000200) == 0x00000200)) {
3979         output.writeEnum(10, action_.getNumber());
3980       }
3981       getUnknownFields().writeTo(output);
3982     }
3983
3984     private int memoizedSerializedSize = -1;
3985     public int getSerializedSize() {
3986       int size = memoizedSerializedSize;
3987       if (size != -1) return size;
3988
3989       size = 0;
3990       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3991         size += com.google.protobuf.CodedOutputStream
3992           .computeInt32Size(1, bus_);
3993       }
3994       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3995         size += com.google.protobuf.CodedOutputStream
3996           .computeUInt32Size(2, messageId_);
3997       }
3998       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3999         size += com.google.protobuf.CodedOutputStream
4000           .computeUInt32Size(3, mode_);
4001       }
4002       if (((bitField0_ & 0x00000008) == 0x00000008)) {
4003         size += com.google.protobuf.CodedOutputStream
4004           .computeUInt32Size(4, pid_);
4005       }
4006       if (((bitField0_ & 0x00000010) == 0x00000010)) {
4007         size += com.google.protobuf.CodedOutputStream
4008           .computeBytesSize(5, payload_);
4009       }
4010       if (((bitField0_ & 0x00000020) == 0x00000020)) {
4011         size += com.google.protobuf.CodedOutputStream
4012           .computeBoolSize(6, multipleResponses_);
4013       }
4014       if (((bitField0_ & 0x00000040) == 0x00000040)) {
4015         size += com.google.protobuf.CodedOutputStream
4016           .computeDoubleSize(7, frequency_);
4017       }
4018       if (((bitField0_ & 0x00000080) == 0x00000080)) {
4019         size += com.google.protobuf.CodedOutputStream
4020           .computeBytesSize(8, getNameBytes());
4021       }
4022       if (((bitField0_ & 0x00000100) == 0x00000100)) {
4023         size += com.google.protobuf.CodedOutputStream
4024           .computeEnumSize(9, decodedType_.getNumber());
4025       }
4026       if (((bitField0_ & 0x00000200) == 0x00000200)) {
4027         size += com.google.protobuf.CodedOutputStream
4028           .computeEnumSize(10, action_.getNumber());
4029       }
4030       size += getUnknownFields().getSerializedSize();
4031       memoizedSerializedSize = size;
4032       return size;
4033     }
4034
4035     private static final long serialVersionUID = 0L;
4036     @java.lang.Override
4037     protected java.lang.Object writeReplace()
4038         throws java.io.ObjectStreamException {
4039       return super.writeReplace();
4040     }
4041
4042     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4043         com.google.protobuf.ByteString data)
4044         throws com.google.protobuf.InvalidProtocolBufferException {
4045       return PARSER.parseFrom(data);
4046     }
4047     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4048         com.google.protobuf.ByteString data,
4049         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4050         throws com.google.protobuf.InvalidProtocolBufferException {
4051       return PARSER.parseFrom(data, extensionRegistry);
4052     }
4053     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(byte[] data)
4054         throws com.google.protobuf.InvalidProtocolBufferException {
4055       return PARSER.parseFrom(data);
4056     }
4057     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4058         byte[] data,
4059         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4060         throws com.google.protobuf.InvalidProtocolBufferException {
4061       return PARSER.parseFrom(data, extensionRegistry);
4062     }
4063     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(java.io.InputStream input)
4064         throws java.io.IOException {
4065       return PARSER.parseFrom(input);
4066     }
4067     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4068         java.io.InputStream input,
4069         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4070         throws java.io.IOException {
4071       return PARSER.parseFrom(input, extensionRegistry);
4072     }
4073     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(java.io.InputStream input)
4074         throws java.io.IOException {
4075       return PARSER.parseDelimitedFrom(input);
4076     }
4077     public static com.openxc.BinaryMessages.DiagnosticRequest parseDelimitedFrom(
4078         java.io.InputStream input,
4079         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4080         throws java.io.IOException {
4081       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4082     }
4083     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4084         com.google.protobuf.CodedInputStream input)
4085         throws java.io.IOException {
4086       return PARSER.parseFrom(input);
4087     }
4088     public static com.openxc.BinaryMessages.DiagnosticRequest parseFrom(
4089         com.google.protobuf.CodedInputStream input,
4090         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4091         throws java.io.IOException {
4092       return PARSER.parseFrom(input, extensionRegistry);
4093     }
4094
4095     public static Builder newBuilder() { return Builder.create(); }
4096     public Builder newBuilderForType() { return newBuilder(); }
4097     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticRequest prototype) {
4098       return newBuilder().mergeFrom(prototype);
4099     }
4100     public Builder toBuilder() { return newBuilder(this); }
4101
4102     @java.lang.Override
4103     protected Builder newBuilderForType(
4104         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4105       Builder builder = new Builder(parent);
4106       return builder;
4107     }
4108     /**
4109      * Protobuf type {@code openxc.DiagnosticRequest}
4110      */
4111     public static final class Builder extends
4112         com.google.protobuf.GeneratedMessage.Builder<Builder>
4113        implements com.openxc.BinaryMessages.DiagnosticRequestOrBuilder {
4114       public static final com.google.protobuf.Descriptors.Descriptor
4115           getDescriptor() {
4116         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4117       }
4118
4119       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4120           internalGetFieldAccessorTable() {
4121         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_fieldAccessorTable
4122             .ensureFieldAccessorsInitialized(
4123                 com.openxc.BinaryMessages.DiagnosticRequest.class, com.openxc.BinaryMessages.DiagnosticRequest.Builder.class);
4124       }
4125
4126       // Construct using com.openxc.BinaryMessages.DiagnosticRequest.newBuilder()
4127       private Builder() {
4128         maybeForceBuilderInitialization();
4129       }
4130
4131       private Builder(
4132           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4133         super(parent);
4134         maybeForceBuilderInitialization();
4135       }
4136       private void maybeForceBuilderInitialization() {
4137         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4138         }
4139       }
4140       private static Builder create() {
4141         return new Builder();
4142       }
4143
4144       public Builder clear() {
4145         super.clear();
4146         bus_ = 0;
4147         bitField0_ = (bitField0_ & ~0x00000001);
4148         messageId_ = 0;
4149         bitField0_ = (bitField0_ & ~0x00000002);
4150         mode_ = 0;
4151         bitField0_ = (bitField0_ & ~0x00000004);
4152         pid_ = 0;
4153         bitField0_ = (bitField0_ & ~0x00000008);
4154         payload_ = com.google.protobuf.ByteString.EMPTY;
4155         bitField0_ = (bitField0_ & ~0x00000010);
4156         multipleResponses_ = false;
4157         bitField0_ = (bitField0_ & ~0x00000020);
4158         frequency_ = 0D;
4159         bitField0_ = (bitField0_ & ~0x00000040);
4160         name_ = "";
4161         bitField0_ = (bitField0_ & ~0x00000080);
4162         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4163         bitField0_ = (bitField0_ & ~0x00000100);
4164         action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
4165         bitField0_ = (bitField0_ & ~0x00000200);
4166         return this;
4167       }
4168
4169       public Builder clone() {
4170         return create().mergeFrom(buildPartial());
4171       }
4172
4173       public com.google.protobuf.Descriptors.Descriptor
4174           getDescriptorForType() {
4175         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticRequest_descriptor;
4176       }
4177
4178       public com.openxc.BinaryMessages.DiagnosticRequest getDefaultInstanceForType() {
4179         return com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance();
4180       }
4181
4182       public com.openxc.BinaryMessages.DiagnosticRequest build() {
4183         com.openxc.BinaryMessages.DiagnosticRequest result = buildPartial();
4184         if (!result.isInitialized()) {
4185           throw newUninitializedMessageException(result);
4186         }
4187         return result;
4188       }
4189
4190       public com.openxc.BinaryMessages.DiagnosticRequest buildPartial() {
4191         com.openxc.BinaryMessages.DiagnosticRequest result = new com.openxc.BinaryMessages.DiagnosticRequest(this);
4192         int from_bitField0_ = bitField0_;
4193         int to_bitField0_ = 0;
4194         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4195           to_bitField0_ |= 0x00000001;
4196         }
4197         result.bus_ = bus_;
4198         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4199           to_bitField0_ |= 0x00000002;
4200         }
4201         result.messageId_ = messageId_;
4202         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4203           to_bitField0_ |= 0x00000004;
4204         }
4205         result.mode_ = mode_;
4206         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
4207           to_bitField0_ |= 0x00000008;
4208         }
4209         result.pid_ = pid_;
4210         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
4211           to_bitField0_ |= 0x00000010;
4212         }
4213         result.payload_ = payload_;
4214         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
4215           to_bitField0_ |= 0x00000020;
4216         }
4217         result.multipleResponses_ = multipleResponses_;
4218         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
4219           to_bitField0_ |= 0x00000040;
4220         }
4221         result.frequency_ = frequency_;
4222         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
4223           to_bitField0_ |= 0x00000080;
4224         }
4225         result.name_ = name_;
4226         if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
4227           to_bitField0_ |= 0x00000100;
4228         }
4229         result.decodedType_ = decodedType_;
4230         if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
4231           to_bitField0_ |= 0x00000200;
4232         }
4233         result.action_ = action_;
4234         result.bitField0_ = to_bitField0_;
4235         onBuilt();
4236         return result;
4237       }
4238
4239       public Builder mergeFrom(com.google.protobuf.Message other) {
4240         if (other instanceof com.openxc.BinaryMessages.DiagnosticRequest) {
4241           return mergeFrom((com.openxc.BinaryMessages.DiagnosticRequest)other);
4242         } else {
4243           super.mergeFrom(other);
4244           return this;
4245         }
4246       }
4247
4248       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticRequest other) {
4249         if (other == com.openxc.BinaryMessages.DiagnosticRequest.getDefaultInstance()) return this;
4250         if (other.hasBus()) {
4251           setBus(other.getBus());
4252         }
4253         if (other.hasMessageId()) {
4254           setMessageId(other.getMessageId());
4255         }
4256         if (other.hasMode()) {
4257           setMode(other.getMode());
4258         }
4259         if (other.hasPid()) {
4260           setPid(other.getPid());
4261         }
4262         if (other.hasPayload()) {
4263           setPayload(other.getPayload());
4264         }
4265         if (other.hasMultipleResponses()) {
4266           setMultipleResponses(other.getMultipleResponses());
4267         }
4268         if (other.hasFrequency()) {
4269           setFrequency(other.getFrequency());
4270         }
4271         if (other.hasName()) {
4272           bitField0_ |= 0x00000080;
4273           name_ = other.name_;
4274           onChanged();
4275         }
4276         if (other.hasDecodedType()) {
4277           setDecodedType(other.getDecodedType());
4278         }
4279         if (other.hasAction()) {
4280           setAction(other.getAction());
4281         }
4282         this.mergeUnknownFields(other.getUnknownFields());
4283         return this;
4284       }
4285
4286       public final boolean isInitialized() {
4287         return true;
4288       }
4289
4290       public Builder mergeFrom(
4291           com.google.protobuf.CodedInputStream input,
4292           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4293           throws java.io.IOException {
4294         com.openxc.BinaryMessages.DiagnosticRequest parsedMessage = null;
4295         try {
4296           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4297         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4298           parsedMessage = (com.openxc.BinaryMessages.DiagnosticRequest) e.getUnfinishedMessage();
4299           throw e;
4300         } finally {
4301           if (parsedMessage != null) {
4302             mergeFrom(parsedMessage);
4303           }
4304         }
4305         return this;
4306       }
4307       private int bitField0_;
4308
4309       // optional int32 bus = 1;
4310       private int bus_ ;
4311       /**
4312        * <code>optional int32 bus = 1;</code>
4313        */
4314       public boolean hasBus() {
4315         return ((bitField0_ & 0x00000001) == 0x00000001);
4316       }
4317       /**
4318        * <code>optional int32 bus = 1;</code>
4319        */
4320       public int getBus() {
4321         return bus_;
4322       }
4323       /**
4324        * <code>optional int32 bus = 1;</code>
4325        */
4326       public Builder setBus(int value) {
4327         bitField0_ |= 0x00000001;
4328         bus_ = value;
4329         onChanged();
4330         return this;
4331       }
4332       /**
4333        * <code>optional int32 bus = 1;</code>
4334        */
4335       public Builder clearBus() {
4336         bitField0_ = (bitField0_ & ~0x00000001);
4337         bus_ = 0;
4338         onChanged();
4339         return this;
4340       }
4341
4342       // optional uint32 message_id = 2;
4343       private int messageId_ ;
4344       /**
4345        * <code>optional uint32 message_id = 2;</code>
4346        */
4347       public boolean hasMessageId() {
4348         return ((bitField0_ & 0x00000002) == 0x00000002);
4349       }
4350       /**
4351        * <code>optional uint32 message_id = 2;</code>
4352        */
4353       public int getMessageId() {
4354         return messageId_;
4355       }
4356       /**
4357        * <code>optional uint32 message_id = 2;</code>
4358        */
4359       public Builder setMessageId(int value) {
4360         bitField0_ |= 0x00000002;
4361         messageId_ = value;
4362         onChanged();
4363         return this;
4364       }
4365       /**
4366        * <code>optional uint32 message_id = 2;</code>
4367        */
4368       public Builder clearMessageId() {
4369         bitField0_ = (bitField0_ & ~0x00000002);
4370         messageId_ = 0;
4371         onChanged();
4372         return this;
4373       }
4374
4375       // optional uint32 mode = 3;
4376       private int mode_ ;
4377       /**
4378        * <code>optional uint32 mode = 3;</code>
4379        */
4380       public boolean hasMode() {
4381         return ((bitField0_ & 0x00000004) == 0x00000004);
4382       }
4383       /**
4384        * <code>optional uint32 mode = 3;</code>
4385        */
4386       public int getMode() {
4387         return mode_;
4388       }
4389       /**
4390        * <code>optional uint32 mode = 3;</code>
4391        */
4392       public Builder setMode(int value) {
4393         bitField0_ |= 0x00000004;
4394         mode_ = value;
4395         onChanged();
4396         return this;
4397       }
4398       /**
4399        * <code>optional uint32 mode = 3;</code>
4400        */
4401       public Builder clearMode() {
4402         bitField0_ = (bitField0_ & ~0x00000004);
4403         mode_ = 0;
4404         onChanged();
4405         return this;
4406       }
4407
4408       // optional uint32 pid = 4;
4409       private int pid_ ;
4410       /**
4411        * <code>optional uint32 pid = 4;</code>
4412        */
4413       public boolean hasPid() {
4414         return ((bitField0_ & 0x00000008) == 0x00000008);
4415       }
4416       /**
4417        * <code>optional uint32 pid = 4;</code>
4418        */
4419       public int getPid() {
4420         return pid_;
4421       }
4422       /**
4423        * <code>optional uint32 pid = 4;</code>
4424        */
4425       public Builder setPid(int value) {
4426         bitField0_ |= 0x00000008;
4427         pid_ = value;
4428         onChanged();
4429         return this;
4430       }
4431       /**
4432        * <code>optional uint32 pid = 4;</code>
4433        */
4434       public Builder clearPid() {
4435         bitField0_ = (bitField0_ & ~0x00000008);
4436         pid_ = 0;
4437         onChanged();
4438         return this;
4439       }
4440
4441       // optional bytes payload = 5;
4442       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
4443       /**
4444        * <code>optional bytes payload = 5;</code>
4445        *
4446        * <pre>
4447        * TODO we are capping this at 8 bytes for now - need to change when we
4448        * support multi-frame responses
4449        * </pre>
4450        */
4451       public boolean hasPayload() {
4452         return ((bitField0_ & 0x00000010) == 0x00000010);
4453       }
4454       /**
4455        * <code>optional bytes payload = 5;</code>
4456        *
4457        * <pre>
4458        * TODO we are capping this at 8 bytes for now - need to change when we
4459        * support multi-frame responses
4460        * </pre>
4461        */
4462       public com.google.protobuf.ByteString getPayload() {
4463         return payload_;
4464       }
4465       /**
4466        * <code>optional bytes payload = 5;</code>
4467        *
4468        * <pre>
4469        * TODO we are capping this at 8 bytes for now - need to change when we
4470        * support multi-frame responses
4471        * </pre>
4472        */
4473       public Builder setPayload(com.google.protobuf.ByteString value) {
4474         if (value == null) {
4475     throw new NullPointerException();
4476   }
4477   bitField0_ |= 0x00000010;
4478         payload_ = value;
4479         onChanged();
4480         return this;
4481       }
4482       /**
4483        * <code>optional bytes payload = 5;</code>
4484        *
4485        * <pre>
4486        * TODO we are capping this at 8 bytes for now - need to change when we
4487        * support multi-frame responses
4488        * </pre>
4489        */
4490       public Builder clearPayload() {
4491         bitField0_ = (bitField0_ & ~0x00000010);
4492         payload_ = getDefaultInstance().getPayload();
4493         onChanged();
4494         return this;
4495       }
4496
4497       // optional bool multiple_responses = 6;
4498       private boolean multipleResponses_ ;
4499       /**
4500        * <code>optional bool multiple_responses = 6;</code>
4501        */
4502       public boolean hasMultipleResponses() {
4503         return ((bitField0_ & 0x00000020) == 0x00000020);
4504       }
4505       /**
4506        * <code>optional bool multiple_responses = 6;</code>
4507        */
4508       public boolean getMultipleResponses() {
4509         return multipleResponses_;
4510       }
4511       /**
4512        * <code>optional bool multiple_responses = 6;</code>
4513        */
4514       public Builder setMultipleResponses(boolean value) {
4515         bitField0_ |= 0x00000020;
4516         multipleResponses_ = value;
4517         onChanged();
4518         return this;
4519       }
4520       /**
4521        * <code>optional bool multiple_responses = 6;</code>
4522        */
4523       public Builder clearMultipleResponses() {
4524         bitField0_ = (bitField0_ & ~0x00000020);
4525         multipleResponses_ = false;
4526         onChanged();
4527         return this;
4528       }
4529
4530       // optional double frequency = 7;
4531       private double frequency_ ;
4532       /**
4533        * <code>optional double frequency = 7;</code>
4534        */
4535       public boolean hasFrequency() {
4536         return ((bitField0_ & 0x00000040) == 0x00000040);
4537       }
4538       /**
4539        * <code>optional double frequency = 7;</code>
4540        */
4541       public double getFrequency() {
4542         return frequency_;
4543       }
4544       /**
4545        * <code>optional double frequency = 7;</code>
4546        */
4547       public Builder setFrequency(double value) {
4548         bitField0_ |= 0x00000040;
4549         frequency_ = value;
4550         onChanged();
4551         return this;
4552       }
4553       /**
4554        * <code>optional double frequency = 7;</code>
4555        */
4556       public Builder clearFrequency() {
4557         bitField0_ = (bitField0_ & ~0x00000040);
4558         frequency_ = 0D;
4559         onChanged();
4560         return this;
4561       }
4562
4563       // optional string name = 8;
4564       private java.lang.Object name_ = "";
4565       /**
4566        * <code>optional string name = 8;</code>
4567        */
4568       public boolean hasName() {
4569         return ((bitField0_ & 0x00000080) == 0x00000080);
4570       }
4571       /**
4572        * <code>optional string name = 8;</code>
4573        */
4574       public java.lang.String getName() {
4575         java.lang.Object ref = name_;
4576         if (!(ref instanceof java.lang.String)) {
4577           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4578               .toStringUtf8();
4579           name_ = s;
4580           return s;
4581         } else {
4582           return (java.lang.String) ref;
4583         }
4584       }
4585       /**
4586        * <code>optional string name = 8;</code>
4587        */
4588       public com.google.protobuf.ByteString
4589           getNameBytes() {
4590         java.lang.Object ref = name_;
4591         if (ref instanceof String) {
4592           com.google.protobuf.ByteString b =
4593               com.google.protobuf.ByteString.copyFromUtf8(
4594                   (java.lang.String) ref);
4595           name_ = b;
4596           return b;
4597         } else {
4598           return (com.google.protobuf.ByteString) ref;
4599         }
4600       }
4601       /**
4602        * <code>optional string name = 8;</code>
4603        */
4604       public Builder setName(
4605           java.lang.String value) {
4606         if (value == null) {
4607     throw new NullPointerException();
4608   }
4609   bitField0_ |= 0x00000080;
4610         name_ = value;
4611         onChanged();
4612         return this;
4613       }
4614       /**
4615        * <code>optional string name = 8;</code>
4616        */
4617       public Builder clearName() {
4618         bitField0_ = (bitField0_ & ~0x00000080);
4619         name_ = getDefaultInstance().getName();
4620         onChanged();
4621         return this;
4622       }
4623       /**
4624        * <code>optional string name = 8;</code>
4625        */
4626       public Builder setNameBytes(
4627           com.google.protobuf.ByteString value) {
4628         if (value == null) {
4629     throw new NullPointerException();
4630   }
4631   bitField0_ |= 0x00000080;
4632         name_ = value;
4633         onChanged();
4634         return this;
4635       }
4636
4637       // optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;
4638       private com.openxc.BinaryMessages.DiagnosticRequest.DecodedType decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4639       /**
4640        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4641        */
4642       public boolean hasDecodedType() {
4643         return ((bitField0_ & 0x00000100) == 0x00000100);
4644       }
4645       /**
4646        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4647        */
4648       public com.openxc.BinaryMessages.DiagnosticRequest.DecodedType getDecodedType() {
4649         return decodedType_;
4650       }
4651       /**
4652        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4653        */
4654       public Builder setDecodedType(com.openxc.BinaryMessages.DiagnosticRequest.DecodedType value) {
4655         if (value == null) {
4656           throw new NullPointerException();
4657         }
4658         bitField0_ |= 0x00000100;
4659         decodedType_ = value;
4660         onChanged();
4661         return this;
4662       }
4663       /**
4664        * <code>optional .openxc.DiagnosticRequest.DecodedType decoded_type = 9;</code>
4665        */
4666       public Builder clearDecodedType() {
4667         bitField0_ = (bitField0_ & ~0x00000100);
4668         decodedType_ = com.openxc.BinaryMessages.DiagnosticRequest.DecodedType.NONE;
4669         onChanged();
4670         return this;
4671       }
4672
4673       // optional .openxc.DiagnosticRequest.Action action = 10;
4674       private com.openxc.BinaryMessages.DiagnosticRequest.Action action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
4675       /**
4676        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4677        */
4678       public boolean hasAction() {
4679         return ((bitField0_ & 0x00000200) == 0x00000200);
4680       }
4681       /**
4682        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4683        */
4684       public com.openxc.BinaryMessages.DiagnosticRequest.Action getAction() {
4685         return action_;
4686       }
4687       /**
4688        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4689        */
4690       public Builder setAction(com.openxc.BinaryMessages.DiagnosticRequest.Action value) {
4691         if (value == null) {
4692           throw new NullPointerException();
4693         }
4694         bitField0_ |= 0x00000200;
4695         action_ = value;
4696         onChanged();
4697         return this;
4698       }
4699       /**
4700        * <code>optional .openxc.DiagnosticRequest.Action action = 10;</code>
4701        */
4702       public Builder clearAction() {
4703         bitField0_ = (bitField0_ & ~0x00000200);
4704         action_ = com.openxc.BinaryMessages.DiagnosticRequest.Action.ADD;
4705         onChanged();
4706         return this;
4707       }
4708
4709       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticRequest)
4710     }
4711
4712     static {
4713       defaultInstance = new DiagnosticRequest(true);
4714       defaultInstance.initFields();
4715     }
4716
4717     // @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest)
4718   }
4719
4720   public interface DiagnosticResponseOrBuilder
4721       extends com.google.protobuf.MessageOrBuilder {
4722
4723     // optional int32 bus = 1;
4724     /**
4725      * <code>optional int32 bus = 1;</code>
4726      */
4727     boolean hasBus();
4728     /**
4729      * <code>optional int32 bus = 1;</code>
4730      */
4731     int getBus();
4732
4733     // optional uint32 message_id = 2;
4734     /**
4735      * <code>optional uint32 message_id = 2;</code>
4736      */
4737     boolean hasMessageId();
4738     /**
4739      * <code>optional uint32 message_id = 2;</code>
4740      */
4741     int getMessageId();
4742
4743     // optional uint32 mode = 3;
4744     /**
4745      * <code>optional uint32 mode = 3;</code>
4746      */
4747     boolean hasMode();
4748     /**
4749      * <code>optional uint32 mode = 3;</code>
4750      */
4751     int getMode();
4752
4753     // optional uint32 pid = 4;
4754     /**
4755      * <code>optional uint32 pid = 4;</code>
4756      */
4757     boolean hasPid();
4758     /**
4759      * <code>optional uint32 pid = 4;</code>
4760      */
4761     int getPid();
4762
4763     // optional bool success = 5;
4764     /**
4765      * <code>optional bool success = 5;</code>
4766      */
4767     boolean hasSuccess();
4768     /**
4769      * <code>optional bool success = 5;</code>
4770      */
4771     boolean getSuccess();
4772
4773     // optional uint32 negative_response_code = 6;
4774     /**
4775      * <code>optional uint32 negative_response_code = 6;</code>
4776      */
4777     boolean hasNegativeResponseCode();
4778     /**
4779      * <code>optional uint32 negative_response_code = 6;</code>
4780      */
4781     int getNegativeResponseCode();
4782
4783     // optional bytes payload = 7;
4784     /**
4785      * <code>optional bytes payload = 7;</code>
4786      *
4787      * <pre>
4788      * TODO we are capping this at 8 bytes for now - need to change when we
4789      * support multi-frame responses
4790      * </pre>
4791      */
4792     boolean hasPayload();
4793     /**
4794      * <code>optional bytes payload = 7;</code>
4795      *
4796      * <pre>
4797      * TODO we are capping this at 8 bytes for now - need to change when we
4798      * support multi-frame responses
4799      * </pre>
4800      */
4801     com.google.protobuf.ByteString getPayload();
4802
4803     // optional double value = 8;
4804     /**
4805      * <code>optional double value = 8;</code>
4806      */
4807     boolean hasValue();
4808     /**
4809      * <code>optional double value = 8;</code>
4810      */
4811     double getValue();
4812   }
4813   /**
4814    * Protobuf type {@code openxc.DiagnosticResponse}
4815    */
4816   public static final class DiagnosticResponse extends
4817       com.google.protobuf.GeneratedMessage
4818       implements DiagnosticResponseOrBuilder {
4819     // Use DiagnosticResponse.newBuilder() to construct.
4820     private DiagnosticResponse(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4821       super(builder);
4822       this.unknownFields = builder.getUnknownFields();
4823     }
4824     private DiagnosticResponse(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4825
4826     private static final DiagnosticResponse defaultInstance;
4827     public static DiagnosticResponse getDefaultInstance() {
4828       return defaultInstance;
4829     }
4830
4831     public DiagnosticResponse getDefaultInstanceForType() {
4832       return defaultInstance;
4833     }
4834
4835     private final com.google.protobuf.UnknownFieldSet unknownFields;
4836     @java.lang.Override
4837     public final com.google.protobuf.UnknownFieldSet
4838         getUnknownFields() {
4839       return this.unknownFields;
4840     }
4841     private DiagnosticResponse(
4842         com.google.protobuf.CodedInputStream input,
4843         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4844         throws com.google.protobuf.InvalidProtocolBufferException {
4845       initFields();
4846       int mutable_bitField0_ = 0;
4847       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4848           com.google.protobuf.UnknownFieldSet.newBuilder();
4849       try {
4850         boolean done = false;
4851         while (!done) {
4852           int tag = input.readTag();
4853           switch (tag) {
4854             case 0:
4855               done = true;
4856               break;
4857             default: {
4858               if (!parseUnknownField(input, unknownFields,
4859                                      extensionRegistry, tag)) {
4860                 done = true;
4861               }
4862               break;
4863             }
4864             case 8: {
4865               bitField0_ |= 0x00000001;
4866               bus_ = input.readInt32();
4867               break;
4868             }
4869             case 16: {
4870               bitField0_ |= 0x00000002;
4871               messageId_ = input.readUInt32();
4872               break;
4873             }
4874             case 24: {
4875               bitField0_ |= 0x00000004;
4876               mode_ = input.readUInt32();
4877               break;
4878             }
4879             case 32: {
4880               bitField0_ |= 0x00000008;
4881               pid_ = input.readUInt32();
4882               break;
4883             }
4884             case 40: {
4885               bitField0_ |= 0x00000010;
4886               success_ = input.readBool();
4887               break;
4888             }
4889             case 48: {
4890               bitField0_ |= 0x00000020;
4891               negativeResponseCode_ = input.readUInt32();
4892               break;
4893             }
4894             case 58: {
4895               bitField0_ |= 0x00000040;
4896               payload_ = input.readBytes();
4897               break;
4898             }
4899             case 65: {
4900               bitField0_ |= 0x00000080;
4901               value_ = input.readDouble();
4902               break;
4903             }
4904           }
4905         }
4906       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4907         throw e.setUnfinishedMessage(this);
4908       } catch (java.io.IOException e) {
4909         throw new com.google.protobuf.InvalidProtocolBufferException(
4910             e.getMessage()).setUnfinishedMessage(this);
4911       } finally {
4912         this.unknownFields = unknownFields.build();
4913         makeExtensionsImmutable();
4914       }
4915     }
4916     public static final com.google.protobuf.Descriptors.Descriptor
4917         getDescriptor() {
4918       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
4919     }
4920
4921     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4922         internalGetFieldAccessorTable() {
4923       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
4924           .ensureFieldAccessorsInitialized(
4925               com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
4926     }
4927
4928     public static com.google.protobuf.Parser<DiagnosticResponse> PARSER =
4929         new com.google.protobuf.AbstractParser<DiagnosticResponse>() {
4930       public DiagnosticResponse parsePartialFrom(
4931           com.google.protobuf.CodedInputStream input,
4932           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4933           throws com.google.protobuf.InvalidProtocolBufferException {
4934         return new DiagnosticResponse(input, extensionRegistry);
4935       }
4936     };
4937
4938     @java.lang.Override
4939     public com.google.protobuf.Parser<DiagnosticResponse> getParserForType() {
4940       return PARSER;
4941     }
4942
4943     private int bitField0_;
4944     // optional int32 bus = 1;
4945     public static final int BUS_FIELD_NUMBER = 1;
4946     private int bus_;
4947     /**
4948      * <code>optional int32 bus = 1;</code>
4949      */
4950     public boolean hasBus() {
4951       return ((bitField0_ & 0x00000001) == 0x00000001);
4952     }
4953     /**
4954      * <code>optional int32 bus = 1;</code>
4955      */
4956     public int getBus() {
4957       return bus_;
4958     }
4959
4960     // optional uint32 message_id = 2;
4961     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
4962     private int messageId_;
4963     /**
4964      * <code>optional uint32 message_id = 2;</code>
4965      */
4966     public boolean hasMessageId() {
4967       return ((bitField0_ & 0x00000002) == 0x00000002);
4968     }
4969     /**
4970      * <code>optional uint32 message_id = 2;</code>
4971      */
4972     public int getMessageId() {
4973       return messageId_;
4974     }
4975
4976     // optional uint32 mode = 3;
4977     public static final int MODE_FIELD_NUMBER = 3;
4978     private int mode_;
4979     /**
4980      * <code>optional uint32 mode = 3;</code>
4981      */
4982     public boolean hasMode() {
4983       return ((bitField0_ & 0x00000004) == 0x00000004);
4984     }
4985     /**
4986      * <code>optional uint32 mode = 3;</code>
4987      */
4988     public int getMode() {
4989       return mode_;
4990     }
4991
4992     // optional uint32 pid = 4;
4993     public static final int PID_FIELD_NUMBER = 4;
4994     private int pid_;
4995     /**
4996      * <code>optional uint32 pid = 4;</code>
4997      */
4998     public boolean hasPid() {
4999       return ((bitField0_ & 0x00000008) == 0x00000008);
5000     }
5001     /**
5002      * <code>optional uint32 pid = 4;</code>
5003      */
5004     public int getPid() {
5005       return pid_;
5006     }
5007
5008     // optional bool success = 5;
5009     public static final int SUCCESS_FIELD_NUMBER = 5;
5010     private boolean success_;
5011     /**
5012      * <code>optional bool success = 5;</code>
5013      */
5014     public boolean hasSuccess() {
5015       return ((bitField0_ & 0x00000010) == 0x00000010);
5016     }
5017     /**
5018      * <code>optional bool success = 5;</code>
5019      */
5020     public boolean getSuccess() {
5021       return success_;
5022     }
5023
5024     // optional uint32 negative_response_code = 6;
5025     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
5026     private int negativeResponseCode_;
5027     /**
5028      * <code>optional uint32 negative_response_code = 6;</code>
5029      */
5030     public boolean hasNegativeResponseCode() {
5031       return ((bitField0_ & 0x00000020) == 0x00000020);
5032     }
5033     /**
5034      * <code>optional uint32 negative_response_code = 6;</code>
5035      */
5036     public int getNegativeResponseCode() {
5037       return negativeResponseCode_;
5038     }
5039
5040     // optional bytes payload = 7;
5041     public static final int PAYLOAD_FIELD_NUMBER = 7;
5042     private com.google.protobuf.ByteString payload_;
5043     /**
5044      * <code>optional bytes payload = 7;</code>
5045      *
5046      * <pre>
5047      * TODO we are capping this at 8 bytes for now - need to change when we
5048      * support multi-frame responses
5049      * </pre>
5050      */
5051     public boolean hasPayload() {
5052       return ((bitField0_ & 0x00000040) == 0x00000040);
5053     }
5054     /**
5055      * <code>optional bytes payload = 7;</code>
5056      *
5057      * <pre>
5058      * TODO we are capping this at 8 bytes for now - need to change when we
5059      * support multi-frame responses
5060      * </pre>
5061      */
5062     public com.google.protobuf.ByteString getPayload() {
5063       return payload_;
5064     }
5065
5066     // optional double value = 8;
5067     public static final int VALUE_FIELD_NUMBER = 8;
5068     private double value_;
5069     /**
5070      * <code>optional double value = 8;</code>
5071      */
5072     public boolean hasValue() {
5073       return ((bitField0_ & 0x00000080) == 0x00000080);
5074     }
5075     /**
5076      * <code>optional double value = 8;</code>
5077      */
5078     public double getValue() {
5079       return value_;
5080     }
5081
5082     private void initFields() {
5083       bus_ = 0;
5084       messageId_ = 0;
5085       mode_ = 0;
5086       pid_ = 0;
5087       success_ = false;
5088       negativeResponseCode_ = 0;
5089       payload_ = com.google.protobuf.ByteString.EMPTY;
5090       value_ = 0D;
5091     }
5092     private byte memoizedIsInitialized = -1;
5093     public final boolean isInitialized() {
5094       byte isInitialized = memoizedIsInitialized;
5095       if (isInitialized != -1) return isInitialized == 1;
5096
5097       memoizedIsInitialized = 1;
5098       return true;
5099     }
5100
5101     public void writeTo(com.google.protobuf.CodedOutputStream output)
5102                         throws java.io.IOException {
5103       getSerializedSize();
5104       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5105         output.writeInt32(1, bus_);
5106       }
5107       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5108         output.writeUInt32(2, messageId_);
5109       }
5110       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5111         output.writeUInt32(3, mode_);
5112       }
5113       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5114         output.writeUInt32(4, pid_);
5115       }
5116       if (((bitField0_ & 0x00000010) == 0x00000010)) {
5117         output.writeBool(5, success_);
5118       }
5119       if (((bitField0_ & 0x00000020) == 0x00000020)) {
5120         output.writeUInt32(6, negativeResponseCode_);
5121       }
5122       if (((bitField0_ & 0x00000040) == 0x00000040)) {
5123         output.writeBytes(7, payload_);
5124       }
5125       if (((bitField0_ & 0x00000080) == 0x00000080)) {
5126         output.writeDouble(8, value_);
5127       }
5128       getUnknownFields().writeTo(output);
5129     }
5130
5131     private int memoizedSerializedSize = -1;
5132     public int getSerializedSize() {
5133       int size = memoizedSerializedSize;
5134       if (size != -1) return size;
5135
5136       size = 0;
5137       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5138         size += com.google.protobuf.CodedOutputStream
5139           .computeInt32Size(1, bus_);
5140       }
5141       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5142         size += com.google.protobuf.CodedOutputStream
5143           .computeUInt32Size(2, messageId_);
5144       }
5145       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5146         size += com.google.protobuf.CodedOutputStream
5147           .computeUInt32Size(3, mode_);
5148       }
5149       if (((bitField0_ & 0x00000008) == 0x00000008)) {
5150         size += com.google.protobuf.CodedOutputStream
5151           .computeUInt32Size(4, pid_);
5152       }
5153       if (((bitField0_ & 0x00000010) == 0x00000010)) {
5154         size += com.google.protobuf.CodedOutputStream
5155           .computeBoolSize(5, success_);
5156       }
5157       if (((bitField0_ & 0x00000020) == 0x00000020)) {
5158         size += com.google.protobuf.CodedOutputStream
5159           .computeUInt32Size(6, negativeResponseCode_);
5160       }
5161       if (((bitField0_ & 0x00000040) == 0x00000040)) {
5162         size += com.google.protobuf.CodedOutputStream
5163           .computeBytesSize(7, payload_);
5164       }
5165       if (((bitField0_ & 0x00000080) == 0x00000080)) {
5166         size += com.google.protobuf.CodedOutputStream
5167           .computeDoubleSize(8, value_);
5168       }
5169       size += getUnknownFields().getSerializedSize();
5170       memoizedSerializedSize = size;
5171       return size;
5172     }
5173
5174     private static final long serialVersionUID = 0L;
5175     @java.lang.Override
5176     protected java.lang.Object writeReplace()
5177         throws java.io.ObjectStreamException {
5178       return super.writeReplace();
5179     }
5180
5181     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5182         com.google.protobuf.ByteString data)
5183         throws com.google.protobuf.InvalidProtocolBufferException {
5184       return PARSER.parseFrom(data);
5185     }
5186     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5187         com.google.protobuf.ByteString data,
5188         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5189         throws com.google.protobuf.InvalidProtocolBufferException {
5190       return PARSER.parseFrom(data, extensionRegistry);
5191     }
5192     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(byte[] data)
5193         throws com.google.protobuf.InvalidProtocolBufferException {
5194       return PARSER.parseFrom(data);
5195     }
5196     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5197         byte[] data,
5198         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5199         throws com.google.protobuf.InvalidProtocolBufferException {
5200       return PARSER.parseFrom(data, extensionRegistry);
5201     }
5202     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(java.io.InputStream input)
5203         throws java.io.IOException {
5204       return PARSER.parseFrom(input);
5205     }
5206     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5207         java.io.InputStream input,
5208         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5209         throws java.io.IOException {
5210       return PARSER.parseFrom(input, extensionRegistry);
5211     }
5212     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(java.io.InputStream input)
5213         throws java.io.IOException {
5214       return PARSER.parseDelimitedFrom(input);
5215     }
5216     public static com.openxc.BinaryMessages.DiagnosticResponse parseDelimitedFrom(
5217         java.io.InputStream input,
5218         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5219         throws java.io.IOException {
5220       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5221     }
5222     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5223         com.google.protobuf.CodedInputStream input)
5224         throws java.io.IOException {
5225       return PARSER.parseFrom(input);
5226     }
5227     public static com.openxc.BinaryMessages.DiagnosticResponse parseFrom(
5228         com.google.protobuf.CodedInputStream input,
5229         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5230         throws java.io.IOException {
5231       return PARSER.parseFrom(input, extensionRegistry);
5232     }
5233
5234     public static Builder newBuilder() { return Builder.create(); }
5235     public Builder newBuilderForType() { return newBuilder(); }
5236     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticResponse prototype) {
5237       return newBuilder().mergeFrom(prototype);
5238     }
5239     public Builder toBuilder() { return newBuilder(this); }
5240
5241     @java.lang.Override
5242     protected Builder newBuilderForType(
5243         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5244       Builder builder = new Builder(parent);
5245       return builder;
5246     }
5247     /**
5248      * Protobuf type {@code openxc.DiagnosticResponse}
5249      */
5250     public static final class Builder extends
5251         com.google.protobuf.GeneratedMessage.Builder<Builder>
5252        implements com.openxc.BinaryMessages.DiagnosticResponseOrBuilder {
5253       public static final com.google.protobuf.Descriptors.Descriptor
5254           getDescriptor() {
5255         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5256       }
5257
5258       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5259           internalGetFieldAccessorTable() {
5260         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_fieldAccessorTable
5261             .ensureFieldAccessorsInitialized(
5262                 com.openxc.BinaryMessages.DiagnosticResponse.class, com.openxc.BinaryMessages.DiagnosticResponse.Builder.class);
5263       }
5264
5265       // Construct using com.openxc.BinaryMessages.DiagnosticResponse.newBuilder()
5266       private Builder() {
5267         maybeForceBuilderInitialization();
5268       }
5269
5270       private Builder(
5271           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5272         super(parent);
5273         maybeForceBuilderInitialization();
5274       }
5275       private void maybeForceBuilderInitialization() {
5276         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5277         }
5278       }
5279       private static Builder create() {
5280         return new Builder();
5281       }
5282
5283       public Builder clear() {
5284         super.clear();
5285         bus_ = 0;
5286         bitField0_ = (bitField0_ & ~0x00000001);
5287         messageId_ = 0;
5288         bitField0_ = (bitField0_ & ~0x00000002);
5289         mode_ = 0;
5290         bitField0_ = (bitField0_ & ~0x00000004);
5291         pid_ = 0;
5292         bitField0_ = (bitField0_ & ~0x00000008);
5293         success_ = false;
5294         bitField0_ = (bitField0_ & ~0x00000010);
5295         negativeResponseCode_ = 0;
5296         bitField0_ = (bitField0_ & ~0x00000020);
5297         payload_ = com.google.protobuf.ByteString.EMPTY;
5298         bitField0_ = (bitField0_ & ~0x00000040);
5299         value_ = 0D;
5300         bitField0_ = (bitField0_ & ~0x00000080);
5301         return this;
5302       }
5303
5304       public Builder clone() {
5305         return create().mergeFrom(buildPartial());
5306       }
5307
5308       public com.google.protobuf.Descriptors.Descriptor
5309           getDescriptorForType() {
5310         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticResponse_descriptor;
5311       }
5312
5313       public com.openxc.BinaryMessages.DiagnosticResponse getDefaultInstanceForType() {
5314         return com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance();
5315       }
5316
5317       public com.openxc.BinaryMessages.DiagnosticResponse build() {
5318         com.openxc.BinaryMessages.DiagnosticResponse result = buildPartial();
5319         if (!result.isInitialized()) {
5320           throw newUninitializedMessageException(result);
5321         }
5322         return result;
5323       }
5324
5325       public com.openxc.BinaryMessages.DiagnosticResponse buildPartial() {
5326         com.openxc.BinaryMessages.DiagnosticResponse result = new com.openxc.BinaryMessages.DiagnosticResponse(this);
5327         int from_bitField0_ = bitField0_;
5328         int to_bitField0_ = 0;
5329         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5330           to_bitField0_ |= 0x00000001;
5331         }
5332         result.bus_ = bus_;
5333         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5334           to_bitField0_ |= 0x00000002;
5335         }
5336         result.messageId_ = messageId_;
5337         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5338           to_bitField0_ |= 0x00000004;
5339         }
5340         result.mode_ = mode_;
5341         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
5342           to_bitField0_ |= 0x00000008;
5343         }
5344         result.pid_ = pid_;
5345         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
5346           to_bitField0_ |= 0x00000010;
5347         }
5348         result.success_ = success_;
5349         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
5350           to_bitField0_ |= 0x00000020;
5351         }
5352         result.negativeResponseCode_ = negativeResponseCode_;
5353         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
5354           to_bitField0_ |= 0x00000040;
5355         }
5356         result.payload_ = payload_;
5357         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
5358           to_bitField0_ |= 0x00000080;
5359         }
5360         result.value_ = value_;
5361         result.bitField0_ = to_bitField0_;
5362         onBuilt();
5363         return result;
5364       }
5365
5366       public Builder mergeFrom(com.google.protobuf.Message other) {
5367         if (other instanceof com.openxc.BinaryMessages.DiagnosticResponse) {
5368           return mergeFrom((com.openxc.BinaryMessages.DiagnosticResponse)other);
5369         } else {
5370           super.mergeFrom(other);
5371           return this;
5372         }
5373       }
5374
5375       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticResponse other) {
5376         if (other == com.openxc.BinaryMessages.DiagnosticResponse.getDefaultInstance()) return this;
5377         if (other.hasBus()) {
5378           setBus(other.getBus());
5379         }
5380         if (other.hasMessageId()) {
5381           setMessageId(other.getMessageId());
5382         }
5383         if (other.hasMode()) {
5384           setMode(other.getMode());
5385         }
5386         if (other.hasPid()) {
5387           setPid(other.getPid());
5388         }
5389         if (other.hasSuccess()) {
5390           setSuccess(other.getSuccess());
5391         }
5392         if (other.hasNegativeResponseCode()) {
5393           setNegativeResponseCode(other.getNegativeResponseCode());
5394         }
5395         if (other.hasPayload()) {
5396           setPayload(other.getPayload());
5397         }
5398         if (other.hasValue()) {
5399           setValue(other.getValue());
5400         }
5401         this.mergeUnknownFields(other.getUnknownFields());
5402         return this;
5403       }
5404
5405       public final boolean isInitialized() {
5406         return true;
5407       }
5408
5409       public Builder mergeFrom(
5410           com.google.protobuf.CodedInputStream input,
5411           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5412           throws java.io.IOException {
5413         com.openxc.BinaryMessages.DiagnosticResponse parsedMessage = null;
5414         try {
5415           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5416         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5417           parsedMessage = (com.openxc.BinaryMessages.DiagnosticResponse) e.getUnfinishedMessage();
5418           throw e;
5419         } finally {
5420           if (parsedMessage != null) {
5421             mergeFrom(parsedMessage);
5422           }
5423         }
5424         return this;
5425       }
5426       private int bitField0_;
5427
5428       // optional int32 bus = 1;
5429       private int bus_ ;
5430       /**
5431        * <code>optional int32 bus = 1;</code>
5432        */
5433       public boolean hasBus() {
5434         return ((bitField0_ & 0x00000001) == 0x00000001);
5435       }
5436       /**
5437        * <code>optional int32 bus = 1;</code>
5438        */
5439       public int getBus() {
5440         return bus_;
5441       }
5442       /**
5443        * <code>optional int32 bus = 1;</code>
5444        */
5445       public Builder setBus(int value) {
5446         bitField0_ |= 0x00000001;
5447         bus_ = value;
5448         onChanged();
5449         return this;
5450       }
5451       /**
5452        * <code>optional int32 bus = 1;</code>
5453        */
5454       public Builder clearBus() {
5455         bitField0_ = (bitField0_ & ~0x00000001);
5456         bus_ = 0;
5457         onChanged();
5458         return this;
5459       }
5460
5461       // optional uint32 message_id = 2;
5462       private int messageId_ ;
5463       /**
5464        * <code>optional uint32 message_id = 2;</code>
5465        */
5466       public boolean hasMessageId() {
5467         return ((bitField0_ & 0x00000002) == 0x00000002);
5468       }
5469       /**
5470        * <code>optional uint32 message_id = 2;</code>
5471        */
5472       public int getMessageId() {
5473         return messageId_;
5474       }
5475       /**
5476        * <code>optional uint32 message_id = 2;</code>
5477        */
5478       public Builder setMessageId(int value) {
5479         bitField0_ |= 0x00000002;
5480         messageId_ = value;
5481         onChanged();
5482         return this;
5483       }
5484       /**
5485        * <code>optional uint32 message_id = 2;</code>
5486        */
5487       public Builder clearMessageId() {
5488         bitField0_ = (bitField0_ & ~0x00000002);
5489         messageId_ = 0;
5490         onChanged();
5491         return this;
5492       }
5493
5494       // optional uint32 mode = 3;
5495       private int mode_ ;
5496       /**
5497        * <code>optional uint32 mode = 3;</code>
5498        */
5499       public boolean hasMode() {
5500         return ((bitField0_ & 0x00000004) == 0x00000004);
5501       }
5502       /**
5503        * <code>optional uint32 mode = 3;</code>
5504        */
5505       public int getMode() {
5506         return mode_;
5507       }
5508       /**
5509        * <code>optional uint32 mode = 3;</code>
5510        */
5511       public Builder setMode(int value) {
5512         bitField0_ |= 0x00000004;
5513         mode_ = value;
5514         onChanged();
5515         return this;
5516       }
5517       /**
5518        * <code>optional uint32 mode = 3;</code>
5519        */
5520       public Builder clearMode() {
5521         bitField0_ = (bitField0_ & ~0x00000004);
5522         mode_ = 0;
5523         onChanged();
5524         return this;
5525       }
5526
5527       // optional uint32 pid = 4;
5528       private int pid_ ;
5529       /**
5530        * <code>optional uint32 pid = 4;</code>
5531        */
5532       public boolean hasPid() {
5533         return ((bitField0_ & 0x00000008) == 0x00000008);
5534       }
5535       /**
5536        * <code>optional uint32 pid = 4;</code>
5537        */
5538       public int getPid() {
5539         return pid_;
5540       }
5541       /**
5542        * <code>optional uint32 pid = 4;</code>
5543        */
5544       public Builder setPid(int value) {
5545         bitField0_ |= 0x00000008;
5546         pid_ = value;
5547         onChanged();
5548         return this;
5549       }
5550       /**
5551        * <code>optional uint32 pid = 4;</code>
5552        */
5553       public Builder clearPid() {
5554         bitField0_ = (bitField0_ & ~0x00000008);
5555         pid_ = 0;
5556         onChanged();
5557         return this;
5558       }
5559
5560       // optional bool success = 5;
5561       private boolean success_ ;
5562       /**
5563        * <code>optional bool success = 5;</code>
5564        */
5565       public boolean hasSuccess() {
5566         return ((bitField0_ & 0x00000010) == 0x00000010);
5567       }
5568       /**
5569        * <code>optional bool success = 5;</code>
5570        */
5571       public boolean getSuccess() {
5572         return success_;
5573       }
5574       /**
5575        * <code>optional bool success = 5;</code>
5576        */
5577       public Builder setSuccess(boolean value) {
5578         bitField0_ |= 0x00000010;
5579         success_ = value;
5580         onChanged();
5581         return this;
5582       }
5583       /**
5584        * <code>optional bool success = 5;</code>
5585        */
5586       public Builder clearSuccess() {
5587         bitField0_ = (bitField0_ & ~0x00000010);
5588         success_ = false;
5589         onChanged();
5590         return this;
5591       }
5592
5593       // optional uint32 negative_response_code = 6;
5594       private int negativeResponseCode_ ;
5595       /**
5596        * <code>optional uint32 negative_response_code = 6;</code>
5597        */
5598       public boolean hasNegativeResponseCode() {
5599         return ((bitField0_ & 0x00000020) == 0x00000020);
5600       }
5601       /**
5602        * <code>optional uint32 negative_response_code = 6;</code>
5603        */
5604       public int getNegativeResponseCode() {
5605         return negativeResponseCode_;
5606       }
5607       /**
5608        * <code>optional uint32 negative_response_code = 6;</code>
5609        */
5610       public Builder setNegativeResponseCode(int value) {
5611         bitField0_ |= 0x00000020;
5612         negativeResponseCode_ = value;
5613         onChanged();
5614         return this;
5615       }
5616       /**
5617        * <code>optional uint32 negative_response_code = 6;</code>
5618        */
5619       public Builder clearNegativeResponseCode() {
5620         bitField0_ = (bitField0_ & ~0x00000020);
5621         negativeResponseCode_ = 0;
5622         onChanged();
5623         return this;
5624       }
5625
5626       // optional bytes payload = 7;
5627       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
5628       /**
5629        * <code>optional bytes payload = 7;</code>
5630        *
5631        * <pre>
5632        * TODO we are capping this at 8 bytes for now - need to change when we
5633        * support multi-frame responses
5634        * </pre>
5635        */
5636       public boolean hasPayload() {
5637         return ((bitField0_ & 0x00000040) == 0x00000040);
5638       }
5639       /**
5640        * <code>optional bytes payload = 7;</code>
5641        *
5642        * <pre>
5643        * TODO we are capping this at 8 bytes for now - need to change when we
5644        * support multi-frame responses
5645        * </pre>
5646        */
5647       public com.google.protobuf.ByteString getPayload() {
5648         return payload_;
5649       }
5650       /**
5651        * <code>optional bytes payload = 7;</code>
5652        *
5653        * <pre>
5654        * TODO we are capping this at 8 bytes for now - need to change when we
5655        * support multi-frame responses
5656        * </pre>
5657        */
5658       public Builder setPayload(com.google.protobuf.ByteString value) {
5659         if (value == null) {
5660     throw new NullPointerException();
5661   }
5662   bitField0_ |= 0x00000040;
5663         payload_ = value;
5664         onChanged();
5665         return this;
5666       }
5667       /**
5668        * <code>optional bytes payload = 7;</code>
5669        *
5670        * <pre>
5671        * TODO we are capping this at 8 bytes for now - need to change when we
5672        * support multi-frame responses
5673        * </pre>
5674        */
5675       public Builder clearPayload() {
5676         bitField0_ = (bitField0_ & ~0x00000040);
5677         payload_ = getDefaultInstance().getPayload();
5678         onChanged();
5679         return this;
5680       }
5681
5682       // optional double value = 8;
5683       private double value_ ;
5684       /**
5685        * <code>optional double value = 8;</code>
5686        */
5687       public boolean hasValue() {
5688         return ((bitField0_ & 0x00000080) == 0x00000080);
5689       }
5690       /**
5691        * <code>optional double value = 8;</code>
5692        */
5693       public double getValue() {
5694         return value_;
5695       }
5696       /**
5697        * <code>optional double value = 8;</code>
5698        */
5699       public Builder setValue(double value) {
5700         bitField0_ |= 0x00000080;
5701         value_ = value;
5702         onChanged();
5703         return this;
5704       }
5705       /**
5706        * <code>optional double value = 8;</code>
5707        */
5708       public Builder clearValue() {
5709         bitField0_ = (bitField0_ & ~0x00000080);
5710         value_ = 0D;
5711         onChanged();
5712         return this;
5713       }
5714
5715       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticResponse)
5716     }
5717
5718     static {
5719       defaultInstance = new DiagnosticResponse(true);
5720       defaultInstance.initFields();
5721     }
5722
5723     // @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse)
5724   }
5725
5726   public interface DynamicFieldOrBuilder
5727       extends com.google.protobuf.MessageOrBuilder {
5728
5729     // optional .openxc.DynamicField.Type type = 1;
5730     /**
5731      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5732      */
5733     boolean hasType();
5734     /**
5735      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5736      */
5737     com.openxc.BinaryMessages.DynamicField.Type getType();
5738
5739     // optional string string_value = 2;
5740     /**
5741      * <code>optional string string_value = 2;</code>
5742      */
5743     boolean hasStringValue();
5744     /**
5745      * <code>optional string string_value = 2;</code>
5746      */
5747     java.lang.String getStringValue();
5748     /**
5749      * <code>optional string string_value = 2;</code>
5750      */
5751     com.google.protobuf.ByteString
5752         getStringValueBytes();
5753
5754     // optional double numeric_value = 3;
5755     /**
5756      * <code>optional double numeric_value = 3;</code>
5757      */
5758     boolean hasNumericValue();
5759     /**
5760      * <code>optional double numeric_value = 3;</code>
5761      */
5762     double getNumericValue();
5763
5764     // optional bool boolean_value = 4;
5765     /**
5766      * <code>optional bool boolean_value = 4;</code>
5767      */
5768     boolean hasBooleanValue();
5769     /**
5770      * <code>optional bool boolean_value = 4;</code>
5771      */
5772     boolean getBooleanValue();
5773   }
5774   /**
5775    * Protobuf type {@code openxc.DynamicField}
5776    */
5777   public static final class DynamicField extends
5778       com.google.protobuf.GeneratedMessage
5779       implements DynamicFieldOrBuilder {
5780     // Use DynamicField.newBuilder() to construct.
5781     private DynamicField(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5782       super(builder);
5783       this.unknownFields = builder.getUnknownFields();
5784     }
5785     private DynamicField(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5786
5787     private static final DynamicField defaultInstance;
5788     public static DynamicField getDefaultInstance() {
5789       return defaultInstance;
5790     }
5791
5792     public DynamicField getDefaultInstanceForType() {
5793       return defaultInstance;
5794     }
5795
5796     private final com.google.protobuf.UnknownFieldSet unknownFields;
5797     @java.lang.Override
5798     public final com.google.protobuf.UnknownFieldSet
5799         getUnknownFields() {
5800       return this.unknownFields;
5801     }
5802     private DynamicField(
5803         com.google.protobuf.CodedInputStream input,
5804         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5805         throws com.google.protobuf.InvalidProtocolBufferException {
5806       initFields();
5807       int mutable_bitField0_ = 0;
5808       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5809           com.google.protobuf.UnknownFieldSet.newBuilder();
5810       try {
5811         boolean done = false;
5812         while (!done) {
5813           int tag = input.readTag();
5814           switch (tag) {
5815             case 0:
5816               done = true;
5817               break;
5818             default: {
5819               if (!parseUnknownField(input, unknownFields,
5820                                      extensionRegistry, tag)) {
5821                 done = true;
5822               }
5823               break;
5824             }
5825             case 8: {
5826               int rawValue = input.readEnum();
5827               com.openxc.BinaryMessages.DynamicField.Type value = com.openxc.BinaryMessages.DynamicField.Type.valueOf(rawValue);
5828               if (value == null) {
5829                 unknownFields.mergeVarintField(1, rawValue);
5830               } else {
5831                 bitField0_ |= 0x00000001;
5832                 type_ = value;
5833               }
5834               break;
5835             }
5836             case 18: {
5837               bitField0_ |= 0x00000002;
5838               stringValue_ = input.readBytes();
5839               break;
5840             }
5841             case 25: {
5842               bitField0_ |= 0x00000004;
5843               numericValue_ = input.readDouble();
5844               break;
5845             }
5846             case 32: {
5847               bitField0_ |= 0x00000008;
5848               booleanValue_ = input.readBool();
5849               break;
5850             }
5851           }
5852         }
5853       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5854         throw e.setUnfinishedMessage(this);
5855       } catch (java.io.IOException e) {
5856         throw new com.google.protobuf.InvalidProtocolBufferException(
5857             e.getMessage()).setUnfinishedMessage(this);
5858       } finally {
5859         this.unknownFields = unknownFields.build();
5860         makeExtensionsImmutable();
5861       }
5862     }
5863     public static final com.google.protobuf.Descriptors.Descriptor
5864         getDescriptor() {
5865       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
5866     }
5867
5868     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5869         internalGetFieldAccessorTable() {
5870       return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
5871           .ensureFieldAccessorsInitialized(
5872               com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
5873     }
5874
5875     public static com.google.protobuf.Parser<DynamicField> PARSER =
5876         new com.google.protobuf.AbstractParser<DynamicField>() {
5877       public DynamicField parsePartialFrom(
5878           com.google.protobuf.CodedInputStream input,
5879           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5880           throws com.google.protobuf.InvalidProtocolBufferException {
5881         return new DynamicField(input, extensionRegistry);
5882       }
5883     };
5884
5885     @java.lang.Override
5886     public com.google.protobuf.Parser<DynamicField> getParserForType() {
5887       return PARSER;
5888     }
5889
5890     /**
5891      * Protobuf enum {@code openxc.DynamicField.Type}
5892      */
5893     public enum Type
5894         implements com.google.protobuf.ProtocolMessageEnum {
5895       /**
5896        * <code>STRING = 1;</code>
5897        */
5898       STRING(0, 1),
5899       /**
5900        * <code>NUM = 2;</code>
5901        */
5902       NUM(1, 2),
5903       /**
5904        * <code>BOOL = 3;</code>
5905        */
5906       BOOL(2, 3),
5907       ;
5908
5909       /**
5910        * <code>STRING = 1;</code>
5911        */
5912       public static final int STRING_VALUE = 1;
5913       /**
5914        * <code>NUM = 2;</code>
5915        */
5916       public static final int NUM_VALUE = 2;
5917       /**
5918        * <code>BOOL = 3;</code>
5919        */
5920       public static final int BOOL_VALUE = 3;
5921
5922
5923       public final int getNumber() { return value; }
5924
5925       public static Type valueOf(int value) {
5926         switch (value) {
5927           case 1: return STRING;
5928           case 2: return NUM;
5929           case 3: return BOOL;
5930           default: return null;
5931         }
5932       }
5933
5934       public static com.google.protobuf.Internal.EnumLiteMap<Type>
5935           internalGetValueMap() {
5936         return internalValueMap;
5937       }
5938       private static com.google.protobuf.Internal.EnumLiteMap<Type>
5939           internalValueMap =
5940             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
5941               public Type findValueByNumber(int number) {
5942                 return Type.valueOf(number);
5943               }
5944             };
5945
5946       public final com.google.protobuf.Descriptors.EnumValueDescriptor
5947           getValueDescriptor() {
5948         return getDescriptor().getValues().get(index);
5949       }
5950       public final com.google.protobuf.Descriptors.EnumDescriptor
5951           getDescriptorForType() {
5952         return getDescriptor();
5953       }
5954       public static final com.google.protobuf.Descriptors.EnumDescriptor
5955           getDescriptor() {
5956         return com.openxc.BinaryMessages.DynamicField.getDescriptor().getEnumTypes().get(0);
5957       }
5958
5959       private static final Type[] VALUES = values();
5960
5961       public static Type valueOf(
5962           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
5963         if (desc.getType() != getDescriptor()) {
5964           throw new java.lang.IllegalArgumentException(
5965             "EnumValueDescriptor is not for this type.");
5966         }
5967         return VALUES[desc.getIndex()];
5968       }
5969
5970       private final int index;
5971       private final int value;
5972
5973       private Type(int index, int value) {
5974         this.index = index;
5975         this.value = value;
5976       }
5977
5978       // @@protoc_insertion_point(enum_scope:openxc.DynamicField.Type)
5979     }
5980
5981     private int bitField0_;
5982     // optional .openxc.DynamicField.Type type = 1;
5983     public static final int TYPE_FIELD_NUMBER = 1;
5984     private com.openxc.BinaryMessages.DynamicField.Type type_;
5985     /**
5986      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5987      */
5988     public boolean hasType() {
5989       return ((bitField0_ & 0x00000001) == 0x00000001);
5990     }
5991     /**
5992      * <code>optional .openxc.DynamicField.Type type = 1;</code>
5993      */
5994     public com.openxc.BinaryMessages.DynamicField.Type getType() {
5995       return type_;
5996     }
5997
5998     // optional string string_value = 2;
5999     public static final int STRING_VALUE_FIELD_NUMBER = 2;
6000     private java.lang.Object stringValue_;
6001     /**
6002      * <code>optional string string_value = 2;</code>
6003      */
6004     public boolean hasStringValue() {
6005       return ((bitField0_ & 0x00000002) == 0x00000002);
6006     }
6007     /**
6008      * <code>optional string string_value = 2;</code>
6009      */
6010     public java.lang.String getStringValue() {
6011       java.lang.Object ref = stringValue_;
6012       if (ref instanceof java.lang.String) {
6013         return (java.lang.String) ref;
6014       } else {
6015         com.google.protobuf.ByteString bs =
6016             (com.google.protobuf.ByteString) ref;
6017         java.lang.String s = bs.toStringUtf8();
6018         if (bs.isValidUtf8()) {
6019           stringValue_ = s;
6020         }
6021         return s;
6022       }
6023     }
6024     /**
6025      * <code>optional string string_value = 2;</code>
6026      */
6027     public com.google.protobuf.ByteString
6028         getStringValueBytes() {
6029       java.lang.Object ref = stringValue_;
6030       if (ref instanceof java.lang.String) {
6031         com.google.protobuf.ByteString b =
6032             com.google.protobuf.ByteString.copyFromUtf8(
6033                 (java.lang.String) ref);
6034         stringValue_ = b;
6035         return b;
6036       } else {
6037         return (com.google.protobuf.ByteString) ref;
6038       }
6039     }
6040
6041     // optional double numeric_value = 3;
6042     public static final int NUMERIC_VALUE_FIELD_NUMBER = 3;
6043     private double numericValue_;
6044     /**
6045      * <code>optional double numeric_value = 3;</code>
6046      */
6047     public boolean hasNumericValue() {
6048       return ((bitField0_ & 0x00000004) == 0x00000004);
6049     }
6050     /**
6051      * <code>optional double numeric_value = 3;</code>
6052      */
6053     public double getNumericValue() {
6054       return numericValue_;
6055     }
6056
6057     // optional bool boolean_value = 4;
6058     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
6059     private boolean booleanValue_;
6060     /**
6061      * <code>optional bool boolean_value = 4;</code>
6062      */
6063     public boolean hasBooleanValue() {
6064       return ((bitField0_ & 0x00000008) == 0x00000008);
6065     }
6066     /**
6067      * <code>optional bool boolean_value = 4;</code>
6068      */
6069     public boolean getBooleanValue() {
6070       return booleanValue_;
6071     }
6072
6073     private void initFields() {
6074       type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6075       stringValue_ = "";
6076       numericValue_ = 0D;
6077       booleanValue_ = false;
6078     }
6079     private byte memoizedIsInitialized = -1;
6080     public final boolean isInitialized() {
6081       byte isInitialized = memoizedIsInitialized;
6082       if (isInitialized != -1) return isInitialized == 1;
6083
6084       memoizedIsInitialized = 1;
6085       return true;
6086     }
6087
6088     public void writeTo(com.google.protobuf.CodedOutputStream output)
6089                         throws java.io.IOException {
6090       getSerializedSize();
6091       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6092         output.writeEnum(1, type_.getNumber());
6093       }
6094       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6095         output.writeBytes(2, getStringValueBytes());
6096       }
6097       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6098         output.writeDouble(3, numericValue_);
6099       }
6100       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6101         output.writeBool(4, booleanValue_);
6102       }
6103       getUnknownFields().writeTo(output);
6104     }
6105
6106     private int memoizedSerializedSize = -1;
6107     public int getSerializedSize() {
6108       int size = memoizedSerializedSize;
6109       if (size != -1) return size;
6110
6111       size = 0;
6112       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6113         size += com.google.protobuf.CodedOutputStream
6114           .computeEnumSize(1, type_.getNumber());
6115       }
6116       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6117         size += com.google.protobuf.CodedOutputStream
6118           .computeBytesSize(2, getStringValueBytes());
6119       }
6120       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6121         size += com.google.protobuf.CodedOutputStream
6122           .computeDoubleSize(3, numericValue_);
6123       }
6124       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6125         size += com.google.protobuf.CodedOutputStream
6126           .computeBoolSize(4, booleanValue_);
6127       }
6128       size += getUnknownFields().getSerializedSize();
6129       memoizedSerializedSize = size;
6130       return size;
6131     }
6132
6133     private static final long serialVersionUID = 0L;
6134     @java.lang.Override
6135     protected java.lang.Object writeReplace()
6136         throws java.io.ObjectStreamException {
6137       return super.writeReplace();
6138     }
6139
6140     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6141         com.google.protobuf.ByteString data)
6142         throws com.google.protobuf.InvalidProtocolBufferException {
6143       return PARSER.parseFrom(data);
6144     }
6145     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6146         com.google.protobuf.ByteString data,
6147         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6148         throws com.google.protobuf.InvalidProtocolBufferException {
6149       return PARSER.parseFrom(data, extensionRegistry);
6150     }
6151     public static com.openxc.BinaryMessages.DynamicField parseFrom(byte[] data)
6152         throws com.google.protobuf.InvalidProtocolBufferException {
6153       return PARSER.parseFrom(data);
6154     }
6155     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6156         byte[] data,
6157         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6158         throws com.google.protobuf.InvalidProtocolBufferException {
6159       return PARSER.parseFrom(data, extensionRegistry);
6160     }
6161     public static com.openxc.BinaryMessages.DynamicField parseFrom(java.io.InputStream input)
6162         throws java.io.IOException {
6163       return PARSER.parseFrom(input);
6164     }
6165     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6166         java.io.InputStream input,
6167         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6168         throws java.io.IOException {
6169       return PARSER.parseFrom(input, extensionRegistry);
6170     }
6171     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(java.io.InputStream input)
6172         throws java.io.IOException {
6173       return PARSER.parseDelimitedFrom(input);
6174     }
6175     public static com.openxc.BinaryMessages.DynamicField parseDelimitedFrom(
6176         java.io.InputStream input,
6177         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6178         throws java.io.IOException {
6179       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6180     }
6181     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6182         com.google.protobuf.CodedInputStream input)
6183         throws java.io.IOException {
6184       return PARSER.parseFrom(input);
6185     }
6186     public static com.openxc.BinaryMessages.DynamicField parseFrom(
6187         com.google.protobuf.CodedInputStream input,
6188         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6189         throws java.io.IOException {
6190       return PARSER.parseFrom(input, extensionRegistry);
6191     }
6192
6193     public static Builder newBuilder() { return Builder.create(); }
6194     public Builder newBuilderForType() { return newBuilder(); }
6195     public static Builder newBuilder(com.openxc.BinaryMessages.DynamicField prototype) {
6196       return newBuilder().mergeFrom(prototype);
6197     }
6198     public Builder toBuilder() { return newBuilder(this); }
6199
6200     @java.lang.Override
6201     protected Builder newBuilderForType(
6202         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6203       Builder builder = new Builder(parent);
6204       return builder;
6205     }
6206     /**
6207      * Protobuf type {@code openxc.DynamicField}
6208      */
6209     public static final class Builder extends
6210         com.google.protobuf.GeneratedMessage.Builder<Builder>
6211        implements com.openxc.BinaryMessages.DynamicFieldOrBuilder {
6212       public static final com.google.protobuf.Descriptors.Descriptor
6213           getDescriptor() {
6214         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
6215       }
6216
6217       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6218           internalGetFieldAccessorTable() {
6219         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_fieldAccessorTable
6220             .ensureFieldAccessorsInitialized(
6221                 com.openxc.BinaryMessages.DynamicField.class, com.openxc.BinaryMessages.DynamicField.Builder.class);
6222       }
6223
6224       // Construct using com.openxc.BinaryMessages.DynamicField.newBuilder()
6225       private Builder() {
6226         maybeForceBuilderInitialization();
6227       }
6228
6229       private Builder(
6230           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6231         super(parent);
6232         maybeForceBuilderInitialization();
6233       }
6234       private void maybeForceBuilderInitialization() {
6235         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6236         }
6237       }
6238       private static Builder create() {
6239         return new Builder();
6240       }
6241
6242       public Builder clear() {
6243         super.clear();
6244         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6245         bitField0_ = (bitField0_ & ~0x00000001);
6246         stringValue_ = "";
6247         bitField0_ = (bitField0_ & ~0x00000002);
6248         numericValue_ = 0D;
6249         bitField0_ = (bitField0_ & ~0x00000004);
6250         booleanValue_ = false;
6251         bitField0_ = (bitField0_ & ~0x00000008);
6252         return this;
6253       }
6254
6255       public Builder clone() {
6256         return create().mergeFrom(buildPartial());
6257       }
6258
6259       public com.google.protobuf.Descriptors.Descriptor
6260           getDescriptorForType() {
6261         return com.openxc.BinaryMessages.internal_static_openxc_DynamicField_descriptor;
6262       }
6263
6264       public com.openxc.BinaryMessages.DynamicField getDefaultInstanceForType() {
6265         return com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6266       }
6267
6268       public com.openxc.BinaryMessages.DynamicField build() {
6269         com.openxc.BinaryMessages.DynamicField result = buildPartial();
6270         if (!result.isInitialized()) {
6271           throw newUninitializedMessageException(result);
6272         }
6273         return result;
6274       }
6275
6276       public com.openxc.BinaryMessages.DynamicField buildPartial() {
6277         com.openxc.BinaryMessages.DynamicField result = new com.openxc.BinaryMessages.DynamicField(this);
6278         int from_bitField0_ = bitField0_;
6279         int to_bitField0_ = 0;
6280         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6281           to_bitField0_ |= 0x00000001;
6282         }
6283         result.type_ = type_;
6284         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6285           to_bitField0_ |= 0x00000002;
6286         }
6287         result.stringValue_ = stringValue_;
6288         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6289           to_bitField0_ |= 0x00000004;
6290         }
6291         result.numericValue_ = numericValue_;
6292         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
6293           to_bitField0_ |= 0x00000008;
6294         }
6295         result.booleanValue_ = booleanValue_;
6296         result.bitField0_ = to_bitField0_;
6297         onBuilt();
6298         return result;
6299       }
6300
6301       public Builder mergeFrom(com.google.protobuf.Message other) {
6302         if (other instanceof com.openxc.BinaryMessages.DynamicField) {
6303           return mergeFrom((com.openxc.BinaryMessages.DynamicField)other);
6304         } else {
6305           super.mergeFrom(other);
6306           return this;
6307         }
6308       }
6309
6310       public Builder mergeFrom(com.openxc.BinaryMessages.DynamicField other) {
6311         if (other == com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) return this;
6312         if (other.hasType()) {
6313           setType(other.getType());
6314         }
6315         if (other.hasStringValue()) {
6316           bitField0_ |= 0x00000002;
6317           stringValue_ = other.stringValue_;
6318           onChanged();
6319         }
6320         if (other.hasNumericValue()) {
6321           setNumericValue(other.getNumericValue());
6322         }
6323         if (other.hasBooleanValue()) {
6324           setBooleanValue(other.getBooleanValue());
6325         }
6326         this.mergeUnknownFields(other.getUnknownFields());
6327         return this;
6328       }
6329
6330       public final boolean isInitialized() {
6331         return true;
6332       }
6333
6334       public Builder mergeFrom(
6335           com.google.protobuf.CodedInputStream input,
6336           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6337           throws java.io.IOException {
6338         com.openxc.BinaryMessages.DynamicField parsedMessage = null;
6339         try {
6340           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6341         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6342           parsedMessage = (com.openxc.BinaryMessages.DynamicField) e.getUnfinishedMessage();
6343           throw e;
6344         } finally {
6345           if (parsedMessage != null) {
6346             mergeFrom(parsedMessage);
6347           }
6348         }
6349         return this;
6350       }
6351       private int bitField0_;
6352
6353       // optional .openxc.DynamicField.Type type = 1;
6354       private com.openxc.BinaryMessages.DynamicField.Type type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6355       /**
6356        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6357        */
6358       public boolean hasType() {
6359         return ((bitField0_ & 0x00000001) == 0x00000001);
6360       }
6361       /**
6362        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6363        */
6364       public com.openxc.BinaryMessages.DynamicField.Type getType() {
6365         return type_;
6366       }
6367       /**
6368        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6369        */
6370       public Builder setType(com.openxc.BinaryMessages.DynamicField.Type value) {
6371         if (value == null) {
6372           throw new NullPointerException();
6373         }
6374         bitField0_ |= 0x00000001;
6375         type_ = value;
6376         onChanged();
6377         return this;
6378       }
6379       /**
6380        * <code>optional .openxc.DynamicField.Type type = 1;</code>
6381        */
6382       public Builder clearType() {
6383         bitField0_ = (bitField0_ & ~0x00000001);
6384         type_ = com.openxc.BinaryMessages.DynamicField.Type.STRING;
6385         onChanged();
6386         return this;
6387       }
6388
6389       // optional string string_value = 2;
6390       private java.lang.Object stringValue_ = "";
6391       /**
6392        * <code>optional string string_value = 2;</code>
6393        */
6394       public boolean hasStringValue() {
6395         return ((bitField0_ & 0x00000002) == 0x00000002);
6396       }
6397       /**
6398        * <code>optional string string_value = 2;</code>
6399        */
6400       public java.lang.String getStringValue() {
6401         java.lang.Object ref = stringValue_;
6402         if (!(ref instanceof java.lang.String)) {
6403           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6404               .toStringUtf8();
6405           stringValue_ = s;
6406           return s;
6407         } else {
6408           return (java.lang.String) ref;
6409         }
6410       }
6411       /**
6412        * <code>optional string string_value = 2;</code>
6413        */
6414       public com.google.protobuf.ByteString
6415           getStringValueBytes() {
6416         java.lang.Object ref = stringValue_;
6417         if (ref instanceof String) {
6418           com.google.protobuf.ByteString b =
6419               com.google.protobuf.ByteString.copyFromUtf8(
6420                   (java.lang.String) ref);
6421           stringValue_ = b;
6422           return b;
6423         } else {
6424           return (com.google.protobuf.ByteString) ref;
6425         }
6426       }
6427       /**
6428        * <code>optional string string_value = 2;</code>
6429        */
6430       public Builder setStringValue(
6431           java.lang.String value) {
6432         if (value == null) {
6433     throw new NullPointerException();
6434   }
6435   bitField0_ |= 0x00000002;
6436         stringValue_ = value;
6437         onChanged();
6438         return this;
6439       }
6440       /**
6441        * <code>optional string string_value = 2;</code>
6442        */
6443       public Builder clearStringValue() {
6444         bitField0_ = (bitField0_ & ~0x00000002);
6445         stringValue_ = getDefaultInstance().getStringValue();
6446         onChanged();
6447         return this;
6448       }
6449       /**
6450        * <code>optional string string_value = 2;</code>
6451        */
6452       public Builder setStringValueBytes(
6453           com.google.protobuf.ByteString value) {
6454         if (value == null) {
6455     throw new NullPointerException();
6456   }
6457   bitField0_ |= 0x00000002;
6458         stringValue_ = value;
6459         onChanged();
6460         return this;
6461       }
6462
6463       // optional double numeric_value = 3;
6464       private double numericValue_ ;
6465       /**
6466        * <code>optional double numeric_value = 3;</code>
6467        */
6468       public boolean hasNumericValue() {
6469         return ((bitField0_ & 0x00000004) == 0x00000004);
6470       }
6471       /**
6472        * <code>optional double numeric_value = 3;</code>
6473        */
6474       public double getNumericValue() {
6475         return numericValue_;
6476       }
6477       /**
6478        * <code>optional double numeric_value = 3;</code>
6479        */
6480       public Builder setNumericValue(double value) {
6481         bitField0_ |= 0x00000004;
6482         numericValue_ = value;
6483         onChanged();
6484         return this;
6485       }
6486       /**
6487        * <code>optional double numeric_value = 3;</code>
6488        */
6489       public Builder clearNumericValue() {
6490         bitField0_ = (bitField0_ & ~0x00000004);
6491         numericValue_ = 0D;
6492         onChanged();
6493         return this;
6494       }
6495
6496       // optional bool boolean_value = 4;
6497       private boolean booleanValue_ ;
6498       /**
6499        * <code>optional bool boolean_value = 4;</code>
6500        */
6501       public boolean hasBooleanValue() {
6502         return ((bitField0_ & 0x00000008) == 0x00000008);
6503       }
6504       /**
6505        * <code>optional bool boolean_value = 4;</code>
6506        */
6507       public boolean getBooleanValue() {
6508         return booleanValue_;
6509       }
6510       /**
6511        * <code>optional bool boolean_value = 4;</code>
6512        */
6513       public Builder setBooleanValue(boolean value) {
6514         bitField0_ |= 0x00000008;
6515         booleanValue_ = value;
6516         onChanged();
6517         return this;
6518       }
6519       /**
6520        * <code>optional bool boolean_value = 4;</code>
6521        */
6522       public Builder clearBooleanValue() {
6523         bitField0_ = (bitField0_ & ~0x00000008);
6524         booleanValue_ = false;
6525         onChanged();
6526         return this;
6527       }
6528
6529       // @@protoc_insertion_point(builder_scope:openxc.DynamicField)
6530     }
6531
6532     static {
6533       defaultInstance = new DynamicField(true);
6534       defaultInstance.initFields();
6535     }
6536
6537     // @@protoc_insertion_point(class_scope:openxc.DynamicField)
6538   }
6539
6540   public interface TranslatedMessageOrBuilder
6541       extends com.google.protobuf.MessageOrBuilder {
6542
6543     // optional .openxc.TranslatedMessage.Type type = 1;
6544     /**
6545      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6546      */
6547     boolean hasType();
6548     /**
6549      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6550      */
6551     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
6552
6553     // optional string name = 2;
6554     /**
6555      * <code>optional string name = 2;</code>
6556      */
6557     boolean hasName();
6558     /**
6559      * <code>optional string name = 2;</code>
6560      */
6561     java.lang.String getName();
6562     /**
6563      * <code>optional string name = 2;</code>
6564      */
6565     com.google.protobuf.ByteString
6566         getNameBytes();
6567
6568     // optional .openxc.DynamicField value = 3;
6569     /**
6570      * <code>optional .openxc.DynamicField value = 3;</code>
6571      */
6572     boolean hasValue();
6573     /**
6574      * <code>optional .openxc.DynamicField value = 3;</code>
6575      */
6576     com.openxc.BinaryMessages.DynamicField getValue();
6577     /**
6578      * <code>optional .openxc.DynamicField value = 3;</code>
6579      */
6580     com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder();
6581
6582     // optional .openxc.DynamicField event = 4;
6583     /**
6584      * <code>optional .openxc.DynamicField event = 4;</code>
6585      */
6586     boolean hasEvent();
6587     /**
6588      * <code>optional .openxc.DynamicField event = 4;</code>
6589      */
6590     com.openxc.BinaryMessages.DynamicField getEvent();
6591     /**
6592      * <code>optional .openxc.DynamicField event = 4;</code>
6593      */
6594     com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder();
6595   }
6596   /**
6597    * Protobuf type {@code openxc.TranslatedMessage}
6598    */
6599   public static final class TranslatedMessage extends
6600       com.google.protobuf.GeneratedMessage
6601       implements TranslatedMessageOrBuilder {
6602     // Use TranslatedMessage.newBuilder() to construct.
6603     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
6604       super(builder);
6605       this.unknownFields = builder.getUnknownFields();
6606     }
6607     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
6608
6609     private static final TranslatedMessage defaultInstance;
6610     public static TranslatedMessage getDefaultInstance() {
6611       return defaultInstance;
6612     }
6613
6614     public TranslatedMessage getDefaultInstanceForType() {
6615       return defaultInstance;
6616     }
6617
6618     private final com.google.protobuf.UnknownFieldSet unknownFields;
6619     @java.lang.Override
6620     public final com.google.protobuf.UnknownFieldSet
6621         getUnknownFields() {
6622       return this.unknownFields;
6623     }
6624     private TranslatedMessage(
6625         com.google.protobuf.CodedInputStream input,
6626         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6627         throws com.google.protobuf.InvalidProtocolBufferException {
6628       initFields();
6629       int mutable_bitField0_ = 0;
6630       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
6631           com.google.protobuf.UnknownFieldSet.newBuilder();
6632       try {
6633         boolean done = false;
6634         while (!done) {
6635           int tag = input.readTag();
6636           switch (tag) {
6637             case 0:
6638               done = true;
6639               break;
6640             default: {
6641               if (!parseUnknownField(input, unknownFields,
6642                                      extensionRegistry, tag)) {
6643                 done = true;
6644               }
6645               break;
6646             }
6647             case 8: {
6648               int rawValue = input.readEnum();
6649               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
6650               if (value == null) {
6651                 unknownFields.mergeVarintField(1, rawValue);
6652               } else {
6653                 bitField0_ |= 0x00000001;
6654                 type_ = value;
6655               }
6656               break;
6657             }
6658             case 18: {
6659               bitField0_ |= 0x00000002;
6660               name_ = input.readBytes();
6661               break;
6662             }
6663             case 26: {
6664               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
6665               if (((bitField0_ & 0x00000004) == 0x00000004)) {
6666                 subBuilder = value_.toBuilder();
6667               }
6668               value_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
6669               if (subBuilder != null) {
6670                 subBuilder.mergeFrom(value_);
6671                 value_ = subBuilder.buildPartial();
6672               }
6673               bitField0_ |= 0x00000004;
6674               break;
6675             }
6676             case 34: {
6677               com.openxc.BinaryMessages.DynamicField.Builder subBuilder = null;
6678               if (((bitField0_ & 0x00000008) == 0x00000008)) {
6679                 subBuilder = event_.toBuilder();
6680               }
6681               event_ = input.readMessage(com.openxc.BinaryMessages.DynamicField.PARSER, extensionRegistry);
6682               if (subBuilder != null) {
6683                 subBuilder.mergeFrom(event_);
6684                 event_ = subBuilder.buildPartial();
6685               }
6686               bitField0_ |= 0x00000008;
6687               break;
6688             }
6689           }
6690         }
6691       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6692         throw e.setUnfinishedMessage(this);
6693       } catch (java.io.IOException e) {
6694         throw new com.google.protobuf.InvalidProtocolBufferException(
6695             e.getMessage()).setUnfinishedMessage(this);
6696       } finally {
6697         this.unknownFields = unknownFields.build();
6698         makeExtensionsImmutable();
6699       }
6700     }
6701     public static final com.google.protobuf.Descriptors.Descriptor
6702         getDescriptor() {
6703       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
6704     }
6705
6706     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6707         internalGetFieldAccessorTable() {
6708       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
6709           .ensureFieldAccessorsInitialized(
6710               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
6711     }
6712
6713     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
6714         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
6715       public TranslatedMessage parsePartialFrom(
6716           com.google.protobuf.CodedInputStream input,
6717           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6718           throws com.google.protobuf.InvalidProtocolBufferException {
6719         return new TranslatedMessage(input, extensionRegistry);
6720       }
6721     };
6722
6723     @java.lang.Override
6724     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
6725       return PARSER;
6726     }
6727
6728     /**
6729      * Protobuf enum {@code openxc.TranslatedMessage.Type}
6730      */
6731     public enum Type
6732         implements com.google.protobuf.ProtocolMessageEnum {
6733       /**
6734        * <code>STRING = 1;</code>
6735        */
6736       STRING(0, 1),
6737       /**
6738        * <code>NUM = 2;</code>
6739        */
6740       NUM(1, 2),
6741       /**
6742        * <code>BOOL = 3;</code>
6743        */
6744       BOOL(2, 3),
6745       /**
6746        * <code>EVENTED_STRING = 4;</code>
6747        */
6748       EVENTED_STRING(3, 4),
6749       /**
6750        * <code>EVENTED_NUM = 5;</code>
6751        */
6752       EVENTED_NUM(4, 5),
6753       /**
6754        * <code>EVENTED_BOOL = 6;</code>
6755        */
6756       EVENTED_BOOL(5, 6),
6757       ;
6758
6759       /**
6760        * <code>STRING = 1;</code>
6761        */
6762       public static final int STRING_VALUE = 1;
6763       /**
6764        * <code>NUM = 2;</code>
6765        */
6766       public static final int NUM_VALUE = 2;
6767       /**
6768        * <code>BOOL = 3;</code>
6769        */
6770       public static final int BOOL_VALUE = 3;
6771       /**
6772        * <code>EVENTED_STRING = 4;</code>
6773        */
6774       public static final int EVENTED_STRING_VALUE = 4;
6775       /**
6776        * <code>EVENTED_NUM = 5;</code>
6777        */
6778       public static final int EVENTED_NUM_VALUE = 5;
6779       /**
6780        * <code>EVENTED_BOOL = 6;</code>
6781        */
6782       public static final int EVENTED_BOOL_VALUE = 6;
6783
6784
6785       public final int getNumber() { return value; }
6786
6787       public static Type valueOf(int value) {
6788         switch (value) {
6789           case 1: return STRING;
6790           case 2: return NUM;
6791           case 3: return BOOL;
6792           case 4: return EVENTED_STRING;
6793           case 5: return EVENTED_NUM;
6794           case 6: return EVENTED_BOOL;
6795           default: return null;
6796         }
6797       }
6798
6799       public static com.google.protobuf.Internal.EnumLiteMap<Type>
6800           internalGetValueMap() {
6801         return internalValueMap;
6802       }
6803       private static com.google.protobuf.Internal.EnumLiteMap<Type>
6804           internalValueMap =
6805             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
6806               public Type findValueByNumber(int number) {
6807                 return Type.valueOf(number);
6808               }
6809             };
6810
6811       public final com.google.protobuf.Descriptors.EnumValueDescriptor
6812           getValueDescriptor() {
6813         return getDescriptor().getValues().get(index);
6814       }
6815       public final com.google.protobuf.Descriptors.EnumDescriptor
6816           getDescriptorForType() {
6817         return getDescriptor();
6818       }
6819       public static final com.google.protobuf.Descriptors.EnumDescriptor
6820           getDescriptor() {
6821         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
6822       }
6823
6824       private static final Type[] VALUES = values();
6825
6826       public static Type valueOf(
6827           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
6828         if (desc.getType() != getDescriptor()) {
6829           throw new java.lang.IllegalArgumentException(
6830             "EnumValueDescriptor is not for this type.");
6831         }
6832         return VALUES[desc.getIndex()];
6833       }
6834
6835       private final int index;
6836       private final int value;
6837
6838       private Type(int index, int value) {
6839         this.index = index;
6840         this.value = value;
6841       }
6842
6843       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
6844     }
6845
6846     private int bitField0_;
6847     // optional .openxc.TranslatedMessage.Type type = 1;
6848     public static final int TYPE_FIELD_NUMBER = 1;
6849     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
6850     /**
6851      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6852      */
6853     public boolean hasType() {
6854       return ((bitField0_ & 0x00000001) == 0x00000001);
6855     }
6856     /**
6857      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
6858      */
6859     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
6860       return type_;
6861     }
6862
6863     // optional string name = 2;
6864     public static final int NAME_FIELD_NUMBER = 2;
6865     private java.lang.Object name_;
6866     /**
6867      * <code>optional string name = 2;</code>
6868      */
6869     public boolean hasName() {
6870       return ((bitField0_ & 0x00000002) == 0x00000002);
6871     }
6872     /**
6873      * <code>optional string name = 2;</code>
6874      */
6875     public java.lang.String getName() {
6876       java.lang.Object ref = name_;
6877       if (ref instanceof java.lang.String) {
6878         return (java.lang.String) ref;
6879       } else {
6880         com.google.protobuf.ByteString bs =
6881             (com.google.protobuf.ByteString) ref;
6882         java.lang.String s = bs.toStringUtf8();
6883         if (bs.isValidUtf8()) {
6884           name_ = s;
6885         }
6886         return s;
6887       }
6888     }
6889     /**
6890      * <code>optional string name = 2;</code>
6891      */
6892     public com.google.protobuf.ByteString
6893         getNameBytes() {
6894       java.lang.Object ref = name_;
6895       if (ref instanceof java.lang.String) {
6896         com.google.protobuf.ByteString b =
6897             com.google.protobuf.ByteString.copyFromUtf8(
6898                 (java.lang.String) ref);
6899         name_ = b;
6900         return b;
6901       } else {
6902         return (com.google.protobuf.ByteString) ref;
6903       }
6904     }
6905
6906     // optional .openxc.DynamicField value = 3;
6907     public static final int VALUE_FIELD_NUMBER = 3;
6908     private com.openxc.BinaryMessages.DynamicField value_;
6909     /**
6910      * <code>optional .openxc.DynamicField value = 3;</code>
6911      */
6912     public boolean hasValue() {
6913       return ((bitField0_ & 0x00000004) == 0x00000004);
6914     }
6915     /**
6916      * <code>optional .openxc.DynamicField value = 3;</code>
6917      */
6918     public com.openxc.BinaryMessages.DynamicField getValue() {
6919       return value_;
6920     }
6921     /**
6922      * <code>optional .openxc.DynamicField value = 3;</code>
6923      */
6924     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
6925       return value_;
6926     }
6927
6928     // optional .openxc.DynamicField event = 4;
6929     public static final int EVENT_FIELD_NUMBER = 4;
6930     private com.openxc.BinaryMessages.DynamicField event_;
6931     /**
6932      * <code>optional .openxc.DynamicField event = 4;</code>
6933      */
6934     public boolean hasEvent() {
6935       return ((bitField0_ & 0x00000008) == 0x00000008);
6936     }
6937     /**
6938      * <code>optional .openxc.DynamicField event = 4;</code>
6939      */
6940     public com.openxc.BinaryMessages.DynamicField getEvent() {
6941       return event_;
6942     }
6943     /**
6944      * <code>optional .openxc.DynamicField event = 4;</code>
6945      */
6946     public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
6947       return event_;
6948     }
6949
6950     private void initFields() {
6951       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
6952       name_ = "";
6953       value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6954       event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
6955     }
6956     private byte memoizedIsInitialized = -1;
6957     public final boolean isInitialized() {
6958       byte isInitialized = memoizedIsInitialized;
6959       if (isInitialized != -1) return isInitialized == 1;
6960
6961       memoizedIsInitialized = 1;
6962       return true;
6963     }
6964
6965     public void writeTo(com.google.protobuf.CodedOutputStream output)
6966                         throws java.io.IOException {
6967       getSerializedSize();
6968       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6969         output.writeEnum(1, type_.getNumber());
6970       }
6971       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6972         output.writeBytes(2, getNameBytes());
6973       }
6974       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6975         output.writeMessage(3, value_);
6976       }
6977       if (((bitField0_ & 0x00000008) == 0x00000008)) {
6978         output.writeMessage(4, event_);
6979       }
6980       getUnknownFields().writeTo(output);
6981     }
6982
6983     private int memoizedSerializedSize = -1;
6984     public int getSerializedSize() {
6985       int size = memoizedSerializedSize;
6986       if (size != -1) return size;
6987
6988       size = 0;
6989       if (((bitField0_ & 0x00000001) == 0x00000001)) {
6990         size += com.google.protobuf.CodedOutputStream
6991           .computeEnumSize(1, type_.getNumber());
6992       }
6993       if (((bitField0_ & 0x00000002) == 0x00000002)) {
6994         size += com.google.protobuf.CodedOutputStream
6995           .computeBytesSize(2, getNameBytes());
6996       }
6997       if (((bitField0_ & 0x00000004) == 0x00000004)) {
6998         size += com.google.protobuf.CodedOutputStream
6999           .computeMessageSize(3, value_);
7000       }
7001       if (((bitField0_ & 0x00000008) == 0x00000008)) {
7002         size += com.google.protobuf.CodedOutputStream
7003           .computeMessageSize(4, event_);
7004       }
7005       size += getUnknownFields().getSerializedSize();
7006       memoizedSerializedSize = size;
7007       return size;
7008     }
7009
7010     private static final long serialVersionUID = 0L;
7011     @java.lang.Override
7012     protected java.lang.Object writeReplace()
7013         throws java.io.ObjectStreamException {
7014       return super.writeReplace();
7015     }
7016
7017     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7018         com.google.protobuf.ByteString data)
7019         throws com.google.protobuf.InvalidProtocolBufferException {
7020       return PARSER.parseFrom(data);
7021     }
7022     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7023         com.google.protobuf.ByteString data,
7024         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7025         throws com.google.protobuf.InvalidProtocolBufferException {
7026       return PARSER.parseFrom(data, extensionRegistry);
7027     }
7028     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
7029         throws com.google.protobuf.InvalidProtocolBufferException {
7030       return PARSER.parseFrom(data);
7031     }
7032     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7033         byte[] data,
7034         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7035         throws com.google.protobuf.InvalidProtocolBufferException {
7036       return PARSER.parseFrom(data, extensionRegistry);
7037     }
7038     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
7039         throws java.io.IOException {
7040       return PARSER.parseFrom(input);
7041     }
7042     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7043         java.io.InputStream input,
7044         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7045         throws java.io.IOException {
7046       return PARSER.parseFrom(input, extensionRegistry);
7047     }
7048     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
7049         throws java.io.IOException {
7050       return PARSER.parseDelimitedFrom(input);
7051     }
7052     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
7053         java.io.InputStream input,
7054         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7055         throws java.io.IOException {
7056       return PARSER.parseDelimitedFrom(input, extensionRegistry);
7057     }
7058     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7059         com.google.protobuf.CodedInputStream input)
7060         throws java.io.IOException {
7061       return PARSER.parseFrom(input);
7062     }
7063     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
7064         com.google.protobuf.CodedInputStream input,
7065         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7066         throws java.io.IOException {
7067       return PARSER.parseFrom(input, extensionRegistry);
7068     }
7069
7070     public static Builder newBuilder() { return Builder.create(); }
7071     public Builder newBuilderForType() { return newBuilder(); }
7072     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
7073       return newBuilder().mergeFrom(prototype);
7074     }
7075     public Builder toBuilder() { return newBuilder(this); }
7076
7077     @java.lang.Override
7078     protected Builder newBuilderForType(
7079         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7080       Builder builder = new Builder(parent);
7081       return builder;
7082     }
7083     /**
7084      * Protobuf type {@code openxc.TranslatedMessage}
7085      */
7086     public static final class Builder extends
7087         com.google.protobuf.GeneratedMessage.Builder<Builder>
7088        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
7089       public static final com.google.protobuf.Descriptors.Descriptor
7090           getDescriptor() {
7091         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
7092       }
7093
7094       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
7095           internalGetFieldAccessorTable() {
7096         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
7097             .ensureFieldAccessorsInitialized(
7098                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
7099       }
7100
7101       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
7102       private Builder() {
7103         maybeForceBuilderInitialization();
7104       }
7105
7106       private Builder(
7107           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
7108         super(parent);
7109         maybeForceBuilderInitialization();
7110       }
7111       private void maybeForceBuilderInitialization() {
7112         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
7113           getValueFieldBuilder();
7114           getEventFieldBuilder();
7115         }
7116       }
7117       private static Builder create() {
7118         return new Builder();
7119       }
7120
7121       public Builder clear() {
7122         super.clear();
7123         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7124         bitField0_ = (bitField0_ & ~0x00000001);
7125         name_ = "";
7126         bitField0_ = (bitField0_ & ~0x00000002);
7127         if (valueBuilder_ == null) {
7128           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7129         } else {
7130           valueBuilder_.clear();
7131         }
7132         bitField0_ = (bitField0_ & ~0x00000004);
7133         if (eventBuilder_ == null) {
7134           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7135         } else {
7136           eventBuilder_.clear();
7137         }
7138         bitField0_ = (bitField0_ & ~0x00000008);
7139         return this;
7140       }
7141
7142       public Builder clone() {
7143         return create().mergeFrom(buildPartial());
7144       }
7145
7146       public com.google.protobuf.Descriptors.Descriptor
7147           getDescriptorForType() {
7148         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
7149       }
7150
7151       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
7152         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
7153       }
7154
7155       public com.openxc.BinaryMessages.TranslatedMessage build() {
7156         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
7157         if (!result.isInitialized()) {
7158           throw newUninitializedMessageException(result);
7159         }
7160         return result;
7161       }
7162
7163       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
7164         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
7165         int from_bitField0_ = bitField0_;
7166         int to_bitField0_ = 0;
7167         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
7168           to_bitField0_ |= 0x00000001;
7169         }
7170         result.type_ = type_;
7171         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
7172           to_bitField0_ |= 0x00000002;
7173         }
7174         result.name_ = name_;
7175         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
7176           to_bitField0_ |= 0x00000004;
7177         }
7178         if (valueBuilder_ == null) {
7179           result.value_ = value_;
7180         } else {
7181           result.value_ = valueBuilder_.build();
7182         }
7183         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
7184           to_bitField0_ |= 0x00000008;
7185         }
7186         if (eventBuilder_ == null) {
7187           result.event_ = event_;
7188         } else {
7189           result.event_ = eventBuilder_.build();
7190         }
7191         result.bitField0_ = to_bitField0_;
7192         onBuilt();
7193         return result;
7194       }
7195
7196       public Builder mergeFrom(com.google.protobuf.Message other) {
7197         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
7198           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
7199         } else {
7200           super.mergeFrom(other);
7201           return this;
7202         }
7203       }
7204
7205       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
7206         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
7207         if (other.hasType()) {
7208           setType(other.getType());
7209         }
7210         if (other.hasName()) {
7211           bitField0_ |= 0x00000002;
7212           name_ = other.name_;
7213           onChanged();
7214         }
7215         if (other.hasValue()) {
7216           mergeValue(other.getValue());
7217         }
7218         if (other.hasEvent()) {
7219           mergeEvent(other.getEvent());
7220         }
7221         this.mergeUnknownFields(other.getUnknownFields());
7222         return this;
7223       }
7224
7225       public final boolean isInitialized() {
7226         return true;
7227       }
7228
7229       public Builder mergeFrom(
7230           com.google.protobuf.CodedInputStream input,
7231           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
7232           throws java.io.IOException {
7233         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
7234         try {
7235           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
7236         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
7237           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
7238           throw e;
7239         } finally {
7240           if (parsedMessage != null) {
7241             mergeFrom(parsedMessage);
7242           }
7243         }
7244         return this;
7245       }
7246       private int bitField0_;
7247
7248       // optional .openxc.TranslatedMessage.Type type = 1;
7249       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7250       /**
7251        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7252        */
7253       public boolean hasType() {
7254         return ((bitField0_ & 0x00000001) == 0x00000001);
7255       }
7256       /**
7257        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7258        */
7259       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
7260         return type_;
7261       }
7262       /**
7263        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7264        */
7265       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
7266         if (value == null) {
7267           throw new NullPointerException();
7268         }
7269         bitField0_ |= 0x00000001;
7270         type_ = value;
7271         onChanged();
7272         return this;
7273       }
7274       /**
7275        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
7276        */
7277       public Builder clearType() {
7278         bitField0_ = (bitField0_ & ~0x00000001);
7279         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
7280         onChanged();
7281         return this;
7282       }
7283
7284       // optional string name = 2;
7285       private java.lang.Object name_ = "";
7286       /**
7287        * <code>optional string name = 2;</code>
7288        */
7289       public boolean hasName() {
7290         return ((bitField0_ & 0x00000002) == 0x00000002);
7291       }
7292       /**
7293        * <code>optional string name = 2;</code>
7294        */
7295       public java.lang.String getName() {
7296         java.lang.Object ref = name_;
7297         if (!(ref instanceof java.lang.String)) {
7298           java.lang.String s = ((com.google.protobuf.ByteString) ref)
7299               .toStringUtf8();
7300           name_ = s;
7301           return s;
7302         } else {
7303           return (java.lang.String) ref;
7304         }
7305       }
7306       /**
7307        * <code>optional string name = 2;</code>
7308        */
7309       public com.google.protobuf.ByteString
7310           getNameBytes() {
7311         java.lang.Object ref = name_;
7312         if (ref instanceof String) {
7313           com.google.protobuf.ByteString b =
7314               com.google.protobuf.ByteString.copyFromUtf8(
7315                   (java.lang.String) ref);
7316           name_ = b;
7317           return b;
7318         } else {
7319           return (com.google.protobuf.ByteString) ref;
7320         }
7321       }
7322       /**
7323        * <code>optional string name = 2;</code>
7324        */
7325       public Builder setName(
7326           java.lang.String value) {
7327         if (value == null) {
7328     throw new NullPointerException();
7329   }
7330   bitField0_ |= 0x00000002;
7331         name_ = value;
7332         onChanged();
7333         return this;
7334       }
7335       /**
7336        * <code>optional string name = 2;</code>
7337        */
7338       public Builder clearName() {
7339         bitField0_ = (bitField0_ & ~0x00000002);
7340         name_ = getDefaultInstance().getName();
7341         onChanged();
7342         return this;
7343       }
7344       /**
7345        * <code>optional string name = 2;</code>
7346        */
7347       public Builder setNameBytes(
7348           com.google.protobuf.ByteString value) {
7349         if (value == null) {
7350     throw new NullPointerException();
7351   }
7352   bitField0_ |= 0x00000002;
7353         name_ = value;
7354         onChanged();
7355         return this;
7356       }
7357
7358       // optional .openxc.DynamicField value = 3;
7359       private com.openxc.BinaryMessages.DynamicField value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7360       private com.google.protobuf.SingleFieldBuilder<
7361           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> valueBuilder_;
7362       /**
7363        * <code>optional .openxc.DynamicField value = 3;</code>
7364        */
7365       public boolean hasValue() {
7366         return ((bitField0_ & 0x00000004) == 0x00000004);
7367       }
7368       /**
7369        * <code>optional .openxc.DynamicField value = 3;</code>
7370        */
7371       public com.openxc.BinaryMessages.DynamicField getValue() {
7372         if (valueBuilder_ == null) {
7373           return value_;
7374         } else {
7375           return valueBuilder_.getMessage();
7376         }
7377       }
7378       /**
7379        * <code>optional .openxc.DynamicField value = 3;</code>
7380        */
7381       public Builder setValue(com.openxc.BinaryMessages.DynamicField value) {
7382         if (valueBuilder_ == null) {
7383           if (value == null) {
7384             throw new NullPointerException();
7385           }
7386           value_ = value;
7387           onChanged();
7388         } else {
7389           valueBuilder_.setMessage(value);
7390         }
7391         bitField0_ |= 0x00000004;
7392         return this;
7393       }
7394       /**
7395        * <code>optional .openxc.DynamicField value = 3;</code>
7396        */
7397       public Builder setValue(
7398           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
7399         if (valueBuilder_ == null) {
7400           value_ = builderForValue.build();
7401           onChanged();
7402         } else {
7403           valueBuilder_.setMessage(builderForValue.build());
7404         }
7405         bitField0_ |= 0x00000004;
7406         return this;
7407       }
7408       /**
7409        * <code>optional .openxc.DynamicField value = 3;</code>
7410        */
7411       public Builder mergeValue(com.openxc.BinaryMessages.DynamicField value) {
7412         if (valueBuilder_ == null) {
7413           if (((bitField0_ & 0x00000004) == 0x00000004) &&
7414               value_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
7415             value_ =
7416               com.openxc.BinaryMessages.DynamicField.newBuilder(value_).mergeFrom(value).buildPartial();
7417           } else {
7418             value_ = value;
7419           }
7420           onChanged();
7421         } else {
7422           valueBuilder_.mergeFrom(value);
7423         }
7424         bitField0_ |= 0x00000004;
7425         return this;
7426       }
7427       /**
7428        * <code>optional .openxc.DynamicField value = 3;</code>
7429        */
7430       public Builder clearValue() {
7431         if (valueBuilder_ == null) {
7432           value_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7433           onChanged();
7434         } else {
7435           valueBuilder_.clear();
7436         }
7437         bitField0_ = (bitField0_ & ~0x00000004);
7438         return this;
7439       }
7440       /**
7441        * <code>optional .openxc.DynamicField value = 3;</code>
7442        */
7443       public com.openxc.BinaryMessages.DynamicField.Builder getValueBuilder() {
7444         bitField0_ |= 0x00000004;
7445         onChanged();
7446         return getValueFieldBuilder().getBuilder();
7447       }
7448       /**
7449        * <code>optional .openxc.DynamicField value = 3;</code>
7450        */
7451       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getValueOrBuilder() {
7452         if (valueBuilder_ != null) {
7453           return valueBuilder_.getMessageOrBuilder();
7454         } else {
7455           return value_;
7456         }
7457       }
7458       /**
7459        * <code>optional .openxc.DynamicField value = 3;</code>
7460        */
7461       private com.google.protobuf.SingleFieldBuilder<
7462           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
7463           getValueFieldBuilder() {
7464         if (valueBuilder_ == null) {
7465           valueBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7466               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
7467                   value_,
7468                   getParentForChildren(),
7469                   isClean());
7470           value_ = null;
7471         }
7472         return valueBuilder_;
7473       }
7474
7475       // optional .openxc.DynamicField event = 4;
7476       private com.openxc.BinaryMessages.DynamicField event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7477       private com.google.protobuf.SingleFieldBuilder<
7478           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder> eventBuilder_;
7479       /**
7480        * <code>optional .openxc.DynamicField event = 4;</code>
7481        */
7482       public boolean hasEvent() {
7483         return ((bitField0_ & 0x00000008) == 0x00000008);
7484       }
7485       /**
7486        * <code>optional .openxc.DynamicField event = 4;</code>
7487        */
7488       public com.openxc.BinaryMessages.DynamicField getEvent() {
7489         if (eventBuilder_ == null) {
7490           return event_;
7491         } else {
7492           return eventBuilder_.getMessage();
7493         }
7494       }
7495       /**
7496        * <code>optional .openxc.DynamicField event = 4;</code>
7497        */
7498       public Builder setEvent(com.openxc.BinaryMessages.DynamicField value) {
7499         if (eventBuilder_ == null) {
7500           if (value == null) {
7501             throw new NullPointerException();
7502           }
7503           event_ = value;
7504           onChanged();
7505         } else {
7506           eventBuilder_.setMessage(value);
7507         }
7508         bitField0_ |= 0x00000008;
7509         return this;
7510       }
7511       /**
7512        * <code>optional .openxc.DynamicField event = 4;</code>
7513        */
7514       public Builder setEvent(
7515           com.openxc.BinaryMessages.DynamicField.Builder builderForValue) {
7516         if (eventBuilder_ == null) {
7517           event_ = builderForValue.build();
7518           onChanged();
7519         } else {
7520           eventBuilder_.setMessage(builderForValue.build());
7521         }
7522         bitField0_ |= 0x00000008;
7523         return this;
7524       }
7525       /**
7526        * <code>optional .openxc.DynamicField event = 4;</code>
7527        */
7528       public Builder mergeEvent(com.openxc.BinaryMessages.DynamicField value) {
7529         if (eventBuilder_ == null) {
7530           if (((bitField0_ & 0x00000008) == 0x00000008) &&
7531               event_ != com.openxc.BinaryMessages.DynamicField.getDefaultInstance()) {
7532             event_ =
7533               com.openxc.BinaryMessages.DynamicField.newBuilder(event_).mergeFrom(value).buildPartial();
7534           } else {
7535             event_ = value;
7536           }
7537           onChanged();
7538         } else {
7539           eventBuilder_.mergeFrom(value);
7540         }
7541         bitField0_ |= 0x00000008;
7542         return this;
7543       }
7544       /**
7545        * <code>optional .openxc.DynamicField event = 4;</code>
7546        */
7547       public Builder clearEvent() {
7548         if (eventBuilder_ == null) {
7549           event_ = com.openxc.BinaryMessages.DynamicField.getDefaultInstance();
7550           onChanged();
7551         } else {
7552           eventBuilder_.clear();
7553         }
7554         bitField0_ = (bitField0_ & ~0x00000008);
7555         return this;
7556       }
7557       /**
7558        * <code>optional .openxc.DynamicField event = 4;</code>
7559        */
7560       public com.openxc.BinaryMessages.DynamicField.Builder getEventBuilder() {
7561         bitField0_ |= 0x00000008;
7562         onChanged();
7563         return getEventFieldBuilder().getBuilder();
7564       }
7565       /**
7566        * <code>optional .openxc.DynamicField event = 4;</code>
7567        */
7568       public com.openxc.BinaryMessages.DynamicFieldOrBuilder getEventOrBuilder() {
7569         if (eventBuilder_ != null) {
7570           return eventBuilder_.getMessageOrBuilder();
7571         } else {
7572           return event_;
7573         }
7574       }
7575       /**
7576        * <code>optional .openxc.DynamicField event = 4;</code>
7577        */
7578       private com.google.protobuf.SingleFieldBuilder<
7579           com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>
7580           getEventFieldBuilder() {
7581         if (eventBuilder_ == null) {
7582           eventBuilder_ = new com.google.protobuf.SingleFieldBuilder<
7583               com.openxc.BinaryMessages.DynamicField, com.openxc.BinaryMessages.DynamicField.Builder, com.openxc.BinaryMessages.DynamicFieldOrBuilder>(
7584                   event_,
7585                   getParentForChildren(),
7586                   isClean());
7587           event_ = null;
7588         }
7589         return eventBuilder_;
7590       }
7591
7592       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
7593     }
7594
7595     static {
7596       defaultInstance = new TranslatedMessage(true);
7597       defaultInstance.initFields();
7598     }
7599
7600     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
7601   }
7602
7603   private static com.google.protobuf.Descriptors.Descriptor
7604     internal_static_openxc_VehicleMessage_descriptor;
7605   private static
7606     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7607       internal_static_openxc_VehicleMessage_fieldAccessorTable;
7608   private static com.google.protobuf.Descriptors.Descriptor
7609     internal_static_openxc_RawMessage_descriptor;
7610   private static
7611     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7612       internal_static_openxc_RawMessage_fieldAccessorTable;
7613   private static com.google.protobuf.Descriptors.Descriptor
7614     internal_static_openxc_ControlCommand_descriptor;
7615   private static
7616     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7617       internal_static_openxc_ControlCommand_fieldAccessorTable;
7618   private static com.google.protobuf.Descriptors.Descriptor
7619     internal_static_openxc_CommandResponse_descriptor;
7620   private static
7621     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7622       internal_static_openxc_CommandResponse_fieldAccessorTable;
7623   private static com.google.protobuf.Descriptors.Descriptor
7624     internal_static_openxc_DiagnosticRequest_descriptor;
7625   private static
7626     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7627       internal_static_openxc_DiagnosticRequest_fieldAccessorTable;
7628   private static com.google.protobuf.Descriptors.Descriptor
7629     internal_static_openxc_DiagnosticResponse_descriptor;
7630   private static
7631     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7632       internal_static_openxc_DiagnosticResponse_fieldAccessorTable;
7633   private static com.google.protobuf.Descriptors.Descriptor
7634     internal_static_openxc_DynamicField_descriptor;
7635   private static
7636     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7637       internal_static_openxc_DynamicField_fieldAccessorTable;
7638   private static com.google.protobuf.Descriptors.Descriptor
7639     internal_static_openxc_TranslatedMessage_descriptor;
7640   private static
7641     com.google.protobuf.GeneratedMessage.FieldAccessorTable
7642       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
7643
7644   public static com.google.protobuf.Descriptors.FileDescriptor
7645       getDescriptor() {
7646     return descriptor;
7647   }
7648   private static com.google.protobuf.Descriptors.FileDescriptor
7649       descriptor;
7650   static {
7651     java.lang.String[] descriptorData = {
7652       "\n\014openxc.proto\022\006openxc\"\224\003\n\016VehicleMessag" +
7653       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
7654       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
7655       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
7656       "xc.TranslatedMessage\0227\n\023diagnostic_respo" +
7657       "nse\030\004 \001(\0132\032.openxc.DiagnosticResponse\022/\n" +
7658       "\017control_command\030\005 \001(\0132\026.openxc.ControlC" +
7659       "ommand\0221\n\020command_response\030\006 \001(\0132\027.openx" +
7660       "c.CommandResponse\"Z\n\004Type\022\007\n\003RAW\020\001\022\016\n\nTR" +
7661       "ANSLATED\020\002\022\016\n\nDIAGNOSTIC\020\003\022\023\n\017CONTROL_CO",
7662       "MMAND\020\004\022\024\n\020COMMAND_RESPONSE\020\005\";\n\nRawMess" +
7663       "age\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004" +
7664       "data\030\003 \001(\014\"\246\001\n\016ControlCommand\022)\n\004type\030\001 " +
7665       "\001(\0162\033.openxc.ControlCommand.Type\0225\n\022diag" +
7666       "nostic_request\030\002 \001(\0132\031.openxc.Diagnostic" +
7667       "Request\"2\n\004Type\022\013\n\007VERSION\020\001\022\r\n\tDEVICE_I" +
7668       "D\020\002\022\016\n\nDIAGNOSTIC\020\003\"M\n\017CommandResponse\022)" +
7669       "\n\004type\030\001 \001(\0162\033.openxc.ControlCommand.Typ" +
7670       "e\022\017\n\007message\030\002 \001(\t\"\316\002\n\021DiagnosticRequest" +
7671       "\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004mod",
7672       "e\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007payload\030\005 \001(\014\022\032\n" +
7673       "\022multiple_responses\030\006 \001(\010\022\021\n\tfrequency\030\007" +
7674       " \001(\001\022\014\n\004name\030\010 \001(\t\022;\n\014decoded_type\030\t \001(\016" +
7675       "2%.openxc.DiagnosticRequest.DecodedType\022" +
7676       "0\n\006action\030\n \001(\0162 .openxc.DiagnosticReque" +
7677       "st.Action\"!\n\013DecodedType\022\010\n\004NONE\020\001\022\010\n\004OB" +
7678       "D2\020\002\"\035\n\006Action\022\007\n\003ADD\020\001\022\n\n\006CANCEL\020\003\"\241\001\n\022" +
7679       "DiagnosticResponse\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessa" +
7680       "ge_id\030\002 \001(\r\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017" +
7681       "\n\007success\030\005 \001(\010\022\036\n\026negative_response_cod",
7682       "e\030\006 \001(\r\022\017\n\007payload\030\007 \001(\014\022\r\n\005value\030\010 \001(\001\"" +
7683       "\242\001\n\014DynamicField\022\'\n\004type\030\001 \001(\0162\031.openxc." +
7684       "DynamicField.Type\022\024\n\014string_value\030\002 \001(\t\022" +
7685       "\025\n\rnumeric_value\030\003 \001(\001\022\025\n\rboolean_value\030" +
7686       "\004 \001(\010\"%\n\004Type\022\n\n\006STRING\020\001\022\007\n\003NUM\020\002\022\010\n\004BO" +
7687       "OL\020\003\"\367\001\n\021TranslatedMessage\022,\n\004type\030\001 \001(\016" +
7688       "2\036.openxc.TranslatedMessage.Type\022\014\n\004name" +
7689       "\030\002 \001(\t\022#\n\005value\030\003 \001(\0132\024.openxc.DynamicFi" +
7690       "eld\022#\n\005event\030\004 \001(\0132\024.openxc.DynamicField" +
7691       "\"\\\n\004Type\022\n\n\006STRING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\022",
7692       "\022\n\016EVENTED_STRING\020\004\022\017\n\013EVENTED_NUM\020\005\022\020\n\014" +
7693       "EVENTED_BOOL\020\006B\034\n\ncom.openxcB\016BinaryMess" +
7694       "ages"
7695     };
7696     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
7697       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
7698         public com.google.protobuf.ExtensionRegistry assignDescriptors(
7699             com.google.protobuf.Descriptors.FileDescriptor root) {
7700           descriptor = root;
7701           internal_static_openxc_VehicleMessage_descriptor =
7702             getDescriptor().getMessageTypes().get(0);
7703           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
7704             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7705               internal_static_openxc_VehicleMessage_descriptor,
7706               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticResponse", "ControlCommand", "CommandResponse", });
7707           internal_static_openxc_RawMessage_descriptor =
7708             getDescriptor().getMessageTypes().get(1);
7709           internal_static_openxc_RawMessage_fieldAccessorTable = new
7710             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7711               internal_static_openxc_RawMessage_descriptor,
7712               new java.lang.String[] { "Bus", "MessageId", "Data", });
7713           internal_static_openxc_ControlCommand_descriptor =
7714             getDescriptor().getMessageTypes().get(2);
7715           internal_static_openxc_ControlCommand_fieldAccessorTable = new
7716             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7717               internal_static_openxc_ControlCommand_descriptor,
7718               new java.lang.String[] { "Type", "DiagnosticRequest", });
7719           internal_static_openxc_CommandResponse_descriptor =
7720             getDescriptor().getMessageTypes().get(3);
7721           internal_static_openxc_CommandResponse_fieldAccessorTable = new
7722             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7723               internal_static_openxc_CommandResponse_descriptor,
7724               new java.lang.String[] { "Type", "Message", });
7725           internal_static_openxc_DiagnosticRequest_descriptor =
7726             getDescriptor().getMessageTypes().get(4);
7727           internal_static_openxc_DiagnosticRequest_fieldAccessorTable = new
7728             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7729               internal_static_openxc_DiagnosticRequest_descriptor,
7730               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Payload", "MultipleResponses", "Frequency", "Name", "DecodedType", "Action", });
7731           internal_static_openxc_DiagnosticResponse_descriptor =
7732             getDescriptor().getMessageTypes().get(5);
7733           internal_static_openxc_DiagnosticResponse_fieldAccessorTable = new
7734             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7735               internal_static_openxc_DiagnosticResponse_descriptor,
7736               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", "Value", });
7737           internal_static_openxc_DynamicField_descriptor =
7738             getDescriptor().getMessageTypes().get(6);
7739           internal_static_openxc_DynamicField_fieldAccessorTable = new
7740             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7741               internal_static_openxc_DynamicField_descriptor,
7742               new java.lang.String[] { "Type", "StringValue", "NumericValue", "BooleanValue", });
7743           internal_static_openxc_TranslatedMessage_descriptor =
7744             getDescriptor().getMessageTypes().get(7);
7745           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
7746             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
7747               internal_static_openxc_TranslatedMessage_descriptor,
7748               new java.lang.String[] { "Type", "Name", "Value", "Event", });
7749           return null;
7750         }
7751       };
7752     com.google.protobuf.Descriptors.FileDescriptor
7753       .internalBuildGeneratedFileFrom(descriptorData,
7754         new com.google.protobuf.Descriptors.FileDescriptor[] {
7755         }, assigner);
7756   }
7757
7758   // @@protoc_insertion_point(outer_class_scope)
7759 }