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.DiagnosticMessage diagnostic_message = 4;
  53     /**
  54      * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
  55      */
  56     boolean hasDiagnosticMessage();
  57     /**
  58      * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
  59      */
  60     com.openxc.BinaryMessages.DiagnosticMessage getDiagnosticMessage();
  61     /**
  62      * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
  63      */
  64     com.openxc.BinaryMessages.DiagnosticMessageOrBuilder getDiagnosticMessageOrBuilder();
  65   }
  66   /**
  67    * Protobuf type {@code openxc.VehicleMessage}
  68    */
  69   public static final class VehicleMessage extends
  70       com.google.protobuf.GeneratedMessage
  71       implements VehicleMessageOrBuilder {
  72     // Use VehicleMessage.newBuilder() to construct.
  73     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
  74       super(builder);
  75       this.unknownFields = builder.getUnknownFields();
  76     }
  77     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
  78
  79     private static final VehicleMessage defaultInstance;
  80     public static VehicleMessage getDefaultInstance() {
  81       return defaultInstance;
  82     }
  83
  84     public VehicleMessage getDefaultInstanceForType() {
  85       return defaultInstance;
  86     }
  87
  88     private final com.google.protobuf.UnknownFieldSet unknownFields;
  89     @java.lang.Override
  90     public final com.google.protobuf.UnknownFieldSet
  91         getUnknownFields() {
  92       return this.unknownFields;
  93     }
  94     private VehicleMessage(
  95         com.google.protobuf.CodedInputStream input,
  96         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
  97         throws com.google.protobuf.InvalidProtocolBufferException {
  98       initFields();
  99       int mutable_bitField0_ = 0;
 100       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 101           com.google.protobuf.UnknownFieldSet.newBuilder();
 102       try {
 103         boolean done = false;
 104         while (!done) {
 105           int tag = input.readTag();
 106           switch (tag) {
 107             case 0:
 108               done = true;
 109               break;
 110             default: {
 111               if (!parseUnknownField(input, unknownFields,
 112                                      extensionRegistry, tag)) {
 113                 done = true;
 114               }
 115               break;
 116             }
 117             case 8: {
 118               int rawValue = input.readEnum();
 119               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 120               if (value == null) {
 121                 unknownFields.mergeVarintField(1, rawValue);
 122               } else {
 123                 bitField0_ |= 0x00000001;
 124                 type_ = value;
 125               }
 126               break;
 127             }
 128             case 18: {
 129               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
 130               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 131                 subBuilder = rawMessage_.toBuilder();
 132               }
 133               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
 134               if (subBuilder != null) {
 135                 subBuilder.mergeFrom(rawMessage_);
 136                 rawMessage_ = subBuilder.buildPartial();
 137               }
 138               bitField0_ |= 0x00000002;
 139               break;
 140             }
 141             case 26: {
 142               com.openxc.BinaryMessages.TranslatedMessage.Builder subBuilder = null;
 143               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 144                 subBuilder = translatedMessage_.toBuilder();
 145               }
 146               translatedMessage_ = input.readMessage(com.openxc.BinaryMessages.TranslatedMessage.PARSER, extensionRegistry);
 147               if (subBuilder != null) {
 148                 subBuilder.mergeFrom(translatedMessage_);
 149                 translatedMessage_ = subBuilder.buildPartial();
 150               }
 151               bitField0_ |= 0x00000004;
 152               break;
 153             }
 154             case 34: {
 155               com.openxc.BinaryMessages.DiagnosticMessage.Builder subBuilder = null;
 156               if (((bitField0_ & 0x00000008) == 0x00000008)) {
 157                 subBuilder = diagnosticMessage_.toBuilder();
 158               }
 159               diagnosticMessage_ = input.readMessage(com.openxc.BinaryMessages.DiagnosticMessage.PARSER, extensionRegistry);
 160               if (subBuilder != null) {
 161                 subBuilder.mergeFrom(diagnosticMessage_);
 162                 diagnosticMessage_ = subBuilder.buildPartial();
 163               }
 164               bitField0_ |= 0x00000008;
 165               break;
 166             }
 167           }
 168         }
 169       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 170         throw e.setUnfinishedMessage(this);
 171       } catch (java.io.IOException e) {
 172         throw new com.google.protobuf.InvalidProtocolBufferException(
 173             e.getMessage()).setUnfinishedMessage(this);
 174       } finally {
 175         this.unknownFields = unknownFields.build();
 176         makeExtensionsImmutable();
 177       }
 178     }
 179     public static final com.google.protobuf.Descriptors.Descriptor
 180         getDescriptor() {
 181       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 182     }
 183
 184     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 185         internalGetFieldAccessorTable() {
 186       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 187           .ensureFieldAccessorsInitialized(
 188               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 189     }
 190
 191     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 192         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 193       public VehicleMessage parsePartialFrom(
 194           com.google.protobuf.CodedInputStream input,
 195           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 196           throws com.google.protobuf.InvalidProtocolBufferException {
 197         return new VehicleMessage(input, extensionRegistry);
 198       }
 199     };
 200
 201     @java.lang.Override
 202     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 203       return PARSER;
 204     }
 205
 206     /**
 207      * Protobuf enum {@code openxc.VehicleMessage.Type}
 208      */
 209     public enum Type
 210         implements com.google.protobuf.ProtocolMessageEnum {
 211       /**
 212        * <code>RAW = 1;</code>
 213        */
 214       RAW(0, 1),
 215       /**
 216        * <code>TRANSLATED = 2;</code>
 217        */
 218       TRANSLATED(1, 2),
 219       /**
 220        * <code>DIAGNOSTIC = 3;</code>
 221        */
 222       DIAGNOSTIC(2, 3),
 223       ;
 224
 225       /**
 226        * <code>RAW = 1;</code>
 227        */
 228       public static final int RAW_VALUE = 1;
 229       /**
 230        * <code>TRANSLATED = 2;</code>
 231        */
 232       public static final int TRANSLATED_VALUE = 2;
 233       /**
 234        * <code>DIAGNOSTIC = 3;</code>
 235        */
 236       public static final int DIAGNOSTIC_VALUE = 3;
 237
 238
 239       public final int getNumber() { return value; }
 240
 241       public static Type valueOf(int value) {
 242         switch (value) {
 243           case 1: return RAW;
 244           case 2: return TRANSLATED;
 245           case 3: return DIAGNOSTIC;
 246           default: return null;
 247         }
 248       }
 249
 250       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 251           internalGetValueMap() {
 252         return internalValueMap;
 253       }
 254       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 255           internalValueMap =
 256             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 257               public Type findValueByNumber(int number) {
 258                 return Type.valueOf(number);
 259               }
 260             };
 261
 262       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 263           getValueDescriptor() {
 264         return getDescriptor().getValues().get(index);
 265       }
 266       public final com.google.protobuf.Descriptors.EnumDescriptor
 267           getDescriptorForType() {
 268         return getDescriptor();
 269       }
 270       public static final com.google.protobuf.Descriptors.EnumDescriptor
 271           getDescriptor() {
 272         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 273       }
 274
 275       private static final Type[] VALUES = values();
 276
 277       public static Type valueOf(
 278           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 279         if (desc.getType() != getDescriptor()) {
 280           throw new java.lang.IllegalArgumentException(
 281             "EnumValueDescriptor is not for this type.");
 282         }
 283         return VALUES[desc.getIndex()];
 284       }
 285
 286       private final int index;
 287       private final int value;
 288
 289       private Type(int index, int value) {
 290         this.index = index;
 291         this.value = value;
 292       }
 293
 294       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 295     }
 296
 297     private int bitField0_;
 298     // optional .openxc.VehicleMessage.Type type = 1;
 299     public static final int TYPE_FIELD_NUMBER = 1;
 300     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 301     /**
 302      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 303      */
 304     public boolean hasType() {
 305       return ((bitField0_ & 0x00000001) == 0x00000001);
 306     }
 307     /**
 308      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 309      */
 310     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 311       return type_;
 312     }
 313
 314     // optional .openxc.RawMessage raw_message = 2;
 315     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
 316     private com.openxc.BinaryMessages.RawMessage rawMessage_;
 317     /**
 318      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 319      */
 320     public boolean hasRawMessage() {
 321       return ((bitField0_ & 0x00000002) == 0x00000002);
 322     }
 323     /**
 324      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 325      */
 326     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 327       return rawMessage_;
 328     }
 329     /**
 330      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 331      */
 332     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 333       return rawMessage_;
 334     }
 335
 336     // optional .openxc.TranslatedMessage translated_message = 3;
 337     public static final int TRANSLATED_MESSAGE_FIELD_NUMBER = 3;
 338     private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_;
 339     /**
 340      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 341      */
 342     public boolean hasTranslatedMessage() {
 343       return ((bitField0_ & 0x00000004) == 0x00000004);
 344     }
 345     /**
 346      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 347      */
 348     public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 349       return translatedMessage_;
 350     }
 351     /**
 352      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 353      */
 354     public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 355       return translatedMessage_;
 356     }
 357
 358     // optional .openxc.DiagnosticMessage diagnostic_message = 4;
 359     public static final int DIAGNOSTIC_MESSAGE_FIELD_NUMBER = 4;
 360     private com.openxc.BinaryMessages.DiagnosticMessage diagnosticMessage_;
 361     /**
 362      * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 363      */
 364     public boolean hasDiagnosticMessage() {
 365       return ((bitField0_ & 0x00000008) == 0x00000008);
 366     }
 367     /**
 368      * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 369      */
 370     public com.openxc.BinaryMessages.DiagnosticMessage getDiagnosticMessage() {
 371       return diagnosticMessage_;
 372     }
 373     /**
 374      * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 375      */
 376     public com.openxc.BinaryMessages.DiagnosticMessageOrBuilder getDiagnosticMessageOrBuilder() {
 377       return diagnosticMessage_;
 378     }
 379
 380     private void initFields() {
 381       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 382       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 383       translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 384       diagnosticMessage_ = com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance();
 385     }
 386     private byte memoizedIsInitialized = -1;
 387     public final boolean isInitialized() {
 388       byte isInitialized = memoizedIsInitialized;
 389       if (isInitialized != -1) return isInitialized == 1;
 390
 391       memoizedIsInitialized = 1;
 392       return true;
 393     }
 394
 395     public void writeTo(com.google.protobuf.CodedOutputStream output)
 396                         throws java.io.IOException {
 397       getSerializedSize();
 398       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 399         output.writeEnum(1, type_.getNumber());
 400       }
 401       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 402         output.writeMessage(2, rawMessage_);
 403       }
 404       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 405         output.writeMessage(3, translatedMessage_);
 406       }
 407       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 408         output.writeMessage(4, diagnosticMessage_);
 409       }
 410       getUnknownFields().writeTo(output);
 411     }
 412
 413     private int memoizedSerializedSize = -1;
 414     public int getSerializedSize() {
 415       int size = memoizedSerializedSize;
 416       if (size != -1) return size;
 417
 418       size = 0;
 419       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 420         size += com.google.protobuf.CodedOutputStream
 421           .computeEnumSize(1, type_.getNumber());
 422       }
 423       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 424         size += com.google.protobuf.CodedOutputStream
 425           .computeMessageSize(2, rawMessage_);
 426       }
 427       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 428         size += com.google.protobuf.CodedOutputStream
 429           .computeMessageSize(3, translatedMessage_);
 430       }
 431       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 432         size += com.google.protobuf.CodedOutputStream
 433           .computeMessageSize(4, diagnosticMessage_);
 434       }
 435       size += getUnknownFields().getSerializedSize();
 436       memoizedSerializedSize = size;
 437       return size;
 438     }
 439
 440     private static final long serialVersionUID = 0L;
 441     @java.lang.Override
 442     protected java.lang.Object writeReplace()
 443         throws java.io.ObjectStreamException {
 444       return super.writeReplace();
 445     }
 446
 447     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 448         com.google.protobuf.ByteString data)
 449         throws com.google.protobuf.InvalidProtocolBufferException {
 450       return PARSER.parseFrom(data);
 451     }
 452     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 453         com.google.protobuf.ByteString data,
 454         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 455         throws com.google.protobuf.InvalidProtocolBufferException {
 456       return PARSER.parseFrom(data, extensionRegistry);
 457     }
 458     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 459         throws com.google.protobuf.InvalidProtocolBufferException {
 460       return PARSER.parseFrom(data);
 461     }
 462     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 463         byte[] data,
 464         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 465         throws com.google.protobuf.InvalidProtocolBufferException {
 466       return PARSER.parseFrom(data, extensionRegistry);
 467     }
 468     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 469         throws java.io.IOException {
 470       return PARSER.parseFrom(input);
 471     }
 472     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 473         java.io.InputStream input,
 474         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 475         throws java.io.IOException {
 476       return PARSER.parseFrom(input, extensionRegistry);
 477     }
 478     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 479         throws java.io.IOException {
 480       return PARSER.parseDelimitedFrom(input);
 481     }
 482     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 483         java.io.InputStream input,
 484         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 485         throws java.io.IOException {
 486       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 487     }
 488     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 489         com.google.protobuf.CodedInputStream input)
 490         throws java.io.IOException {
 491       return PARSER.parseFrom(input);
 492     }
 493     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 494         com.google.protobuf.CodedInputStream input,
 495         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 496         throws java.io.IOException {
 497       return PARSER.parseFrom(input, extensionRegistry);
 498     }
 499
 500     public static Builder newBuilder() { return Builder.create(); }
 501     public Builder newBuilderForType() { return newBuilder(); }
 502     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 503       return newBuilder().mergeFrom(prototype);
 504     }
 505     public Builder toBuilder() { return newBuilder(this); }
 506
 507     @java.lang.Override
 508     protected Builder newBuilderForType(
 509         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 510       Builder builder = new Builder(parent);
 511       return builder;
 512     }
 513     /**
 514      * Protobuf type {@code openxc.VehicleMessage}
 515      */
 516     public static final class Builder extends
 517         com.google.protobuf.GeneratedMessage.Builder<Builder>
 518        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 519       public static final com.google.protobuf.Descriptors.Descriptor
 520           getDescriptor() {
 521         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 522       }
 523
 524       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 525           internalGetFieldAccessorTable() {
 526         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 527             .ensureFieldAccessorsInitialized(
 528                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 529       }
 530
 531       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 532       private Builder() {
 533         maybeForceBuilderInitialization();
 534       }
 535
 536       private Builder(
 537           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 538         super(parent);
 539         maybeForceBuilderInitialization();
 540       }
 541       private void maybeForceBuilderInitialization() {
 542         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 543           getRawMessageFieldBuilder();
 544           getTranslatedMessageFieldBuilder();
 545           getDiagnosticMessageFieldBuilder();
 546         }
 547       }
 548       private static Builder create() {
 549         return new Builder();
 550       }
 551
 552       public Builder clear() {
 553         super.clear();
 554         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 555         bitField0_ = (bitField0_ & ~0x00000001);
 556         if (rawMessageBuilder_ == null) {
 557           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 558         } else {
 559           rawMessageBuilder_.clear();
 560         }
 561         bitField0_ = (bitField0_ & ~0x00000002);
 562         if (translatedMessageBuilder_ == null) {
 563           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 564         } else {
 565           translatedMessageBuilder_.clear();
 566         }
 567         bitField0_ = (bitField0_ & ~0x00000004);
 568         if (diagnosticMessageBuilder_ == null) {
 569           diagnosticMessage_ = com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance();
 570         } else {
 571           diagnosticMessageBuilder_.clear();
 572         }
 573         bitField0_ = (bitField0_ & ~0x00000008);
 574         return this;
 575       }
 576
 577       public Builder clone() {
 578         return create().mergeFrom(buildPartial());
 579       }
 580
 581       public com.google.protobuf.Descriptors.Descriptor
 582           getDescriptorForType() {
 583         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 584       }
 585
 586       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 587         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 588       }
 589
 590       public com.openxc.BinaryMessages.VehicleMessage build() {
 591         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 592         if (!result.isInitialized()) {
 593           throw newUninitializedMessageException(result);
 594         }
 595         return result;
 596       }
 597
 598       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 599         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 600         int from_bitField0_ = bitField0_;
 601         int to_bitField0_ = 0;
 602         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 603           to_bitField0_ |= 0x00000001;
 604         }
 605         result.type_ = type_;
 606         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 607           to_bitField0_ |= 0x00000002;
 608         }
 609         if (rawMessageBuilder_ == null) {
 610           result.rawMessage_ = rawMessage_;
 611         } else {
 612           result.rawMessage_ = rawMessageBuilder_.build();
 613         }
 614         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 615           to_bitField0_ |= 0x00000004;
 616         }
 617         if (translatedMessageBuilder_ == null) {
 618           result.translatedMessage_ = translatedMessage_;
 619         } else {
 620           result.translatedMessage_ = translatedMessageBuilder_.build();
 621         }
 622         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 623           to_bitField0_ |= 0x00000008;
 624         }
 625         if (diagnosticMessageBuilder_ == null) {
 626           result.diagnosticMessage_ = diagnosticMessage_;
 627         } else {
 628           result.diagnosticMessage_ = diagnosticMessageBuilder_.build();
 629         }
 630         result.bitField0_ = to_bitField0_;
 631         onBuilt();
 632         return result;
 633       }
 634
 635       public Builder mergeFrom(com.google.protobuf.Message other) {
 636         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 637           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 638         } else {
 639           super.mergeFrom(other);
 640           return this;
 641         }
 642       }
 643
 644       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 645         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 646         if (other.hasType()) {
 647           setType(other.getType());
 648         }
 649         if (other.hasRawMessage()) {
 650           mergeRawMessage(other.getRawMessage());
 651         }
 652         if (other.hasTranslatedMessage()) {
 653           mergeTranslatedMessage(other.getTranslatedMessage());
 654         }
 655         if (other.hasDiagnosticMessage()) {
 656           mergeDiagnosticMessage(other.getDiagnosticMessage());
 657         }
 658         this.mergeUnknownFields(other.getUnknownFields());
 659         return this;
 660       }
 661
 662       public final boolean isInitialized() {
 663         return true;
 664       }
 665
 666       public Builder mergeFrom(
 667           com.google.protobuf.CodedInputStream input,
 668           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 669           throws java.io.IOException {
 670         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
 671         try {
 672           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 673         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 674           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
 675           throw e;
 676         } finally {
 677           if (parsedMessage != null) {
 678             mergeFrom(parsedMessage);
 679           }
 680         }
 681         return this;
 682       }
 683       private int bitField0_;
 684
 685       // optional .openxc.VehicleMessage.Type type = 1;
 686       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 687       /**
 688        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 689        */
 690       public boolean hasType() {
 691         return ((bitField0_ & 0x00000001) == 0x00000001);
 692       }
 693       /**
 694        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 695        */
 696       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 697         return type_;
 698       }
 699       /**
 700        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 701        */
 702       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 703         if (value == null) {
 704           throw new NullPointerException();
 705         }
 706         bitField0_ |= 0x00000001;
 707         type_ = value;
 708         onChanged();
 709         return this;
 710       }
 711       /**
 712        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 713        */
 714       public Builder clearType() {
 715         bitField0_ = (bitField0_ & ~0x00000001);
 716         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 717         onChanged();
 718         return this;
 719       }
 720
 721       // optional .openxc.RawMessage raw_message = 2;
 722       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 723       private com.google.protobuf.SingleFieldBuilder<
 724           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
 725       /**
 726        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 727        */
 728       public boolean hasRawMessage() {
 729         return ((bitField0_ & 0x00000002) == 0x00000002);
 730       }
 731       /**
 732        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 733        */
 734       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 735         if (rawMessageBuilder_ == null) {
 736           return rawMessage_;
 737         } else {
 738           return rawMessageBuilder_.getMessage();
 739         }
 740       }
 741       /**
 742        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 743        */
 744       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 745         if (rawMessageBuilder_ == null) {
 746           if (value == null) {
 747             throw new NullPointerException();
 748           }
 749           rawMessage_ = value;
 750           onChanged();
 751         } else {
 752           rawMessageBuilder_.setMessage(value);
 753         }
 754         bitField0_ |= 0x00000002;
 755         return this;
 756       }
 757       /**
 758        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 759        */
 760       public Builder setRawMessage(
 761           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
 762         if (rawMessageBuilder_ == null) {
 763           rawMessage_ = builderForValue.build();
 764           onChanged();
 765         } else {
 766           rawMessageBuilder_.setMessage(builderForValue.build());
 767         }
 768         bitField0_ |= 0x00000002;
 769         return this;
 770       }
 771       /**
 772        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 773        */
 774       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 775         if (rawMessageBuilder_ == null) {
 776           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 777               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
 778             rawMessage_ =
 779               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
 780           } else {
 781             rawMessage_ = value;
 782           }
 783           onChanged();
 784         } else {
 785           rawMessageBuilder_.mergeFrom(value);
 786         }
 787         bitField0_ |= 0x00000002;
 788         return this;
 789       }
 790       /**
 791        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 792        */
 793       public Builder clearRawMessage() {
 794         if (rawMessageBuilder_ == null) {
 795           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 796           onChanged();
 797         } else {
 798           rawMessageBuilder_.clear();
 799         }
 800         bitField0_ = (bitField0_ & ~0x00000002);
 801         return this;
 802       }
 803       /**
 804        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 805        */
 806       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
 807         bitField0_ |= 0x00000002;
 808         onChanged();
 809         return getRawMessageFieldBuilder().getBuilder();
 810       }
 811       /**
 812        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 813        */
 814       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 815         if (rawMessageBuilder_ != null) {
 816           return rawMessageBuilder_.getMessageOrBuilder();
 817         } else {
 818           return rawMessage_;
 819         }
 820       }
 821       /**
 822        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 823        */
 824       private com.google.protobuf.SingleFieldBuilder<
 825           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>
 826           getRawMessageFieldBuilder() {
 827         if (rawMessageBuilder_ == null) {
 828           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 829               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
 830                   rawMessage_,
 831                   getParentForChildren(),
 832                   isClean());
 833           rawMessage_ = null;
 834         }
 835         return rawMessageBuilder_;
 836       }
 837
 838       // optional .openxc.TranslatedMessage translated_message = 3;
 839       private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 840       private com.google.protobuf.SingleFieldBuilder<
 841           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> translatedMessageBuilder_;
 842       /**
 843        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 844        */
 845       public boolean hasTranslatedMessage() {
 846         return ((bitField0_ & 0x00000004) == 0x00000004);
 847       }
 848       /**
 849        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 850        */
 851       public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 852         if (translatedMessageBuilder_ == null) {
 853           return translatedMessage_;
 854         } else {
 855           return translatedMessageBuilder_.getMessage();
 856         }
 857       }
 858       /**
 859        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 860        */
 861       public Builder setTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
 862         if (translatedMessageBuilder_ == null) {
 863           if (value == null) {
 864             throw new NullPointerException();
 865           }
 866           translatedMessage_ = value;
 867           onChanged();
 868         } else {
 869           translatedMessageBuilder_.setMessage(value);
 870         }
 871         bitField0_ |= 0x00000004;
 872         return this;
 873       }
 874       /**
 875        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 876        */
 877       public Builder setTranslatedMessage(
 878           com.openxc.BinaryMessages.TranslatedMessage.Builder builderForValue) {
 879         if (translatedMessageBuilder_ == null) {
 880           translatedMessage_ = builderForValue.build();
 881           onChanged();
 882         } else {
 883           translatedMessageBuilder_.setMessage(builderForValue.build());
 884         }
 885         bitField0_ |= 0x00000004;
 886         return this;
 887       }
 888       /**
 889        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 890        */
 891       public Builder mergeTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
 892         if (translatedMessageBuilder_ == null) {
 893           if (((bitField0_ & 0x00000004) == 0x00000004) &&
 894               translatedMessage_ != com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) {
 895             translatedMessage_ =
 896               com.openxc.BinaryMessages.TranslatedMessage.newBuilder(translatedMessage_).mergeFrom(value).buildPartial();
 897           } else {
 898             translatedMessage_ = value;
 899           }
 900           onChanged();
 901         } else {
 902           translatedMessageBuilder_.mergeFrom(value);
 903         }
 904         bitField0_ |= 0x00000004;
 905         return this;
 906       }
 907       /**
 908        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 909        */
 910       public Builder clearTranslatedMessage() {
 911         if (translatedMessageBuilder_ == null) {
 912           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 913           onChanged();
 914         } else {
 915           translatedMessageBuilder_.clear();
 916         }
 917         bitField0_ = (bitField0_ & ~0x00000004);
 918         return this;
 919       }
 920       /**
 921        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 922        */
 923       public com.openxc.BinaryMessages.TranslatedMessage.Builder getTranslatedMessageBuilder() {
 924         bitField0_ |= 0x00000004;
 925         onChanged();
 926         return getTranslatedMessageFieldBuilder().getBuilder();
 927       }
 928       /**
 929        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 930        */
 931       public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 932         if (translatedMessageBuilder_ != null) {
 933           return translatedMessageBuilder_.getMessageOrBuilder();
 934         } else {
 935           return translatedMessage_;
 936         }
 937       }
 938       /**
 939        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 940        */
 941       private com.google.protobuf.SingleFieldBuilder<
 942           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>
 943           getTranslatedMessageFieldBuilder() {
 944         if (translatedMessageBuilder_ == null) {
 945           translatedMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 946               com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>(
 947                   translatedMessage_,
 948                   getParentForChildren(),
 949                   isClean());
 950           translatedMessage_ = null;
 951         }
 952         return translatedMessageBuilder_;
 953       }
 954
 955       // optional .openxc.DiagnosticMessage diagnostic_message = 4;
 956       private com.openxc.BinaryMessages.DiagnosticMessage diagnosticMessage_ = com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance();
 957       private com.google.protobuf.SingleFieldBuilder<
 958           com.openxc.BinaryMessages.DiagnosticMessage, com.openxc.BinaryMessages.DiagnosticMessage.Builder, com.openxc.BinaryMessages.DiagnosticMessageOrBuilder> diagnosticMessageBuilder_;
 959       /**
 960        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 961        */
 962       public boolean hasDiagnosticMessage() {
 963         return ((bitField0_ & 0x00000008) == 0x00000008);
 964       }
 965       /**
 966        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 967        */
 968       public com.openxc.BinaryMessages.DiagnosticMessage getDiagnosticMessage() {
 969         if (diagnosticMessageBuilder_ == null) {
 970           return diagnosticMessage_;
 971         } else {
 972           return diagnosticMessageBuilder_.getMessage();
 973         }
 974       }
 975       /**
 976        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 977        */
 978       public Builder setDiagnosticMessage(com.openxc.BinaryMessages.DiagnosticMessage value) {
 979         if (diagnosticMessageBuilder_ == null) {
 980           if (value == null) {
 981             throw new NullPointerException();
 982           }
 983           diagnosticMessage_ = value;
 984           onChanged();
 985         } else {
 986           diagnosticMessageBuilder_.setMessage(value);
 987         }
 988         bitField0_ |= 0x00000008;
 989         return this;
 990       }
 991       /**
 992        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
 993        */
 994       public Builder setDiagnosticMessage(
 995           com.openxc.BinaryMessages.DiagnosticMessage.Builder builderForValue) {
 996         if (diagnosticMessageBuilder_ == null) {
 997           diagnosticMessage_ = builderForValue.build();
 998           onChanged();
 999         } else {
1000           diagnosticMessageBuilder_.setMessage(builderForValue.build());
1001         }
1002         bitField0_ |= 0x00000008;
1003         return this;
1004       }
1005       /**
1006        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
1007        */
1008       public Builder mergeDiagnosticMessage(com.openxc.BinaryMessages.DiagnosticMessage value) {
1009         if (diagnosticMessageBuilder_ == null) {
1010           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1011               diagnosticMessage_ != com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance()) {
1012             diagnosticMessage_ =
1013               com.openxc.BinaryMessages.DiagnosticMessage.newBuilder(diagnosticMessage_).mergeFrom(value).buildPartial();
1014           } else {
1015             diagnosticMessage_ = value;
1016           }
1017           onChanged();
1018         } else {
1019           diagnosticMessageBuilder_.mergeFrom(value);
1020         }
1021         bitField0_ |= 0x00000008;
1022         return this;
1023       }
1024       /**
1025        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
1026        */
1027       public Builder clearDiagnosticMessage() {
1028         if (diagnosticMessageBuilder_ == null) {
1029           diagnosticMessage_ = com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance();
1030           onChanged();
1031         } else {
1032           diagnosticMessageBuilder_.clear();
1033         }
1034         bitField0_ = (bitField0_ & ~0x00000008);
1035         return this;
1036       }
1037       /**
1038        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
1039        */
1040       public com.openxc.BinaryMessages.DiagnosticMessage.Builder getDiagnosticMessageBuilder() {
1041         bitField0_ |= 0x00000008;
1042         onChanged();
1043         return getDiagnosticMessageFieldBuilder().getBuilder();
1044       }
1045       /**
1046        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
1047        */
1048       public com.openxc.BinaryMessages.DiagnosticMessageOrBuilder getDiagnosticMessageOrBuilder() {
1049         if (diagnosticMessageBuilder_ != null) {
1050           return diagnosticMessageBuilder_.getMessageOrBuilder();
1051         } else {
1052           return diagnosticMessage_;
1053         }
1054       }
1055       /**
1056        * <code>optional .openxc.DiagnosticMessage diagnostic_message = 4;</code>
1057        */
1058       private com.google.protobuf.SingleFieldBuilder<
1059           com.openxc.BinaryMessages.DiagnosticMessage, com.openxc.BinaryMessages.DiagnosticMessage.Builder, com.openxc.BinaryMessages.DiagnosticMessageOrBuilder>
1060           getDiagnosticMessageFieldBuilder() {
1061         if (diagnosticMessageBuilder_ == null) {
1062           diagnosticMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1063               com.openxc.BinaryMessages.DiagnosticMessage, com.openxc.BinaryMessages.DiagnosticMessage.Builder, com.openxc.BinaryMessages.DiagnosticMessageOrBuilder>(
1064                   diagnosticMessage_,
1065                   getParentForChildren(),
1066                   isClean());
1067           diagnosticMessage_ = null;
1068         }
1069         return diagnosticMessageBuilder_;
1070       }
1071
1072       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1073     }
1074
1075     static {
1076       defaultInstance = new VehicleMessage(true);
1077       defaultInstance.initFields();
1078     }
1079
1080     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1081   }
1082
1083   public interface RawMessageOrBuilder
1084       extends com.google.protobuf.MessageOrBuilder {
1085
1086     // optional int32 bus = 1;
1087     /**
1088      * <code>optional int32 bus = 1;</code>
1089      */
1090     boolean hasBus();
1091     /**
1092      * <code>optional int32 bus = 1;</code>
1093      */
1094     int getBus();
1095
1096     // optional uint32 message_id = 2;
1097     /**
1098      * <code>optional uint32 message_id = 2;</code>
1099      */
1100     boolean hasMessageId();
1101     /**
1102      * <code>optional uint32 message_id = 2;</code>
1103      */
1104     int getMessageId();
1105
1106     // optional bytes data = 3;
1107     /**
1108      * <code>optional bytes data = 3;</code>
1109      */
1110     boolean hasData();
1111     /**
1112      * <code>optional bytes data = 3;</code>
1113      */
1114     com.google.protobuf.ByteString getData();
1115   }
1116   /**
1117    * Protobuf type {@code openxc.RawMessage}
1118    */
1119   public static final class RawMessage extends
1120       com.google.protobuf.GeneratedMessage
1121       implements RawMessageOrBuilder {
1122     // Use RawMessage.newBuilder() to construct.
1123     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1124       super(builder);
1125       this.unknownFields = builder.getUnknownFields();
1126     }
1127     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1128
1129     private static final RawMessage defaultInstance;
1130     public static RawMessage getDefaultInstance() {
1131       return defaultInstance;
1132     }
1133
1134     public RawMessage getDefaultInstanceForType() {
1135       return defaultInstance;
1136     }
1137
1138     private final com.google.protobuf.UnknownFieldSet unknownFields;
1139     @java.lang.Override
1140     public final com.google.protobuf.UnknownFieldSet
1141         getUnknownFields() {
1142       return this.unknownFields;
1143     }
1144     private RawMessage(
1145         com.google.protobuf.CodedInputStream input,
1146         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1147         throws com.google.protobuf.InvalidProtocolBufferException {
1148       initFields();
1149       int mutable_bitField0_ = 0;
1150       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1151           com.google.protobuf.UnknownFieldSet.newBuilder();
1152       try {
1153         boolean done = false;
1154         while (!done) {
1155           int tag = input.readTag();
1156           switch (tag) {
1157             case 0:
1158               done = true;
1159               break;
1160             default: {
1161               if (!parseUnknownField(input, unknownFields,
1162                                      extensionRegistry, tag)) {
1163                 done = true;
1164               }
1165               break;
1166             }
1167             case 8: {
1168               bitField0_ |= 0x00000001;
1169               bus_ = input.readInt32();
1170               break;
1171             }
1172             case 16: {
1173               bitField0_ |= 0x00000002;
1174               messageId_ = input.readUInt32();
1175               break;
1176             }
1177             case 26: {
1178               bitField0_ |= 0x00000004;
1179               data_ = input.readBytes();
1180               break;
1181             }
1182           }
1183         }
1184       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1185         throw e.setUnfinishedMessage(this);
1186       } catch (java.io.IOException e) {
1187         throw new com.google.protobuf.InvalidProtocolBufferException(
1188             e.getMessage()).setUnfinishedMessage(this);
1189       } finally {
1190         this.unknownFields = unknownFields.build();
1191         makeExtensionsImmutable();
1192       }
1193     }
1194     public static final com.google.protobuf.Descriptors.Descriptor
1195         getDescriptor() {
1196       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1197     }
1198
1199     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1200         internalGetFieldAccessorTable() {
1201       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1202           .ensureFieldAccessorsInitialized(
1203               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1204     }
1205
1206     public static com.google.protobuf.Parser<RawMessage> PARSER =
1207         new com.google.protobuf.AbstractParser<RawMessage>() {
1208       public RawMessage parsePartialFrom(
1209           com.google.protobuf.CodedInputStream input,
1210           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1211           throws com.google.protobuf.InvalidProtocolBufferException {
1212         return new RawMessage(input, extensionRegistry);
1213       }
1214     };
1215
1216     @java.lang.Override
1217     public com.google.protobuf.Parser<RawMessage> getParserForType() {
1218       return PARSER;
1219     }
1220
1221     private int bitField0_;
1222     // optional int32 bus = 1;
1223     public static final int BUS_FIELD_NUMBER = 1;
1224     private int bus_;
1225     /**
1226      * <code>optional int32 bus = 1;</code>
1227      */
1228     public boolean hasBus() {
1229       return ((bitField0_ & 0x00000001) == 0x00000001);
1230     }
1231     /**
1232      * <code>optional int32 bus = 1;</code>
1233      */
1234     public int getBus() {
1235       return bus_;
1236     }
1237
1238     // optional uint32 message_id = 2;
1239     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1240     private int messageId_;
1241     /**
1242      * <code>optional uint32 message_id = 2;</code>
1243      */
1244     public boolean hasMessageId() {
1245       return ((bitField0_ & 0x00000002) == 0x00000002);
1246     }
1247     /**
1248      * <code>optional uint32 message_id = 2;</code>
1249      */
1250     public int getMessageId() {
1251       return messageId_;
1252     }
1253
1254     // optional bytes data = 3;
1255     public static final int DATA_FIELD_NUMBER = 3;
1256     private com.google.protobuf.ByteString data_;
1257     /**
1258      * <code>optional bytes data = 3;</code>
1259      */
1260     public boolean hasData() {
1261       return ((bitField0_ & 0x00000004) == 0x00000004);
1262     }
1263     /**
1264      * <code>optional bytes data = 3;</code>
1265      */
1266     public com.google.protobuf.ByteString getData() {
1267       return data_;
1268     }
1269
1270     private void initFields() {
1271       bus_ = 0;
1272       messageId_ = 0;
1273       data_ = com.google.protobuf.ByteString.EMPTY;
1274     }
1275     private byte memoizedIsInitialized = -1;
1276     public final boolean isInitialized() {
1277       byte isInitialized = memoizedIsInitialized;
1278       if (isInitialized != -1) return isInitialized == 1;
1279
1280       memoizedIsInitialized = 1;
1281       return true;
1282     }
1283
1284     public void writeTo(com.google.protobuf.CodedOutputStream output)
1285                         throws java.io.IOException {
1286       getSerializedSize();
1287       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1288         output.writeInt32(1, bus_);
1289       }
1290       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1291         output.writeUInt32(2, messageId_);
1292       }
1293       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1294         output.writeBytes(3, data_);
1295       }
1296       getUnknownFields().writeTo(output);
1297     }
1298
1299     private int memoizedSerializedSize = -1;
1300     public int getSerializedSize() {
1301       int size = memoizedSerializedSize;
1302       if (size != -1) return size;
1303
1304       size = 0;
1305       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1306         size += com.google.protobuf.CodedOutputStream
1307           .computeInt32Size(1, bus_);
1308       }
1309       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1310         size += com.google.protobuf.CodedOutputStream
1311           .computeUInt32Size(2, messageId_);
1312       }
1313       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1314         size += com.google.protobuf.CodedOutputStream
1315           .computeBytesSize(3, data_);
1316       }
1317       size += getUnknownFields().getSerializedSize();
1318       memoizedSerializedSize = size;
1319       return size;
1320     }
1321
1322     private static final long serialVersionUID = 0L;
1323     @java.lang.Override
1324     protected java.lang.Object writeReplace()
1325         throws java.io.ObjectStreamException {
1326       return super.writeReplace();
1327     }
1328
1329     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1330         com.google.protobuf.ByteString data)
1331         throws com.google.protobuf.InvalidProtocolBufferException {
1332       return PARSER.parseFrom(data);
1333     }
1334     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1335         com.google.protobuf.ByteString data,
1336         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1337         throws com.google.protobuf.InvalidProtocolBufferException {
1338       return PARSER.parseFrom(data, extensionRegistry);
1339     }
1340     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
1341         throws com.google.protobuf.InvalidProtocolBufferException {
1342       return PARSER.parseFrom(data);
1343     }
1344     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1345         byte[] data,
1346         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1347         throws com.google.protobuf.InvalidProtocolBufferException {
1348       return PARSER.parseFrom(data, extensionRegistry);
1349     }
1350     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
1351         throws java.io.IOException {
1352       return PARSER.parseFrom(input);
1353     }
1354     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1355         java.io.InputStream input,
1356         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1357         throws java.io.IOException {
1358       return PARSER.parseFrom(input, extensionRegistry);
1359     }
1360     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
1361         throws java.io.IOException {
1362       return PARSER.parseDelimitedFrom(input);
1363     }
1364     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
1365         java.io.InputStream input,
1366         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1367         throws java.io.IOException {
1368       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1369     }
1370     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1371         com.google.protobuf.CodedInputStream input)
1372         throws java.io.IOException {
1373       return PARSER.parseFrom(input);
1374     }
1375     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1376         com.google.protobuf.CodedInputStream input,
1377         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1378         throws java.io.IOException {
1379       return PARSER.parseFrom(input, extensionRegistry);
1380     }
1381
1382     public static Builder newBuilder() { return Builder.create(); }
1383     public Builder newBuilderForType() { return newBuilder(); }
1384     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
1385       return newBuilder().mergeFrom(prototype);
1386     }
1387     public Builder toBuilder() { return newBuilder(this); }
1388
1389     @java.lang.Override
1390     protected Builder newBuilderForType(
1391         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1392       Builder builder = new Builder(parent);
1393       return builder;
1394     }
1395     /**
1396      * Protobuf type {@code openxc.RawMessage}
1397      */
1398     public static final class Builder extends
1399         com.google.protobuf.GeneratedMessage.Builder<Builder>
1400        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
1401       public static final com.google.protobuf.Descriptors.Descriptor
1402           getDescriptor() {
1403         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1404       }
1405
1406       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1407           internalGetFieldAccessorTable() {
1408         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1409             .ensureFieldAccessorsInitialized(
1410                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1411       }
1412
1413       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
1414       private Builder() {
1415         maybeForceBuilderInitialization();
1416       }
1417
1418       private Builder(
1419           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1420         super(parent);
1421         maybeForceBuilderInitialization();
1422       }
1423       private void maybeForceBuilderInitialization() {
1424         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1425         }
1426       }
1427       private static Builder create() {
1428         return new Builder();
1429       }
1430
1431       public Builder clear() {
1432         super.clear();
1433         bus_ = 0;
1434         bitField0_ = (bitField0_ & ~0x00000001);
1435         messageId_ = 0;
1436         bitField0_ = (bitField0_ & ~0x00000002);
1437         data_ = com.google.protobuf.ByteString.EMPTY;
1438         bitField0_ = (bitField0_ & ~0x00000004);
1439         return this;
1440       }
1441
1442       public Builder clone() {
1443         return create().mergeFrom(buildPartial());
1444       }
1445
1446       public com.google.protobuf.Descriptors.Descriptor
1447           getDescriptorForType() {
1448         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1449       }
1450
1451       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
1452         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1453       }
1454
1455       public com.openxc.BinaryMessages.RawMessage build() {
1456         com.openxc.BinaryMessages.RawMessage result = buildPartial();
1457         if (!result.isInitialized()) {
1458           throw newUninitializedMessageException(result);
1459         }
1460         return result;
1461       }
1462
1463       public com.openxc.BinaryMessages.RawMessage buildPartial() {
1464         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
1465         int from_bitField0_ = bitField0_;
1466         int to_bitField0_ = 0;
1467         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1468           to_bitField0_ |= 0x00000001;
1469         }
1470         result.bus_ = bus_;
1471         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1472           to_bitField0_ |= 0x00000002;
1473         }
1474         result.messageId_ = messageId_;
1475         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1476           to_bitField0_ |= 0x00000004;
1477         }
1478         result.data_ = data_;
1479         result.bitField0_ = to_bitField0_;
1480         onBuilt();
1481         return result;
1482       }
1483
1484       public Builder mergeFrom(com.google.protobuf.Message other) {
1485         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
1486           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
1487         } else {
1488           super.mergeFrom(other);
1489           return this;
1490         }
1491       }
1492
1493       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
1494         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
1495         if (other.hasBus()) {
1496           setBus(other.getBus());
1497         }
1498         if (other.hasMessageId()) {
1499           setMessageId(other.getMessageId());
1500         }
1501         if (other.hasData()) {
1502           setData(other.getData());
1503         }
1504         this.mergeUnknownFields(other.getUnknownFields());
1505         return this;
1506       }
1507
1508       public final boolean isInitialized() {
1509         return true;
1510       }
1511
1512       public Builder mergeFrom(
1513           com.google.protobuf.CodedInputStream input,
1514           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1515           throws java.io.IOException {
1516         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
1517         try {
1518           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1519         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1520           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
1521           throw e;
1522         } finally {
1523           if (parsedMessage != null) {
1524             mergeFrom(parsedMessage);
1525           }
1526         }
1527         return this;
1528       }
1529       private int bitField0_;
1530
1531       // optional int32 bus = 1;
1532       private int bus_ ;
1533       /**
1534        * <code>optional int32 bus = 1;</code>
1535        */
1536       public boolean hasBus() {
1537         return ((bitField0_ & 0x00000001) == 0x00000001);
1538       }
1539       /**
1540        * <code>optional int32 bus = 1;</code>
1541        */
1542       public int getBus() {
1543         return bus_;
1544       }
1545       /**
1546        * <code>optional int32 bus = 1;</code>
1547        */
1548       public Builder setBus(int value) {
1549         bitField0_ |= 0x00000001;
1550         bus_ = value;
1551         onChanged();
1552         return this;
1553       }
1554       /**
1555        * <code>optional int32 bus = 1;</code>
1556        */
1557       public Builder clearBus() {
1558         bitField0_ = (bitField0_ & ~0x00000001);
1559         bus_ = 0;
1560         onChanged();
1561         return this;
1562       }
1563
1564       // optional uint32 message_id = 2;
1565       private int messageId_ ;
1566       /**
1567        * <code>optional uint32 message_id = 2;</code>
1568        */
1569       public boolean hasMessageId() {
1570         return ((bitField0_ & 0x00000002) == 0x00000002);
1571       }
1572       /**
1573        * <code>optional uint32 message_id = 2;</code>
1574        */
1575       public int getMessageId() {
1576         return messageId_;
1577       }
1578       /**
1579        * <code>optional uint32 message_id = 2;</code>
1580        */
1581       public Builder setMessageId(int value) {
1582         bitField0_ |= 0x00000002;
1583         messageId_ = value;
1584         onChanged();
1585         return this;
1586       }
1587       /**
1588        * <code>optional uint32 message_id = 2;</code>
1589        */
1590       public Builder clearMessageId() {
1591         bitField0_ = (bitField0_ & ~0x00000002);
1592         messageId_ = 0;
1593         onChanged();
1594         return this;
1595       }
1596
1597       // optional bytes data = 3;
1598       private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
1599       /**
1600        * <code>optional bytes data = 3;</code>
1601        */
1602       public boolean hasData() {
1603         return ((bitField0_ & 0x00000004) == 0x00000004);
1604       }
1605       /**
1606        * <code>optional bytes data = 3;</code>
1607        */
1608       public com.google.protobuf.ByteString getData() {
1609         return data_;
1610       }
1611       /**
1612        * <code>optional bytes data = 3;</code>
1613        */
1614       public Builder setData(com.google.protobuf.ByteString value) {
1615         if (value == null) {
1616     throw new NullPointerException();
1617   }
1618   bitField0_ |= 0x00000004;
1619         data_ = value;
1620         onChanged();
1621         return this;
1622       }
1623       /**
1624        * <code>optional bytes data = 3;</code>
1625        */
1626       public Builder clearData() {
1627         bitField0_ = (bitField0_ & ~0x00000004);
1628         data_ = getDefaultInstance().getData();
1629         onChanged();
1630         return this;
1631       }
1632
1633       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
1634     }
1635
1636     static {
1637       defaultInstance = new RawMessage(true);
1638       defaultInstance.initFields();
1639     }
1640
1641     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
1642   }
1643
1644   public interface DiagnosticMessageOrBuilder
1645       extends com.google.protobuf.MessageOrBuilder {
1646
1647     // optional int32 bus = 1;
1648     /**
1649      * <code>optional int32 bus = 1;</code>
1650      */
1651     boolean hasBus();
1652     /**
1653      * <code>optional int32 bus = 1;</code>
1654      */
1655     int getBus();
1656
1657     // optional uint32 message_id = 2;
1658     /**
1659      * <code>optional uint32 message_id = 2;</code>
1660      */
1661     boolean hasMessageId();
1662     /**
1663      * <code>optional uint32 message_id = 2;</code>
1664      */
1665     int getMessageId();
1666
1667     // optional uint32 mode = 3;
1668     /**
1669      * <code>optional uint32 mode = 3;</code>
1670      */
1671     boolean hasMode();
1672     /**
1673      * <code>optional uint32 mode = 3;</code>
1674      */
1675     int getMode();
1676
1677     // optional uint32 pid = 4;
1678     /**
1679      * <code>optional uint32 pid = 4;</code>
1680      */
1681     boolean hasPid();
1682     /**
1683      * <code>optional uint32 pid = 4;</code>
1684      */
1685     int getPid();
1686
1687     // optional bool success = 5;
1688     /**
1689      * <code>optional bool success = 5;</code>
1690      */
1691     boolean hasSuccess();
1692     /**
1693      * <code>optional bool success = 5;</code>
1694      */
1695     boolean getSuccess();
1696
1697     // optional uint32 negative_response_code = 6;
1698     /**
1699      * <code>optional uint32 negative_response_code = 6;</code>
1700      */
1701     boolean hasNegativeResponseCode();
1702     /**
1703      * <code>optional uint32 negative_response_code = 6;</code>
1704      */
1705     int getNegativeResponseCode();
1706
1707     // optional bytes payload = 7;
1708     /**
1709      * <code>optional bytes payload = 7;</code>
1710      *
1711      * <pre>
1712      * TODO we are capping this at 8 bytes for now - need to change when we
1713      * support multi-frame responses
1714      * </pre>
1715      */
1716     boolean hasPayload();
1717     /**
1718      * <code>optional bytes payload = 7;</code>
1719      *
1720      * <pre>
1721      * TODO we are capping this at 8 bytes for now - need to change when we
1722      * support multi-frame responses
1723      * </pre>
1724      */
1725     com.google.protobuf.ByteString getPayload();
1726   }
1727   /**
1728    * Protobuf type {@code openxc.DiagnosticMessage}
1729    */
1730   public static final class DiagnosticMessage extends
1731       com.google.protobuf.GeneratedMessage
1732       implements DiagnosticMessageOrBuilder {
1733     // Use DiagnosticMessage.newBuilder() to construct.
1734     private DiagnosticMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1735       super(builder);
1736       this.unknownFields = builder.getUnknownFields();
1737     }
1738     private DiagnosticMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1739
1740     private static final DiagnosticMessage defaultInstance;
1741     public static DiagnosticMessage getDefaultInstance() {
1742       return defaultInstance;
1743     }
1744
1745     public DiagnosticMessage getDefaultInstanceForType() {
1746       return defaultInstance;
1747     }
1748
1749     private final com.google.protobuf.UnknownFieldSet unknownFields;
1750     @java.lang.Override
1751     public final com.google.protobuf.UnknownFieldSet
1752         getUnknownFields() {
1753       return this.unknownFields;
1754     }
1755     private DiagnosticMessage(
1756         com.google.protobuf.CodedInputStream input,
1757         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1758         throws com.google.protobuf.InvalidProtocolBufferException {
1759       initFields();
1760       int mutable_bitField0_ = 0;
1761       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1762           com.google.protobuf.UnknownFieldSet.newBuilder();
1763       try {
1764         boolean done = false;
1765         while (!done) {
1766           int tag = input.readTag();
1767           switch (tag) {
1768             case 0:
1769               done = true;
1770               break;
1771             default: {
1772               if (!parseUnknownField(input, unknownFields,
1773                                      extensionRegistry, tag)) {
1774                 done = true;
1775               }
1776               break;
1777             }
1778             case 8: {
1779               bitField0_ |= 0x00000001;
1780               bus_ = input.readInt32();
1781               break;
1782             }
1783             case 16: {
1784               bitField0_ |= 0x00000002;
1785               messageId_ = input.readUInt32();
1786               break;
1787             }
1788             case 24: {
1789               bitField0_ |= 0x00000004;
1790               mode_ = input.readUInt32();
1791               break;
1792             }
1793             case 32: {
1794               bitField0_ |= 0x00000008;
1795               pid_ = input.readUInt32();
1796               break;
1797             }
1798             case 40: {
1799               bitField0_ |= 0x00000010;
1800               success_ = input.readBool();
1801               break;
1802             }
1803             case 48: {
1804               bitField0_ |= 0x00000020;
1805               negativeResponseCode_ = input.readUInt32();
1806               break;
1807             }
1808             case 58: {
1809               bitField0_ |= 0x00000040;
1810               payload_ = input.readBytes();
1811               break;
1812             }
1813           }
1814         }
1815       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1816         throw e.setUnfinishedMessage(this);
1817       } catch (java.io.IOException e) {
1818         throw new com.google.protobuf.InvalidProtocolBufferException(
1819             e.getMessage()).setUnfinishedMessage(this);
1820       } finally {
1821         this.unknownFields = unknownFields.build();
1822         makeExtensionsImmutable();
1823       }
1824     }
1825     public static final com.google.protobuf.Descriptors.Descriptor
1826         getDescriptor() {
1827       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_descriptor;
1828     }
1829
1830     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1831         internalGetFieldAccessorTable() {
1832       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_fieldAccessorTable
1833           .ensureFieldAccessorsInitialized(
1834               com.openxc.BinaryMessages.DiagnosticMessage.class, com.openxc.BinaryMessages.DiagnosticMessage.Builder.class);
1835     }
1836
1837     public static com.google.protobuf.Parser<DiagnosticMessage> PARSER =
1838         new com.google.protobuf.AbstractParser<DiagnosticMessage>() {
1839       public DiagnosticMessage parsePartialFrom(
1840           com.google.protobuf.CodedInputStream input,
1841           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1842           throws com.google.protobuf.InvalidProtocolBufferException {
1843         return new DiagnosticMessage(input, extensionRegistry);
1844       }
1845     };
1846
1847     @java.lang.Override
1848     public com.google.protobuf.Parser<DiagnosticMessage> getParserForType() {
1849       return PARSER;
1850     }
1851
1852     private int bitField0_;
1853     // optional int32 bus = 1;
1854     public static final int BUS_FIELD_NUMBER = 1;
1855     private int bus_;
1856     /**
1857      * <code>optional int32 bus = 1;</code>
1858      */
1859     public boolean hasBus() {
1860       return ((bitField0_ & 0x00000001) == 0x00000001);
1861     }
1862     /**
1863      * <code>optional int32 bus = 1;</code>
1864      */
1865     public int getBus() {
1866       return bus_;
1867     }
1868
1869     // optional uint32 message_id = 2;
1870     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1871     private int messageId_;
1872     /**
1873      * <code>optional uint32 message_id = 2;</code>
1874      */
1875     public boolean hasMessageId() {
1876       return ((bitField0_ & 0x00000002) == 0x00000002);
1877     }
1878     /**
1879      * <code>optional uint32 message_id = 2;</code>
1880      */
1881     public int getMessageId() {
1882       return messageId_;
1883     }
1884
1885     // optional uint32 mode = 3;
1886     public static final int MODE_FIELD_NUMBER = 3;
1887     private int mode_;
1888     /**
1889      * <code>optional uint32 mode = 3;</code>
1890      */
1891     public boolean hasMode() {
1892       return ((bitField0_ & 0x00000004) == 0x00000004);
1893     }
1894     /**
1895      * <code>optional uint32 mode = 3;</code>
1896      */
1897     public int getMode() {
1898       return mode_;
1899     }
1900
1901     // optional uint32 pid = 4;
1902     public static final int PID_FIELD_NUMBER = 4;
1903     private int pid_;
1904     /**
1905      * <code>optional uint32 pid = 4;</code>
1906      */
1907     public boolean hasPid() {
1908       return ((bitField0_ & 0x00000008) == 0x00000008);
1909     }
1910     /**
1911      * <code>optional uint32 pid = 4;</code>
1912      */
1913     public int getPid() {
1914       return pid_;
1915     }
1916
1917     // optional bool success = 5;
1918     public static final int SUCCESS_FIELD_NUMBER = 5;
1919     private boolean success_;
1920     /**
1921      * <code>optional bool success = 5;</code>
1922      */
1923     public boolean hasSuccess() {
1924       return ((bitField0_ & 0x00000010) == 0x00000010);
1925     }
1926     /**
1927      * <code>optional bool success = 5;</code>
1928      */
1929     public boolean getSuccess() {
1930       return success_;
1931     }
1932
1933     // optional uint32 negative_response_code = 6;
1934     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
1935     private int negativeResponseCode_;
1936     /**
1937      * <code>optional uint32 negative_response_code = 6;</code>
1938      */
1939     public boolean hasNegativeResponseCode() {
1940       return ((bitField0_ & 0x00000020) == 0x00000020);
1941     }
1942     /**
1943      * <code>optional uint32 negative_response_code = 6;</code>
1944      */
1945     public int getNegativeResponseCode() {
1946       return negativeResponseCode_;
1947     }
1948
1949     // optional bytes payload = 7;
1950     public static final int PAYLOAD_FIELD_NUMBER = 7;
1951     private com.google.protobuf.ByteString payload_;
1952     /**
1953      * <code>optional bytes payload = 7;</code>
1954      *
1955      * <pre>
1956      * TODO we are capping this at 8 bytes for now - need to change when we
1957      * support multi-frame responses
1958      * </pre>
1959      */
1960     public boolean hasPayload() {
1961       return ((bitField0_ & 0x00000040) == 0x00000040);
1962     }
1963     /**
1964      * <code>optional bytes payload = 7;</code>
1965      *
1966      * <pre>
1967      * TODO we are capping this at 8 bytes for now - need to change when we
1968      * support multi-frame responses
1969      * </pre>
1970      */
1971     public com.google.protobuf.ByteString getPayload() {
1972       return payload_;
1973     }
1974
1975     private void initFields() {
1976       bus_ = 0;
1977       messageId_ = 0;
1978       mode_ = 0;
1979       pid_ = 0;
1980       success_ = false;
1981       negativeResponseCode_ = 0;
1982       payload_ = com.google.protobuf.ByteString.EMPTY;
1983     }
1984     private byte memoizedIsInitialized = -1;
1985     public final boolean isInitialized() {
1986       byte isInitialized = memoizedIsInitialized;
1987       if (isInitialized != -1) return isInitialized == 1;
1988
1989       memoizedIsInitialized = 1;
1990       return true;
1991     }
1992
1993     public void writeTo(com.google.protobuf.CodedOutputStream output)
1994                         throws java.io.IOException {
1995       getSerializedSize();
1996       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1997         output.writeInt32(1, bus_);
1998       }
1999       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2000         output.writeUInt32(2, messageId_);
2001       }
2002       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2003         output.writeUInt32(3, mode_);
2004       }
2005       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2006         output.writeUInt32(4, pid_);
2007       }
2008       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2009         output.writeBool(5, success_);
2010       }
2011       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2012         output.writeUInt32(6, negativeResponseCode_);
2013       }
2014       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2015         output.writeBytes(7, payload_);
2016       }
2017       getUnknownFields().writeTo(output);
2018     }
2019
2020     private int memoizedSerializedSize = -1;
2021     public int getSerializedSize() {
2022       int size = memoizedSerializedSize;
2023       if (size != -1) return size;
2024
2025       size = 0;
2026       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2027         size += com.google.protobuf.CodedOutputStream
2028           .computeInt32Size(1, bus_);
2029       }
2030       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2031         size += com.google.protobuf.CodedOutputStream
2032           .computeUInt32Size(2, messageId_);
2033       }
2034       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2035         size += com.google.protobuf.CodedOutputStream
2036           .computeUInt32Size(3, mode_);
2037       }
2038       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2039         size += com.google.protobuf.CodedOutputStream
2040           .computeUInt32Size(4, pid_);
2041       }
2042       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2043         size += com.google.protobuf.CodedOutputStream
2044           .computeBoolSize(5, success_);
2045       }
2046       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2047         size += com.google.protobuf.CodedOutputStream
2048           .computeUInt32Size(6, negativeResponseCode_);
2049       }
2050       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2051         size += com.google.protobuf.CodedOutputStream
2052           .computeBytesSize(7, payload_);
2053       }
2054       size += getUnknownFields().getSerializedSize();
2055       memoizedSerializedSize = size;
2056       return size;
2057     }
2058
2059     private static final long serialVersionUID = 0L;
2060     @java.lang.Override
2061     protected java.lang.Object writeReplace()
2062         throws java.io.ObjectStreamException {
2063       return super.writeReplace();
2064     }
2065
2066     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2067         com.google.protobuf.ByteString data)
2068         throws com.google.protobuf.InvalidProtocolBufferException {
2069       return PARSER.parseFrom(data);
2070     }
2071     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2072         com.google.protobuf.ByteString data,
2073         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2074         throws com.google.protobuf.InvalidProtocolBufferException {
2075       return PARSER.parseFrom(data, extensionRegistry);
2076     }
2077     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(byte[] data)
2078         throws com.google.protobuf.InvalidProtocolBufferException {
2079       return PARSER.parseFrom(data);
2080     }
2081     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2082         byte[] data,
2083         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2084         throws com.google.protobuf.InvalidProtocolBufferException {
2085       return PARSER.parseFrom(data, extensionRegistry);
2086     }
2087     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(java.io.InputStream input)
2088         throws java.io.IOException {
2089       return PARSER.parseFrom(input);
2090     }
2091     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2092         java.io.InputStream input,
2093         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2094         throws java.io.IOException {
2095       return PARSER.parseFrom(input, extensionRegistry);
2096     }
2097     public static com.openxc.BinaryMessages.DiagnosticMessage parseDelimitedFrom(java.io.InputStream input)
2098         throws java.io.IOException {
2099       return PARSER.parseDelimitedFrom(input);
2100     }
2101     public static com.openxc.BinaryMessages.DiagnosticMessage parseDelimitedFrom(
2102         java.io.InputStream input,
2103         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2104         throws java.io.IOException {
2105       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2106     }
2107     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2108         com.google.protobuf.CodedInputStream input)
2109         throws java.io.IOException {
2110       return PARSER.parseFrom(input);
2111     }
2112     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2113         com.google.protobuf.CodedInputStream input,
2114         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2115         throws java.io.IOException {
2116       return PARSER.parseFrom(input, extensionRegistry);
2117     }
2118
2119     public static Builder newBuilder() { return Builder.create(); }
2120     public Builder newBuilderForType() { return newBuilder(); }
2121     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticMessage prototype) {
2122       return newBuilder().mergeFrom(prototype);
2123     }
2124     public Builder toBuilder() { return newBuilder(this); }
2125
2126     @java.lang.Override
2127     protected Builder newBuilderForType(
2128         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2129       Builder builder = new Builder(parent);
2130       return builder;
2131     }
2132     /**
2133      * Protobuf type {@code openxc.DiagnosticMessage}
2134      */
2135     public static final class Builder extends
2136         com.google.protobuf.GeneratedMessage.Builder<Builder>
2137        implements com.openxc.BinaryMessages.DiagnosticMessageOrBuilder {
2138       public static final com.google.protobuf.Descriptors.Descriptor
2139           getDescriptor() {
2140         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_descriptor;
2141       }
2142
2143       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2144           internalGetFieldAccessorTable() {
2145         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_fieldAccessorTable
2146             .ensureFieldAccessorsInitialized(
2147                 com.openxc.BinaryMessages.DiagnosticMessage.class, com.openxc.BinaryMessages.DiagnosticMessage.Builder.class);
2148       }
2149
2150       // Construct using com.openxc.BinaryMessages.DiagnosticMessage.newBuilder()
2151       private Builder() {
2152         maybeForceBuilderInitialization();
2153       }
2154
2155       private Builder(
2156           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2157         super(parent);
2158         maybeForceBuilderInitialization();
2159       }
2160       private void maybeForceBuilderInitialization() {
2161         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2162         }
2163       }
2164       private static Builder create() {
2165         return new Builder();
2166       }
2167
2168       public Builder clear() {
2169         super.clear();
2170         bus_ = 0;
2171         bitField0_ = (bitField0_ & ~0x00000001);
2172         messageId_ = 0;
2173         bitField0_ = (bitField0_ & ~0x00000002);
2174         mode_ = 0;
2175         bitField0_ = (bitField0_ & ~0x00000004);
2176         pid_ = 0;
2177         bitField0_ = (bitField0_ & ~0x00000008);
2178         success_ = false;
2179         bitField0_ = (bitField0_ & ~0x00000010);
2180         negativeResponseCode_ = 0;
2181         bitField0_ = (bitField0_ & ~0x00000020);
2182         payload_ = com.google.protobuf.ByteString.EMPTY;
2183         bitField0_ = (bitField0_ & ~0x00000040);
2184         return this;
2185       }
2186
2187       public Builder clone() {
2188         return create().mergeFrom(buildPartial());
2189       }
2190
2191       public com.google.protobuf.Descriptors.Descriptor
2192           getDescriptorForType() {
2193         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_descriptor;
2194       }
2195
2196       public com.openxc.BinaryMessages.DiagnosticMessage getDefaultInstanceForType() {
2197         return com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance();
2198       }
2199
2200       public com.openxc.BinaryMessages.DiagnosticMessage build() {
2201         com.openxc.BinaryMessages.DiagnosticMessage result = buildPartial();
2202         if (!result.isInitialized()) {
2203           throw newUninitializedMessageException(result);
2204         }
2205         return result;
2206       }
2207
2208       public com.openxc.BinaryMessages.DiagnosticMessage buildPartial() {
2209         com.openxc.BinaryMessages.DiagnosticMessage result = new com.openxc.BinaryMessages.DiagnosticMessage(this);
2210         int from_bitField0_ = bitField0_;
2211         int to_bitField0_ = 0;
2212         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2213           to_bitField0_ |= 0x00000001;
2214         }
2215         result.bus_ = bus_;
2216         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2217           to_bitField0_ |= 0x00000002;
2218         }
2219         result.messageId_ = messageId_;
2220         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2221           to_bitField0_ |= 0x00000004;
2222         }
2223         result.mode_ = mode_;
2224         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2225           to_bitField0_ |= 0x00000008;
2226         }
2227         result.pid_ = pid_;
2228         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2229           to_bitField0_ |= 0x00000010;
2230         }
2231         result.success_ = success_;
2232         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2233           to_bitField0_ |= 0x00000020;
2234         }
2235         result.negativeResponseCode_ = negativeResponseCode_;
2236         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2237           to_bitField0_ |= 0x00000040;
2238         }
2239         result.payload_ = payload_;
2240         result.bitField0_ = to_bitField0_;
2241         onBuilt();
2242         return result;
2243       }
2244
2245       public Builder mergeFrom(com.google.protobuf.Message other) {
2246         if (other instanceof com.openxc.BinaryMessages.DiagnosticMessage) {
2247           return mergeFrom((com.openxc.BinaryMessages.DiagnosticMessage)other);
2248         } else {
2249           super.mergeFrom(other);
2250           return this;
2251         }
2252       }
2253
2254       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticMessage other) {
2255         if (other == com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance()) return this;
2256         if (other.hasBus()) {
2257           setBus(other.getBus());
2258         }
2259         if (other.hasMessageId()) {
2260           setMessageId(other.getMessageId());
2261         }
2262         if (other.hasMode()) {
2263           setMode(other.getMode());
2264         }
2265         if (other.hasPid()) {
2266           setPid(other.getPid());
2267         }
2268         if (other.hasSuccess()) {
2269           setSuccess(other.getSuccess());
2270         }
2271         if (other.hasNegativeResponseCode()) {
2272           setNegativeResponseCode(other.getNegativeResponseCode());
2273         }
2274         if (other.hasPayload()) {
2275           setPayload(other.getPayload());
2276         }
2277         this.mergeUnknownFields(other.getUnknownFields());
2278         return this;
2279       }
2280
2281       public final boolean isInitialized() {
2282         return true;
2283       }
2284
2285       public Builder mergeFrom(
2286           com.google.protobuf.CodedInputStream input,
2287           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2288           throws java.io.IOException {
2289         com.openxc.BinaryMessages.DiagnosticMessage parsedMessage = null;
2290         try {
2291           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2292         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2293           parsedMessage = (com.openxc.BinaryMessages.DiagnosticMessage) e.getUnfinishedMessage();
2294           throw e;
2295         } finally {
2296           if (parsedMessage != null) {
2297             mergeFrom(parsedMessage);
2298           }
2299         }
2300         return this;
2301       }
2302       private int bitField0_;
2303
2304       // optional int32 bus = 1;
2305       private int bus_ ;
2306       /**
2307        * <code>optional int32 bus = 1;</code>
2308        */
2309       public boolean hasBus() {
2310         return ((bitField0_ & 0x00000001) == 0x00000001);
2311       }
2312       /**
2313        * <code>optional int32 bus = 1;</code>
2314        */
2315       public int getBus() {
2316         return bus_;
2317       }
2318       /**
2319        * <code>optional int32 bus = 1;</code>
2320        */
2321       public Builder setBus(int value) {
2322         bitField0_ |= 0x00000001;
2323         bus_ = value;
2324         onChanged();
2325         return this;
2326       }
2327       /**
2328        * <code>optional int32 bus = 1;</code>
2329        */
2330       public Builder clearBus() {
2331         bitField0_ = (bitField0_ & ~0x00000001);
2332         bus_ = 0;
2333         onChanged();
2334         return this;
2335       }
2336
2337       // optional uint32 message_id = 2;
2338       private int messageId_ ;
2339       /**
2340        * <code>optional uint32 message_id = 2;</code>
2341        */
2342       public boolean hasMessageId() {
2343         return ((bitField0_ & 0x00000002) == 0x00000002);
2344       }
2345       /**
2346        * <code>optional uint32 message_id = 2;</code>
2347        */
2348       public int getMessageId() {
2349         return messageId_;
2350       }
2351       /**
2352        * <code>optional uint32 message_id = 2;</code>
2353        */
2354       public Builder setMessageId(int value) {
2355         bitField0_ |= 0x00000002;
2356         messageId_ = value;
2357         onChanged();
2358         return this;
2359       }
2360       /**
2361        * <code>optional uint32 message_id = 2;</code>
2362        */
2363       public Builder clearMessageId() {
2364         bitField0_ = (bitField0_ & ~0x00000002);
2365         messageId_ = 0;
2366         onChanged();
2367         return this;
2368       }
2369
2370       // optional uint32 mode = 3;
2371       private int mode_ ;
2372       /**
2373        * <code>optional uint32 mode = 3;</code>
2374        */
2375       public boolean hasMode() {
2376         return ((bitField0_ & 0x00000004) == 0x00000004);
2377       }
2378       /**
2379        * <code>optional uint32 mode = 3;</code>
2380        */
2381       public int getMode() {
2382         return mode_;
2383       }
2384       /**
2385        * <code>optional uint32 mode = 3;</code>
2386        */
2387       public Builder setMode(int value) {
2388         bitField0_ |= 0x00000004;
2389         mode_ = value;
2390         onChanged();
2391         return this;
2392       }
2393       /**
2394        * <code>optional uint32 mode = 3;</code>
2395        */
2396       public Builder clearMode() {
2397         bitField0_ = (bitField0_ & ~0x00000004);
2398         mode_ = 0;
2399         onChanged();
2400         return this;
2401       }
2402
2403       // optional uint32 pid = 4;
2404       private int pid_ ;
2405       /**
2406        * <code>optional uint32 pid = 4;</code>
2407        */
2408       public boolean hasPid() {
2409         return ((bitField0_ & 0x00000008) == 0x00000008);
2410       }
2411       /**
2412        * <code>optional uint32 pid = 4;</code>
2413        */
2414       public int getPid() {
2415         return pid_;
2416       }
2417       /**
2418        * <code>optional uint32 pid = 4;</code>
2419        */
2420       public Builder setPid(int value) {
2421         bitField0_ |= 0x00000008;
2422         pid_ = value;
2423         onChanged();
2424         return this;
2425       }
2426       /**
2427        * <code>optional uint32 pid = 4;</code>
2428        */
2429       public Builder clearPid() {
2430         bitField0_ = (bitField0_ & ~0x00000008);
2431         pid_ = 0;
2432         onChanged();
2433         return this;
2434       }
2435
2436       // optional bool success = 5;
2437       private boolean success_ ;
2438       /**
2439        * <code>optional bool success = 5;</code>
2440        */
2441       public boolean hasSuccess() {
2442         return ((bitField0_ & 0x00000010) == 0x00000010);
2443       }
2444       /**
2445        * <code>optional bool success = 5;</code>
2446        */
2447       public boolean getSuccess() {
2448         return success_;
2449       }
2450       /**
2451        * <code>optional bool success = 5;</code>
2452        */
2453       public Builder setSuccess(boolean value) {
2454         bitField0_ |= 0x00000010;
2455         success_ = value;
2456         onChanged();
2457         return this;
2458       }
2459       /**
2460        * <code>optional bool success = 5;</code>
2461        */
2462       public Builder clearSuccess() {
2463         bitField0_ = (bitField0_ & ~0x00000010);
2464         success_ = false;
2465         onChanged();
2466         return this;
2467       }
2468
2469       // optional uint32 negative_response_code = 6;
2470       private int negativeResponseCode_ ;
2471       /**
2472        * <code>optional uint32 negative_response_code = 6;</code>
2473        */
2474       public boolean hasNegativeResponseCode() {
2475         return ((bitField0_ & 0x00000020) == 0x00000020);
2476       }
2477       /**
2478        * <code>optional uint32 negative_response_code = 6;</code>
2479        */
2480       public int getNegativeResponseCode() {
2481         return negativeResponseCode_;
2482       }
2483       /**
2484        * <code>optional uint32 negative_response_code = 6;</code>
2485        */
2486       public Builder setNegativeResponseCode(int value) {
2487         bitField0_ |= 0x00000020;
2488         negativeResponseCode_ = value;
2489         onChanged();
2490         return this;
2491       }
2492       /**
2493        * <code>optional uint32 negative_response_code = 6;</code>
2494        */
2495       public Builder clearNegativeResponseCode() {
2496         bitField0_ = (bitField0_ & ~0x00000020);
2497         negativeResponseCode_ = 0;
2498         onChanged();
2499         return this;
2500       }
2501
2502       // optional bytes payload = 7;
2503       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
2504       /**
2505        * <code>optional bytes payload = 7;</code>
2506        *
2507        * <pre>
2508        * TODO we are capping this at 8 bytes for now - need to change when we
2509        * support multi-frame responses
2510        * </pre>
2511        */
2512       public boolean hasPayload() {
2513         return ((bitField0_ & 0x00000040) == 0x00000040);
2514       }
2515       /**
2516        * <code>optional bytes payload = 7;</code>
2517        *
2518        * <pre>
2519        * TODO we are capping this at 8 bytes for now - need to change when we
2520        * support multi-frame responses
2521        * </pre>
2522        */
2523       public com.google.protobuf.ByteString getPayload() {
2524         return payload_;
2525       }
2526       /**
2527        * <code>optional bytes payload = 7;</code>
2528        *
2529        * <pre>
2530        * TODO we are capping this at 8 bytes for now - need to change when we
2531        * support multi-frame responses
2532        * </pre>
2533        */
2534       public Builder setPayload(com.google.protobuf.ByteString value) {
2535         if (value == null) {
2536     throw new NullPointerException();
2537   }
2538   bitField0_ |= 0x00000040;
2539         payload_ = value;
2540         onChanged();
2541         return this;
2542       }
2543       /**
2544        * <code>optional bytes payload = 7;</code>
2545        *
2546        * <pre>
2547        * TODO we are capping this at 8 bytes for now - need to change when we
2548        * support multi-frame responses
2549        * </pre>
2550        */
2551       public Builder clearPayload() {
2552         bitField0_ = (bitField0_ & ~0x00000040);
2553         payload_ = getDefaultInstance().getPayload();
2554         onChanged();
2555         return this;
2556       }
2557
2558       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticMessage)
2559     }
2560
2561     static {
2562       defaultInstance = new DiagnosticMessage(true);
2563       defaultInstance.initFields();
2564     }
2565
2566     // @@protoc_insertion_point(class_scope:openxc.DiagnosticMessage)
2567   }
2568
2569   public interface TranslatedMessageOrBuilder
2570       extends com.google.protobuf.MessageOrBuilder {
2571
2572     // optional .openxc.TranslatedMessage.Type type = 1;
2573     /**
2574      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2575      */
2576     boolean hasType();
2577     /**
2578      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2579      */
2580     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
2581
2582     // optional string name = 2;
2583     /**
2584      * <code>optional string name = 2;</code>
2585      */
2586     boolean hasName();
2587     /**
2588      * <code>optional string name = 2;</code>
2589      */
2590     java.lang.String getName();
2591     /**
2592      * <code>optional string name = 2;</code>
2593      */
2594     com.google.protobuf.ByteString
2595         getNameBytes();
2596
2597     // optional string string_value = 3;
2598     /**
2599      * <code>optional string string_value = 3;</code>
2600      */
2601     boolean hasStringValue();
2602     /**
2603      * <code>optional string string_value = 3;</code>
2604      */
2605     java.lang.String getStringValue();
2606     /**
2607      * <code>optional string string_value = 3;</code>
2608      */
2609     com.google.protobuf.ByteString
2610         getStringValueBytes();
2611
2612     // optional double numeric_value = 4;
2613     /**
2614      * <code>optional double numeric_value = 4;</code>
2615      */
2616     boolean hasNumericValue();
2617     /**
2618      * <code>optional double numeric_value = 4;</code>
2619      */
2620     double getNumericValue();
2621
2622     // optional bool boolean_value = 5;
2623     /**
2624      * <code>optional bool boolean_value = 5;</code>
2625      */
2626     boolean hasBooleanValue();
2627     /**
2628      * <code>optional bool boolean_value = 5;</code>
2629      */
2630     boolean getBooleanValue();
2631
2632     // optional string string_event = 6;
2633     /**
2634      * <code>optional string string_event = 6;</code>
2635      */
2636     boolean hasStringEvent();
2637     /**
2638      * <code>optional string string_event = 6;</code>
2639      */
2640     java.lang.String getStringEvent();
2641     /**
2642      * <code>optional string string_event = 6;</code>
2643      */
2644     com.google.protobuf.ByteString
2645         getStringEventBytes();
2646
2647     // optional double numeric_event = 7;
2648     /**
2649      * <code>optional double numeric_event = 7;</code>
2650      */
2651     boolean hasNumericEvent();
2652     /**
2653      * <code>optional double numeric_event = 7;</code>
2654      */
2655     double getNumericEvent();
2656
2657     // optional bool boolean_event = 8;
2658     /**
2659      * <code>optional bool boolean_event = 8;</code>
2660      */
2661     boolean hasBooleanEvent();
2662     /**
2663      * <code>optional bool boolean_event = 8;</code>
2664      */
2665     boolean getBooleanEvent();
2666   }
2667   /**
2668    * Protobuf type {@code openxc.TranslatedMessage}
2669    */
2670   public static final class TranslatedMessage extends
2671       com.google.protobuf.GeneratedMessage
2672       implements TranslatedMessageOrBuilder {
2673     // Use TranslatedMessage.newBuilder() to construct.
2674     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2675       super(builder);
2676       this.unknownFields = builder.getUnknownFields();
2677     }
2678     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2679
2680     private static final TranslatedMessage defaultInstance;
2681     public static TranslatedMessage getDefaultInstance() {
2682       return defaultInstance;
2683     }
2684
2685     public TranslatedMessage getDefaultInstanceForType() {
2686       return defaultInstance;
2687     }
2688
2689     private final com.google.protobuf.UnknownFieldSet unknownFields;
2690     @java.lang.Override
2691     public final com.google.protobuf.UnknownFieldSet
2692         getUnknownFields() {
2693       return this.unknownFields;
2694     }
2695     private TranslatedMessage(
2696         com.google.protobuf.CodedInputStream input,
2697         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2698         throws com.google.protobuf.InvalidProtocolBufferException {
2699       initFields();
2700       int mutable_bitField0_ = 0;
2701       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2702           com.google.protobuf.UnknownFieldSet.newBuilder();
2703       try {
2704         boolean done = false;
2705         while (!done) {
2706           int tag = input.readTag();
2707           switch (tag) {
2708             case 0:
2709               done = true;
2710               break;
2711             default: {
2712               if (!parseUnknownField(input, unknownFields,
2713                                      extensionRegistry, tag)) {
2714                 done = true;
2715               }
2716               break;
2717             }
2718             case 8: {
2719               int rawValue = input.readEnum();
2720               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
2721               if (value == null) {
2722                 unknownFields.mergeVarintField(1, rawValue);
2723               } else {
2724                 bitField0_ |= 0x00000001;
2725                 type_ = value;
2726               }
2727               break;
2728             }
2729             case 18: {
2730               bitField0_ |= 0x00000002;
2731               name_ = input.readBytes();
2732               break;
2733             }
2734             case 26: {
2735               bitField0_ |= 0x00000004;
2736               stringValue_ = input.readBytes();
2737               break;
2738             }
2739             case 33: {
2740               bitField0_ |= 0x00000008;
2741               numericValue_ = input.readDouble();
2742               break;
2743             }
2744             case 40: {
2745               bitField0_ |= 0x00000010;
2746               booleanValue_ = input.readBool();
2747               break;
2748             }
2749             case 50: {
2750               bitField0_ |= 0x00000020;
2751               stringEvent_ = input.readBytes();
2752               break;
2753             }
2754             case 57: {
2755               bitField0_ |= 0x00000040;
2756               numericEvent_ = input.readDouble();
2757               break;
2758             }
2759             case 64: {
2760               bitField0_ |= 0x00000080;
2761               booleanEvent_ = input.readBool();
2762               break;
2763             }
2764           }
2765         }
2766       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2767         throw e.setUnfinishedMessage(this);
2768       } catch (java.io.IOException e) {
2769         throw new com.google.protobuf.InvalidProtocolBufferException(
2770             e.getMessage()).setUnfinishedMessage(this);
2771       } finally {
2772         this.unknownFields = unknownFields.build();
2773         makeExtensionsImmutable();
2774       }
2775     }
2776     public static final com.google.protobuf.Descriptors.Descriptor
2777         getDescriptor() {
2778       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
2779     }
2780
2781     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2782         internalGetFieldAccessorTable() {
2783       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
2784           .ensureFieldAccessorsInitialized(
2785               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
2786     }
2787
2788     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
2789         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
2790       public TranslatedMessage parsePartialFrom(
2791           com.google.protobuf.CodedInputStream input,
2792           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2793           throws com.google.protobuf.InvalidProtocolBufferException {
2794         return new TranslatedMessage(input, extensionRegistry);
2795       }
2796     };
2797
2798     @java.lang.Override
2799     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
2800       return PARSER;
2801     }
2802
2803     /**
2804      * Protobuf enum {@code openxc.TranslatedMessage.Type}
2805      */
2806     public enum Type
2807         implements com.google.protobuf.ProtocolMessageEnum {
2808       /**
2809        * <code>STRING = 1;</code>
2810        */
2811       STRING(0, 1),
2812       /**
2813        * <code>NUM = 2;</code>
2814        */
2815       NUM(1, 2),
2816       /**
2817        * <code>BOOL = 3;</code>
2818        */
2819       BOOL(2, 3),
2820       /**
2821        * <code>EVENTED_STRING = 4;</code>
2822        */
2823       EVENTED_STRING(3, 4),
2824       /**
2825        * <code>EVENTED_NUM = 5;</code>
2826        */
2827       EVENTED_NUM(4, 5),
2828       /**
2829        * <code>EVENTED_BOOL = 6;</code>
2830        */
2831       EVENTED_BOOL(5, 6),
2832       ;
2833
2834       /**
2835        * <code>STRING = 1;</code>
2836        */
2837       public static final int STRING_VALUE = 1;
2838       /**
2839        * <code>NUM = 2;</code>
2840        */
2841       public static final int NUM_VALUE = 2;
2842       /**
2843        * <code>BOOL = 3;</code>
2844        */
2845       public static final int BOOL_VALUE = 3;
2846       /**
2847        * <code>EVENTED_STRING = 4;</code>
2848        */
2849       public static final int EVENTED_STRING_VALUE = 4;
2850       /**
2851        * <code>EVENTED_NUM = 5;</code>
2852        */
2853       public static final int EVENTED_NUM_VALUE = 5;
2854       /**
2855        * <code>EVENTED_BOOL = 6;</code>
2856        */
2857       public static final int EVENTED_BOOL_VALUE = 6;
2858
2859
2860       public final int getNumber() { return value; }
2861
2862       public static Type valueOf(int value) {
2863         switch (value) {
2864           case 1: return STRING;
2865           case 2: return NUM;
2866           case 3: return BOOL;
2867           case 4: return EVENTED_STRING;
2868           case 5: return EVENTED_NUM;
2869           case 6: return EVENTED_BOOL;
2870           default: return null;
2871         }
2872       }
2873
2874       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2875           internalGetValueMap() {
2876         return internalValueMap;
2877       }
2878       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2879           internalValueMap =
2880             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2881               public Type findValueByNumber(int number) {
2882                 return Type.valueOf(number);
2883               }
2884             };
2885
2886       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2887           getValueDescriptor() {
2888         return getDescriptor().getValues().get(index);
2889       }
2890       public final com.google.protobuf.Descriptors.EnumDescriptor
2891           getDescriptorForType() {
2892         return getDescriptor();
2893       }
2894       public static final com.google.protobuf.Descriptors.EnumDescriptor
2895           getDescriptor() {
2896         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
2897       }
2898
2899       private static final Type[] VALUES = values();
2900
2901       public static Type valueOf(
2902           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2903         if (desc.getType() != getDescriptor()) {
2904           throw new java.lang.IllegalArgumentException(
2905             "EnumValueDescriptor is not for this type.");
2906         }
2907         return VALUES[desc.getIndex()];
2908       }
2909
2910       private final int index;
2911       private final int value;
2912
2913       private Type(int index, int value) {
2914         this.index = index;
2915         this.value = value;
2916       }
2917
2918       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
2919     }
2920
2921     private int bitField0_;
2922     // optional .openxc.TranslatedMessage.Type type = 1;
2923     public static final int TYPE_FIELD_NUMBER = 1;
2924     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
2925     /**
2926      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2927      */
2928     public boolean hasType() {
2929       return ((bitField0_ & 0x00000001) == 0x00000001);
2930     }
2931     /**
2932      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2933      */
2934     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
2935       return type_;
2936     }
2937
2938     // optional string name = 2;
2939     public static final int NAME_FIELD_NUMBER = 2;
2940     private java.lang.Object name_;
2941     /**
2942      * <code>optional string name = 2;</code>
2943      */
2944     public boolean hasName() {
2945       return ((bitField0_ & 0x00000002) == 0x00000002);
2946     }
2947     /**
2948      * <code>optional string name = 2;</code>
2949      */
2950     public java.lang.String getName() {
2951       java.lang.Object ref = name_;
2952       if (ref instanceof java.lang.String) {
2953         return (java.lang.String) ref;
2954       } else {
2955         com.google.protobuf.ByteString bs =
2956             (com.google.protobuf.ByteString) ref;
2957         java.lang.String s = bs.toStringUtf8();
2958         if (bs.isValidUtf8()) {
2959           name_ = s;
2960         }
2961         return s;
2962       }
2963     }
2964     /**
2965      * <code>optional string name = 2;</code>
2966      */
2967     public com.google.protobuf.ByteString
2968         getNameBytes() {
2969       java.lang.Object ref = name_;
2970       if (ref instanceof java.lang.String) {
2971         com.google.protobuf.ByteString b =
2972             com.google.protobuf.ByteString.copyFromUtf8(
2973                 (java.lang.String) ref);
2974         name_ = b;
2975         return b;
2976       } else {
2977         return (com.google.protobuf.ByteString) ref;
2978       }
2979     }
2980
2981     // optional string string_value = 3;
2982     public static final int STRING_VALUE_FIELD_NUMBER = 3;
2983     private java.lang.Object stringValue_;
2984     /**
2985      * <code>optional string string_value = 3;</code>
2986      */
2987     public boolean hasStringValue() {
2988       return ((bitField0_ & 0x00000004) == 0x00000004);
2989     }
2990     /**
2991      * <code>optional string string_value = 3;</code>
2992      */
2993     public java.lang.String getStringValue() {
2994       java.lang.Object ref = stringValue_;
2995       if (ref instanceof java.lang.String) {
2996         return (java.lang.String) ref;
2997       } else {
2998         com.google.protobuf.ByteString bs =
2999             (com.google.protobuf.ByteString) ref;
3000         java.lang.String s = bs.toStringUtf8();
3001         if (bs.isValidUtf8()) {
3002           stringValue_ = s;
3003         }
3004         return s;
3005       }
3006     }
3007     /**
3008      * <code>optional string string_value = 3;</code>
3009      */
3010     public com.google.protobuf.ByteString
3011         getStringValueBytes() {
3012       java.lang.Object ref = stringValue_;
3013       if (ref instanceof java.lang.String) {
3014         com.google.protobuf.ByteString b =
3015             com.google.protobuf.ByteString.copyFromUtf8(
3016                 (java.lang.String) ref);
3017         stringValue_ = b;
3018         return b;
3019       } else {
3020         return (com.google.protobuf.ByteString) ref;
3021       }
3022     }
3023
3024     // optional double numeric_value = 4;
3025     public static final int NUMERIC_VALUE_FIELD_NUMBER = 4;
3026     private double numericValue_;
3027     /**
3028      * <code>optional double numeric_value = 4;</code>
3029      */
3030     public boolean hasNumericValue() {
3031       return ((bitField0_ & 0x00000008) == 0x00000008);
3032     }
3033     /**
3034      * <code>optional double numeric_value = 4;</code>
3035      */
3036     public double getNumericValue() {
3037       return numericValue_;
3038     }
3039
3040     // optional bool boolean_value = 5;
3041     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 5;
3042     private boolean booleanValue_;
3043     /**
3044      * <code>optional bool boolean_value = 5;</code>
3045      */
3046     public boolean hasBooleanValue() {
3047       return ((bitField0_ & 0x00000010) == 0x00000010);
3048     }
3049     /**
3050      * <code>optional bool boolean_value = 5;</code>
3051      */
3052     public boolean getBooleanValue() {
3053       return booleanValue_;
3054     }
3055
3056     // optional string string_event = 6;
3057     public static final int STRING_EVENT_FIELD_NUMBER = 6;
3058     private java.lang.Object stringEvent_;
3059     /**
3060      * <code>optional string string_event = 6;</code>
3061      */
3062     public boolean hasStringEvent() {
3063       return ((bitField0_ & 0x00000020) == 0x00000020);
3064     }
3065     /**
3066      * <code>optional string string_event = 6;</code>
3067      */
3068     public java.lang.String getStringEvent() {
3069       java.lang.Object ref = stringEvent_;
3070       if (ref instanceof java.lang.String) {
3071         return (java.lang.String) ref;
3072       } else {
3073         com.google.protobuf.ByteString bs =
3074             (com.google.protobuf.ByteString) ref;
3075         java.lang.String s = bs.toStringUtf8();
3076         if (bs.isValidUtf8()) {
3077           stringEvent_ = s;
3078         }
3079         return s;
3080       }
3081     }
3082     /**
3083      * <code>optional string string_event = 6;</code>
3084      */
3085     public com.google.protobuf.ByteString
3086         getStringEventBytes() {
3087       java.lang.Object ref = stringEvent_;
3088       if (ref instanceof java.lang.String) {
3089         com.google.protobuf.ByteString b =
3090             com.google.protobuf.ByteString.copyFromUtf8(
3091                 (java.lang.String) ref);
3092         stringEvent_ = b;
3093         return b;
3094       } else {
3095         return (com.google.protobuf.ByteString) ref;
3096       }
3097     }
3098
3099     // optional double numeric_event = 7;
3100     public static final int NUMERIC_EVENT_FIELD_NUMBER = 7;
3101     private double numericEvent_;
3102     /**
3103      * <code>optional double numeric_event = 7;</code>
3104      */
3105     public boolean hasNumericEvent() {
3106       return ((bitField0_ & 0x00000040) == 0x00000040);
3107     }
3108     /**
3109      * <code>optional double numeric_event = 7;</code>
3110      */
3111     public double getNumericEvent() {
3112       return numericEvent_;
3113     }
3114
3115     // optional bool boolean_event = 8;
3116     public static final int BOOLEAN_EVENT_FIELD_NUMBER = 8;
3117     private boolean booleanEvent_;
3118     /**
3119      * <code>optional bool boolean_event = 8;</code>
3120      */
3121     public boolean hasBooleanEvent() {
3122       return ((bitField0_ & 0x00000080) == 0x00000080);
3123     }
3124     /**
3125      * <code>optional bool boolean_event = 8;</code>
3126      */
3127     public boolean getBooleanEvent() {
3128       return booleanEvent_;
3129     }
3130
3131     private void initFields() {
3132       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3133       name_ = "";
3134       stringValue_ = "";
3135       numericValue_ = 0D;
3136       booleanValue_ = false;
3137       stringEvent_ = "";
3138       numericEvent_ = 0D;
3139       booleanEvent_ = false;
3140     }
3141     private byte memoizedIsInitialized = -1;
3142     public final boolean isInitialized() {
3143       byte isInitialized = memoizedIsInitialized;
3144       if (isInitialized != -1) return isInitialized == 1;
3145
3146       memoizedIsInitialized = 1;
3147       return true;
3148     }
3149
3150     public void writeTo(com.google.protobuf.CodedOutputStream output)
3151                         throws java.io.IOException {
3152       getSerializedSize();
3153       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3154         output.writeEnum(1, type_.getNumber());
3155       }
3156       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3157         output.writeBytes(2, getNameBytes());
3158       }
3159       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3160         output.writeBytes(3, getStringValueBytes());
3161       }
3162       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3163         output.writeDouble(4, numericValue_);
3164       }
3165       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3166         output.writeBool(5, booleanValue_);
3167       }
3168       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3169         output.writeBytes(6, getStringEventBytes());
3170       }
3171       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3172         output.writeDouble(7, numericEvent_);
3173       }
3174       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3175         output.writeBool(8, booleanEvent_);
3176       }
3177       getUnknownFields().writeTo(output);
3178     }
3179
3180     private int memoizedSerializedSize = -1;
3181     public int getSerializedSize() {
3182       int size = memoizedSerializedSize;
3183       if (size != -1) return size;
3184
3185       size = 0;
3186       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3187         size += com.google.protobuf.CodedOutputStream
3188           .computeEnumSize(1, type_.getNumber());
3189       }
3190       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3191         size += com.google.protobuf.CodedOutputStream
3192           .computeBytesSize(2, getNameBytes());
3193       }
3194       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3195         size += com.google.protobuf.CodedOutputStream
3196           .computeBytesSize(3, getStringValueBytes());
3197       }
3198       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3199         size += com.google.protobuf.CodedOutputStream
3200           .computeDoubleSize(4, numericValue_);
3201       }
3202       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3203         size += com.google.protobuf.CodedOutputStream
3204           .computeBoolSize(5, booleanValue_);
3205       }
3206       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3207         size += com.google.protobuf.CodedOutputStream
3208           .computeBytesSize(6, getStringEventBytes());
3209       }
3210       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3211         size += com.google.protobuf.CodedOutputStream
3212           .computeDoubleSize(7, numericEvent_);
3213       }
3214       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3215         size += com.google.protobuf.CodedOutputStream
3216           .computeBoolSize(8, booleanEvent_);
3217       }
3218       size += getUnknownFields().getSerializedSize();
3219       memoizedSerializedSize = size;
3220       return size;
3221     }
3222
3223     private static final long serialVersionUID = 0L;
3224     @java.lang.Override
3225     protected java.lang.Object writeReplace()
3226         throws java.io.ObjectStreamException {
3227       return super.writeReplace();
3228     }
3229
3230     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3231         com.google.protobuf.ByteString data)
3232         throws com.google.protobuf.InvalidProtocolBufferException {
3233       return PARSER.parseFrom(data);
3234     }
3235     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3236         com.google.protobuf.ByteString data,
3237         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3238         throws com.google.protobuf.InvalidProtocolBufferException {
3239       return PARSER.parseFrom(data, extensionRegistry);
3240     }
3241     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
3242         throws com.google.protobuf.InvalidProtocolBufferException {
3243       return PARSER.parseFrom(data);
3244     }
3245     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3246         byte[] data,
3247         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3248         throws com.google.protobuf.InvalidProtocolBufferException {
3249       return PARSER.parseFrom(data, extensionRegistry);
3250     }
3251     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
3252         throws java.io.IOException {
3253       return PARSER.parseFrom(input);
3254     }
3255     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3256         java.io.InputStream input,
3257         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3258         throws java.io.IOException {
3259       return PARSER.parseFrom(input, extensionRegistry);
3260     }
3261     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
3262         throws java.io.IOException {
3263       return PARSER.parseDelimitedFrom(input);
3264     }
3265     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
3266         java.io.InputStream input,
3267         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3268         throws java.io.IOException {
3269       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3270     }
3271     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3272         com.google.protobuf.CodedInputStream input)
3273         throws java.io.IOException {
3274       return PARSER.parseFrom(input);
3275     }
3276     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3277         com.google.protobuf.CodedInputStream input,
3278         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3279         throws java.io.IOException {
3280       return PARSER.parseFrom(input, extensionRegistry);
3281     }
3282
3283     public static Builder newBuilder() { return Builder.create(); }
3284     public Builder newBuilderForType() { return newBuilder(); }
3285     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
3286       return newBuilder().mergeFrom(prototype);
3287     }
3288     public Builder toBuilder() { return newBuilder(this); }
3289
3290     @java.lang.Override
3291     protected Builder newBuilderForType(
3292         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3293       Builder builder = new Builder(parent);
3294       return builder;
3295     }
3296     /**
3297      * Protobuf type {@code openxc.TranslatedMessage}
3298      */
3299     public static final class Builder extends
3300         com.google.protobuf.GeneratedMessage.Builder<Builder>
3301        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
3302       public static final com.google.protobuf.Descriptors.Descriptor
3303           getDescriptor() {
3304         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
3305       }
3306
3307       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3308           internalGetFieldAccessorTable() {
3309         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
3310             .ensureFieldAccessorsInitialized(
3311                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
3312       }
3313
3314       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
3315       private Builder() {
3316         maybeForceBuilderInitialization();
3317       }
3318
3319       private Builder(
3320           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3321         super(parent);
3322         maybeForceBuilderInitialization();
3323       }
3324       private void maybeForceBuilderInitialization() {
3325         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3326         }
3327       }
3328       private static Builder create() {
3329         return new Builder();
3330       }
3331
3332       public Builder clear() {
3333         super.clear();
3334         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3335         bitField0_ = (bitField0_ & ~0x00000001);
3336         name_ = "";
3337         bitField0_ = (bitField0_ & ~0x00000002);
3338         stringValue_ = "";
3339         bitField0_ = (bitField0_ & ~0x00000004);
3340         numericValue_ = 0D;
3341         bitField0_ = (bitField0_ & ~0x00000008);
3342         booleanValue_ = false;
3343         bitField0_ = (bitField0_ & ~0x00000010);
3344         stringEvent_ = "";
3345         bitField0_ = (bitField0_ & ~0x00000020);
3346         numericEvent_ = 0D;
3347         bitField0_ = (bitField0_ & ~0x00000040);
3348         booleanEvent_ = false;
3349         bitField0_ = (bitField0_ & ~0x00000080);
3350         return this;
3351       }
3352
3353       public Builder clone() {
3354         return create().mergeFrom(buildPartial());
3355       }
3356
3357       public com.google.protobuf.Descriptors.Descriptor
3358           getDescriptorForType() {
3359         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
3360       }
3361
3362       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
3363         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
3364       }
3365
3366       public com.openxc.BinaryMessages.TranslatedMessage build() {
3367         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
3368         if (!result.isInitialized()) {
3369           throw newUninitializedMessageException(result);
3370         }
3371         return result;
3372       }
3373
3374       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
3375         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
3376         int from_bitField0_ = bitField0_;
3377         int to_bitField0_ = 0;
3378         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3379           to_bitField0_ |= 0x00000001;
3380         }
3381         result.type_ = type_;
3382         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3383           to_bitField0_ |= 0x00000002;
3384         }
3385         result.name_ = name_;
3386         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
3387           to_bitField0_ |= 0x00000004;
3388         }
3389         result.stringValue_ = stringValue_;
3390         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
3391           to_bitField0_ |= 0x00000008;
3392         }
3393         result.numericValue_ = numericValue_;
3394         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
3395           to_bitField0_ |= 0x00000010;
3396         }
3397         result.booleanValue_ = booleanValue_;
3398         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
3399           to_bitField0_ |= 0x00000020;
3400         }
3401         result.stringEvent_ = stringEvent_;
3402         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
3403           to_bitField0_ |= 0x00000040;
3404         }
3405         result.numericEvent_ = numericEvent_;
3406         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
3407           to_bitField0_ |= 0x00000080;
3408         }
3409         result.booleanEvent_ = booleanEvent_;
3410         result.bitField0_ = to_bitField0_;
3411         onBuilt();
3412         return result;
3413       }
3414
3415       public Builder mergeFrom(com.google.protobuf.Message other) {
3416         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
3417           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
3418         } else {
3419           super.mergeFrom(other);
3420           return this;
3421         }
3422       }
3423
3424       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
3425         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
3426         if (other.hasType()) {
3427           setType(other.getType());
3428         }
3429         if (other.hasName()) {
3430           bitField0_ |= 0x00000002;
3431           name_ = other.name_;
3432           onChanged();
3433         }
3434         if (other.hasStringValue()) {
3435           bitField0_ |= 0x00000004;
3436           stringValue_ = other.stringValue_;
3437           onChanged();
3438         }
3439         if (other.hasNumericValue()) {
3440           setNumericValue(other.getNumericValue());
3441         }
3442         if (other.hasBooleanValue()) {
3443           setBooleanValue(other.getBooleanValue());
3444         }
3445         if (other.hasStringEvent()) {
3446           bitField0_ |= 0x00000020;
3447           stringEvent_ = other.stringEvent_;
3448           onChanged();
3449         }
3450         if (other.hasNumericEvent()) {
3451           setNumericEvent(other.getNumericEvent());
3452         }
3453         if (other.hasBooleanEvent()) {
3454           setBooleanEvent(other.getBooleanEvent());
3455         }
3456         this.mergeUnknownFields(other.getUnknownFields());
3457         return this;
3458       }
3459
3460       public final boolean isInitialized() {
3461         return true;
3462       }
3463
3464       public Builder mergeFrom(
3465           com.google.protobuf.CodedInputStream input,
3466           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3467           throws java.io.IOException {
3468         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
3469         try {
3470           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3471         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3472           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
3473           throw e;
3474         } finally {
3475           if (parsedMessage != null) {
3476             mergeFrom(parsedMessage);
3477           }
3478         }
3479         return this;
3480       }
3481       private int bitField0_;
3482
3483       // optional .openxc.TranslatedMessage.Type type = 1;
3484       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3485       /**
3486        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3487        */
3488       public boolean hasType() {
3489         return ((bitField0_ & 0x00000001) == 0x00000001);
3490       }
3491       /**
3492        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3493        */
3494       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
3495         return type_;
3496       }
3497       /**
3498        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3499        */
3500       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
3501         if (value == null) {
3502           throw new NullPointerException();
3503         }
3504         bitField0_ |= 0x00000001;
3505         type_ = value;
3506         onChanged();
3507         return this;
3508       }
3509       /**
3510        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3511        */
3512       public Builder clearType() {
3513         bitField0_ = (bitField0_ & ~0x00000001);
3514         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3515         onChanged();
3516         return this;
3517       }
3518
3519       // optional string name = 2;
3520       private java.lang.Object name_ = "";
3521       /**
3522        * <code>optional string name = 2;</code>
3523        */
3524       public boolean hasName() {
3525         return ((bitField0_ & 0x00000002) == 0x00000002);
3526       }
3527       /**
3528        * <code>optional string name = 2;</code>
3529        */
3530       public java.lang.String getName() {
3531         java.lang.Object ref = name_;
3532         if (!(ref instanceof java.lang.String)) {
3533           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3534               .toStringUtf8();
3535           name_ = s;
3536           return s;
3537         } else {
3538           return (java.lang.String) ref;
3539         }
3540       }
3541       /**
3542        * <code>optional string name = 2;</code>
3543        */
3544       public com.google.protobuf.ByteString
3545           getNameBytes() {
3546         java.lang.Object ref = name_;
3547         if (ref instanceof String) {
3548           com.google.protobuf.ByteString b =
3549               com.google.protobuf.ByteString.copyFromUtf8(
3550                   (java.lang.String) ref);
3551           name_ = b;
3552           return b;
3553         } else {
3554           return (com.google.protobuf.ByteString) ref;
3555         }
3556       }
3557       /**
3558        * <code>optional string name = 2;</code>
3559        */
3560       public Builder setName(
3561           java.lang.String value) {
3562         if (value == null) {
3563     throw new NullPointerException();
3564   }
3565   bitField0_ |= 0x00000002;
3566         name_ = value;
3567         onChanged();
3568         return this;
3569       }
3570       /**
3571        * <code>optional string name = 2;</code>
3572        */
3573       public Builder clearName() {
3574         bitField0_ = (bitField0_ & ~0x00000002);
3575         name_ = getDefaultInstance().getName();
3576         onChanged();
3577         return this;
3578       }
3579       /**
3580        * <code>optional string name = 2;</code>
3581        */
3582       public Builder setNameBytes(
3583           com.google.protobuf.ByteString value) {
3584         if (value == null) {
3585     throw new NullPointerException();
3586   }
3587   bitField0_ |= 0x00000002;
3588         name_ = value;
3589         onChanged();
3590         return this;
3591       }
3592
3593       // optional string string_value = 3;
3594       private java.lang.Object stringValue_ = "";
3595       /**
3596        * <code>optional string string_value = 3;</code>
3597        */
3598       public boolean hasStringValue() {
3599         return ((bitField0_ & 0x00000004) == 0x00000004);
3600       }
3601       /**
3602        * <code>optional string string_value = 3;</code>
3603        */
3604       public java.lang.String getStringValue() {
3605         java.lang.Object ref = stringValue_;
3606         if (!(ref instanceof java.lang.String)) {
3607           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3608               .toStringUtf8();
3609           stringValue_ = s;
3610           return s;
3611         } else {
3612           return (java.lang.String) ref;
3613         }
3614       }
3615       /**
3616        * <code>optional string string_value = 3;</code>
3617        */
3618       public com.google.protobuf.ByteString
3619           getStringValueBytes() {
3620         java.lang.Object ref = stringValue_;
3621         if (ref instanceof String) {
3622           com.google.protobuf.ByteString b =
3623               com.google.protobuf.ByteString.copyFromUtf8(
3624                   (java.lang.String) ref);
3625           stringValue_ = b;
3626           return b;
3627         } else {
3628           return (com.google.protobuf.ByteString) ref;
3629         }
3630       }
3631       /**
3632        * <code>optional string string_value = 3;</code>
3633        */
3634       public Builder setStringValue(
3635           java.lang.String value) {
3636         if (value == null) {
3637     throw new NullPointerException();
3638   }
3639   bitField0_ |= 0x00000004;
3640         stringValue_ = value;
3641         onChanged();
3642         return this;
3643       }
3644       /**
3645        * <code>optional string string_value = 3;</code>
3646        */
3647       public Builder clearStringValue() {
3648         bitField0_ = (bitField0_ & ~0x00000004);
3649         stringValue_ = getDefaultInstance().getStringValue();
3650         onChanged();
3651         return this;
3652       }
3653       /**
3654        * <code>optional string string_value = 3;</code>
3655        */
3656       public Builder setStringValueBytes(
3657           com.google.protobuf.ByteString value) {
3658         if (value == null) {
3659     throw new NullPointerException();
3660   }
3661   bitField0_ |= 0x00000004;
3662         stringValue_ = value;
3663         onChanged();
3664         return this;
3665       }
3666
3667       // optional double numeric_value = 4;
3668       private double numericValue_ ;
3669       /**
3670        * <code>optional double numeric_value = 4;</code>
3671        */
3672       public boolean hasNumericValue() {
3673         return ((bitField0_ & 0x00000008) == 0x00000008);
3674       }
3675       /**
3676        * <code>optional double numeric_value = 4;</code>
3677        */
3678       public double getNumericValue() {
3679         return numericValue_;
3680       }
3681       /**
3682        * <code>optional double numeric_value = 4;</code>
3683        */
3684       public Builder setNumericValue(double value) {
3685         bitField0_ |= 0x00000008;
3686         numericValue_ = value;
3687         onChanged();
3688         return this;
3689       }
3690       /**
3691        * <code>optional double numeric_value = 4;</code>
3692        */
3693       public Builder clearNumericValue() {
3694         bitField0_ = (bitField0_ & ~0x00000008);
3695         numericValue_ = 0D;
3696         onChanged();
3697         return this;
3698       }
3699
3700       // optional bool boolean_value = 5;
3701       private boolean booleanValue_ ;
3702       /**
3703        * <code>optional bool boolean_value = 5;</code>
3704        */
3705       public boolean hasBooleanValue() {
3706         return ((bitField0_ & 0x00000010) == 0x00000010);
3707       }
3708       /**
3709        * <code>optional bool boolean_value = 5;</code>
3710        */
3711       public boolean getBooleanValue() {
3712         return booleanValue_;
3713       }
3714       /**
3715        * <code>optional bool boolean_value = 5;</code>
3716        */
3717       public Builder setBooleanValue(boolean value) {
3718         bitField0_ |= 0x00000010;
3719         booleanValue_ = value;
3720         onChanged();
3721         return this;
3722       }
3723       /**
3724        * <code>optional bool boolean_value = 5;</code>
3725        */
3726       public Builder clearBooleanValue() {
3727         bitField0_ = (bitField0_ & ~0x00000010);
3728         booleanValue_ = false;
3729         onChanged();
3730         return this;
3731       }
3732
3733       // optional string string_event = 6;
3734       private java.lang.Object stringEvent_ = "";
3735       /**
3736        * <code>optional string string_event = 6;</code>
3737        */
3738       public boolean hasStringEvent() {
3739         return ((bitField0_ & 0x00000020) == 0x00000020);
3740       }
3741       /**
3742        * <code>optional string string_event = 6;</code>
3743        */
3744       public java.lang.String getStringEvent() {
3745         java.lang.Object ref = stringEvent_;
3746         if (!(ref instanceof java.lang.String)) {
3747           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3748               .toStringUtf8();
3749           stringEvent_ = s;
3750           return s;
3751         } else {
3752           return (java.lang.String) ref;
3753         }
3754       }
3755       /**
3756        * <code>optional string string_event = 6;</code>
3757        */
3758       public com.google.protobuf.ByteString
3759           getStringEventBytes() {
3760         java.lang.Object ref = stringEvent_;
3761         if (ref instanceof String) {
3762           com.google.protobuf.ByteString b =
3763               com.google.protobuf.ByteString.copyFromUtf8(
3764                   (java.lang.String) ref);
3765           stringEvent_ = b;
3766           return b;
3767         } else {
3768           return (com.google.protobuf.ByteString) ref;
3769         }
3770       }
3771       /**
3772        * <code>optional string string_event = 6;</code>
3773        */
3774       public Builder setStringEvent(
3775           java.lang.String value) {
3776         if (value == null) {
3777     throw new NullPointerException();
3778   }
3779   bitField0_ |= 0x00000020;
3780         stringEvent_ = value;
3781         onChanged();
3782         return this;
3783       }
3784       /**
3785        * <code>optional string string_event = 6;</code>
3786        */
3787       public Builder clearStringEvent() {
3788         bitField0_ = (bitField0_ & ~0x00000020);
3789         stringEvent_ = getDefaultInstance().getStringEvent();
3790         onChanged();
3791         return this;
3792       }
3793       /**
3794        * <code>optional string string_event = 6;</code>
3795        */
3796       public Builder setStringEventBytes(
3797           com.google.protobuf.ByteString value) {
3798         if (value == null) {
3799     throw new NullPointerException();
3800   }
3801   bitField0_ |= 0x00000020;
3802         stringEvent_ = value;
3803         onChanged();
3804         return this;
3805       }
3806
3807       // optional double numeric_event = 7;
3808       private double numericEvent_ ;
3809       /**
3810        * <code>optional double numeric_event = 7;</code>
3811        */
3812       public boolean hasNumericEvent() {
3813         return ((bitField0_ & 0x00000040) == 0x00000040);
3814       }
3815       /**
3816        * <code>optional double numeric_event = 7;</code>
3817        */
3818       public double getNumericEvent() {
3819         return numericEvent_;
3820       }
3821       /**
3822        * <code>optional double numeric_event = 7;</code>
3823        */
3824       public Builder setNumericEvent(double value) {
3825         bitField0_ |= 0x00000040;
3826         numericEvent_ = value;
3827         onChanged();
3828         return this;
3829       }
3830       /**
3831        * <code>optional double numeric_event = 7;</code>
3832        */
3833       public Builder clearNumericEvent() {
3834         bitField0_ = (bitField0_ & ~0x00000040);
3835         numericEvent_ = 0D;
3836         onChanged();
3837         return this;
3838       }
3839
3840       // optional bool boolean_event = 8;
3841       private boolean booleanEvent_ ;
3842       /**
3843        * <code>optional bool boolean_event = 8;</code>
3844        */
3845       public boolean hasBooleanEvent() {
3846         return ((bitField0_ & 0x00000080) == 0x00000080);
3847       }
3848       /**
3849        * <code>optional bool boolean_event = 8;</code>
3850        */
3851       public boolean getBooleanEvent() {
3852         return booleanEvent_;
3853       }
3854       /**
3855        * <code>optional bool boolean_event = 8;</code>
3856        */
3857       public Builder setBooleanEvent(boolean value) {
3858         bitField0_ |= 0x00000080;
3859         booleanEvent_ = value;
3860         onChanged();
3861         return this;
3862       }
3863       /**
3864        * <code>optional bool boolean_event = 8;</code>
3865        */
3866       public Builder clearBooleanEvent() {
3867         bitField0_ = (bitField0_ & ~0x00000080);
3868         booleanEvent_ = false;
3869         onChanged();
3870         return this;
3871       }
3872
3873       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
3874     }
3875
3876     static {
3877       defaultInstance = new TranslatedMessage(true);
3878       defaultInstance.initFields();
3879     }
3880
3881     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
3882   }
3883
3884   private static com.google.protobuf.Descriptors.Descriptor
3885     internal_static_openxc_VehicleMessage_descriptor;
3886   private static
3887     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3888       internal_static_openxc_VehicleMessage_fieldAccessorTable;
3889   private static com.google.protobuf.Descriptors.Descriptor
3890     internal_static_openxc_RawMessage_descriptor;
3891   private static
3892     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3893       internal_static_openxc_RawMessage_fieldAccessorTable;
3894   private static com.google.protobuf.Descriptors.Descriptor
3895     internal_static_openxc_DiagnosticMessage_descriptor;
3896   private static
3897     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3898       internal_static_openxc_DiagnosticMessage_fieldAccessorTable;
3899   private static com.google.protobuf.Descriptors.Descriptor
3900     internal_static_openxc_TranslatedMessage_descriptor;
3901   private static
3902     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3903       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
3904
3905   public static com.google.protobuf.Descriptors.FileDescriptor
3906       getDescriptor() {
3907     return descriptor;
3908   }
3909   private static com.google.protobuf.Descriptors.FileDescriptor
3910       descriptor;
3911   static {
3912     java.lang.String[] descriptorData = {
3913       "\n\014openxc.proto\022\006openxc\"\203\002\n\016VehicleMessag" +
3914       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
3915       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
3916       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
3917       "xc.TranslatedMessage\0225\n\022diagnostic_messa" +
3918       "ge\030\004 \001(\0132\031.openxc.DiagnosticMessage\"/\n\004T" +
3919       "ype\022\007\n\003RAW\020\001\022\016\n\nTRANSLATED\020\002\022\016\n\nDIAGNOST" +
3920       "IC\020\003\";\n\nRawMessage\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessa" +
3921       "ge_id\030\002 \001(\r\022\014\n\004data\030\003 \001(\014\"\221\001\n\021Diagnostic" +
3922       "Message\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r",
3923       "\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005" +
3924       " \001(\010\022\036\n\026negative_response_code\030\006 \001(\r\022\017\n\007" +
3925       "payload\030\007 \001(\014\"\265\002\n\021TranslatedMessage\022,\n\004t" +
3926       "ype\030\001 \001(\0162\036.openxc.TranslatedMessage.Typ" +
3927       "e\022\014\n\004name\030\002 \001(\t\022\024\n\014string_value\030\003 \001(\t\022\025\n" +
3928       "\rnumeric_value\030\004 \001(\001\022\025\n\rboolean_value\030\005 " +
3929       "\001(\010\022\024\n\014string_event\030\006 \001(\t\022\025\n\rnumeric_eve" +
3930       "nt\030\007 \001(\001\022\025\n\rboolean_event\030\010 \001(\010\"\\\n\004Type\022" +
3931       "\n\n\006STRING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTE" +
3932       "D_STRING\020\004\022\017\n\013EVENTED_NUM\020\005\022\020\n\014EVENTED_B",
3933       "OOL\020\006B\034\n\ncom.openxcB\016BinaryMessages"
3934     };
3935     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
3936       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
3937         public com.google.protobuf.ExtensionRegistry assignDescriptors(
3938             com.google.protobuf.Descriptors.FileDescriptor root) {
3939           descriptor = root;
3940           internal_static_openxc_VehicleMessage_descriptor =
3941             getDescriptor().getMessageTypes().get(0);
3942           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
3943             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3944               internal_static_openxc_VehicleMessage_descriptor,
3945               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticMessage", });
3946           internal_static_openxc_RawMessage_descriptor =
3947             getDescriptor().getMessageTypes().get(1);
3948           internal_static_openxc_RawMessage_fieldAccessorTable = new
3949             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3950               internal_static_openxc_RawMessage_descriptor,
3951               new java.lang.String[] { "Bus", "MessageId", "Data", });
3952           internal_static_openxc_DiagnosticMessage_descriptor =
3953             getDescriptor().getMessageTypes().get(2);
3954           internal_static_openxc_DiagnosticMessage_fieldAccessorTable = new
3955             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3956               internal_static_openxc_DiagnosticMessage_descriptor,
3957               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", });
3958           internal_static_openxc_TranslatedMessage_descriptor =
3959             getDescriptor().getMessageTypes().get(3);
3960           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
3961             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3962               internal_static_openxc_TranslatedMessage_descriptor,
3963               new java.lang.String[] { "Type", "Name", "StringValue", "NumericValue", "BooleanValue", "StringEvent", "NumericEvent", "BooleanEvent", });
3964           return null;
3965         }
3966       };
3967     com.google.protobuf.Descriptors.FileDescriptor
3968       .internalBuildGeneratedFileFrom(descriptorData,
3969         new com.google.protobuf.Descriptors.FileDescriptor[] {
3970         }, assigner);
3971   }
3972
3973   // @@protoc_insertion_point(outer_class_scope)
3974 }