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 uint64 data = 3;
1107     /**
1108      * <code>optional uint64 data = 3;</code>
1109      */
1110     boolean hasData();
1111     /**
1112      * <code>optional uint64 data = 3;</code>
1113      */
1114     long 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 24: {
1178               bitField0_ |= 0x00000004;
1179               data_ = input.readUInt64();
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 uint64 data = 3;
1255     public static final int DATA_FIELD_NUMBER = 3;
1256     private long data_;
1257     /**
1258      * <code>optional uint64 data = 3;</code>
1259      */
1260     public boolean hasData() {
1261       return ((bitField0_ & 0x00000004) == 0x00000004);
1262     }
1263     /**
1264      * <code>optional uint64 data = 3;</code>
1265      */
1266     public long getData() {
1267       return data_;
1268     }
1269
1270     private void initFields() {
1271       bus_ = 0;
1272       messageId_ = 0;
1273       data_ = 0L;
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.writeUInt64(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           .computeUInt64Size(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_ = 0L;
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 uint64 data = 3;
1598       private long data_ ;
1599       /**
1600        * <code>optional uint64 data = 3;</code>
1601        */
1602       public boolean hasData() {
1603         return ((bitField0_ & 0x00000004) == 0x00000004);
1604       }
1605       /**
1606        * <code>optional uint64 data = 3;</code>
1607        */
1608       public long getData() {
1609         return data_;
1610       }
1611       /**
1612        * <code>optional uint64 data = 3;</code>
1613        */
1614       public Builder setData(long value) {
1615         bitField0_ |= 0x00000004;
1616         data_ = value;
1617         onChanged();
1618         return this;
1619       }
1620       /**
1621        * <code>optional uint64 data = 3;</code>
1622        */
1623       public Builder clearData() {
1624         bitField0_ = (bitField0_ & ~0x00000004);
1625         data_ = 0L;
1626         onChanged();
1627         return this;
1628       }
1629
1630       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
1631     }
1632
1633     static {
1634       defaultInstance = new RawMessage(true);
1635       defaultInstance.initFields();
1636     }
1637
1638     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
1639   }
1640
1641   public interface DiagnosticMessageOrBuilder
1642       extends com.google.protobuf.MessageOrBuilder {
1643
1644     // optional int32 bus = 1;
1645     /**
1646      * <code>optional int32 bus = 1;</code>
1647      */
1648     boolean hasBus();
1649     /**
1650      * <code>optional int32 bus = 1;</code>
1651      */
1652     int getBus();
1653
1654     // optional uint32 message_id = 2;
1655     /**
1656      * <code>optional uint32 message_id = 2;</code>
1657      */
1658     boolean hasMessageId();
1659     /**
1660      * <code>optional uint32 message_id = 2;</code>
1661      */
1662     int getMessageId();
1663
1664     // optional uint32 mode = 3;
1665     /**
1666      * <code>optional uint32 mode = 3;</code>
1667      */
1668     boolean hasMode();
1669     /**
1670      * <code>optional uint32 mode = 3;</code>
1671      */
1672     int getMode();
1673
1674     // optional uint32 pid = 4;
1675     /**
1676      * <code>optional uint32 pid = 4;</code>
1677      */
1678     boolean hasPid();
1679     /**
1680      * <code>optional uint32 pid = 4;</code>
1681      */
1682     int getPid();
1683
1684     // optional bool success = 5;
1685     /**
1686      * <code>optional bool success = 5;</code>
1687      */
1688     boolean hasSuccess();
1689     /**
1690      * <code>optional bool success = 5;</code>
1691      */
1692     boolean getSuccess();
1693
1694     // optional uint32 negative_response_code = 6;
1695     /**
1696      * <code>optional uint32 negative_response_code = 6;</code>
1697      */
1698     boolean hasNegativeResponseCode();
1699     /**
1700      * <code>optional uint32 negative_response_code = 6;</code>
1701      */
1702     int getNegativeResponseCode();
1703
1704     // optional bytes payload = 7;
1705     /**
1706      * <code>optional bytes payload = 7;</code>
1707      *
1708      * <pre>
1709      * TODO we are capping this at 8 bytes for now - need to change when we
1710      * support multi-frame responses
1711      * </pre>
1712      */
1713     boolean hasPayload();
1714     /**
1715      * <code>optional bytes payload = 7;</code>
1716      *
1717      * <pre>
1718      * TODO we are capping this at 8 bytes for now - need to change when we
1719      * support multi-frame responses
1720      * </pre>
1721      */
1722     com.google.protobuf.ByteString getPayload();
1723   }
1724   /**
1725    * Protobuf type {@code openxc.DiagnosticMessage}
1726    */
1727   public static final class DiagnosticMessage extends
1728       com.google.protobuf.GeneratedMessage
1729       implements DiagnosticMessageOrBuilder {
1730     // Use DiagnosticMessage.newBuilder() to construct.
1731     private DiagnosticMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1732       super(builder);
1733       this.unknownFields = builder.getUnknownFields();
1734     }
1735     private DiagnosticMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1736
1737     private static final DiagnosticMessage defaultInstance;
1738     public static DiagnosticMessage getDefaultInstance() {
1739       return defaultInstance;
1740     }
1741
1742     public DiagnosticMessage getDefaultInstanceForType() {
1743       return defaultInstance;
1744     }
1745
1746     private final com.google.protobuf.UnknownFieldSet unknownFields;
1747     @java.lang.Override
1748     public final com.google.protobuf.UnknownFieldSet
1749         getUnknownFields() {
1750       return this.unknownFields;
1751     }
1752     private DiagnosticMessage(
1753         com.google.protobuf.CodedInputStream input,
1754         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1755         throws com.google.protobuf.InvalidProtocolBufferException {
1756       initFields();
1757       int mutable_bitField0_ = 0;
1758       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1759           com.google.protobuf.UnknownFieldSet.newBuilder();
1760       try {
1761         boolean done = false;
1762         while (!done) {
1763           int tag = input.readTag();
1764           switch (tag) {
1765             case 0:
1766               done = true;
1767               break;
1768             default: {
1769               if (!parseUnknownField(input, unknownFields,
1770                                      extensionRegistry, tag)) {
1771                 done = true;
1772               }
1773               break;
1774             }
1775             case 8: {
1776               bitField0_ |= 0x00000001;
1777               bus_ = input.readInt32();
1778               break;
1779             }
1780             case 16: {
1781               bitField0_ |= 0x00000002;
1782               messageId_ = input.readUInt32();
1783               break;
1784             }
1785             case 24: {
1786               bitField0_ |= 0x00000004;
1787               mode_ = input.readUInt32();
1788               break;
1789             }
1790             case 32: {
1791               bitField0_ |= 0x00000008;
1792               pid_ = input.readUInt32();
1793               break;
1794             }
1795             case 40: {
1796               bitField0_ |= 0x00000010;
1797               success_ = input.readBool();
1798               break;
1799             }
1800             case 48: {
1801               bitField0_ |= 0x00000020;
1802               negativeResponseCode_ = input.readUInt32();
1803               break;
1804             }
1805             case 58: {
1806               bitField0_ |= 0x00000040;
1807               payload_ = input.readBytes();
1808               break;
1809             }
1810           }
1811         }
1812       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1813         throw e.setUnfinishedMessage(this);
1814       } catch (java.io.IOException e) {
1815         throw new com.google.protobuf.InvalidProtocolBufferException(
1816             e.getMessage()).setUnfinishedMessage(this);
1817       } finally {
1818         this.unknownFields = unknownFields.build();
1819         makeExtensionsImmutable();
1820       }
1821     }
1822     public static final com.google.protobuf.Descriptors.Descriptor
1823         getDescriptor() {
1824       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_descriptor;
1825     }
1826
1827     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1828         internalGetFieldAccessorTable() {
1829       return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_fieldAccessorTable
1830           .ensureFieldAccessorsInitialized(
1831               com.openxc.BinaryMessages.DiagnosticMessage.class, com.openxc.BinaryMessages.DiagnosticMessage.Builder.class);
1832     }
1833
1834     public static com.google.protobuf.Parser<DiagnosticMessage> PARSER =
1835         new com.google.protobuf.AbstractParser<DiagnosticMessage>() {
1836       public DiagnosticMessage parsePartialFrom(
1837           com.google.protobuf.CodedInputStream input,
1838           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1839           throws com.google.protobuf.InvalidProtocolBufferException {
1840         return new DiagnosticMessage(input, extensionRegistry);
1841       }
1842     };
1843
1844     @java.lang.Override
1845     public com.google.protobuf.Parser<DiagnosticMessage> getParserForType() {
1846       return PARSER;
1847     }
1848
1849     private int bitField0_;
1850     // optional int32 bus = 1;
1851     public static final int BUS_FIELD_NUMBER = 1;
1852     private int bus_;
1853     /**
1854      * <code>optional int32 bus = 1;</code>
1855      */
1856     public boolean hasBus() {
1857       return ((bitField0_ & 0x00000001) == 0x00000001);
1858     }
1859     /**
1860      * <code>optional int32 bus = 1;</code>
1861      */
1862     public int getBus() {
1863       return bus_;
1864     }
1865
1866     // optional uint32 message_id = 2;
1867     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1868     private int messageId_;
1869     /**
1870      * <code>optional uint32 message_id = 2;</code>
1871      */
1872     public boolean hasMessageId() {
1873       return ((bitField0_ & 0x00000002) == 0x00000002);
1874     }
1875     /**
1876      * <code>optional uint32 message_id = 2;</code>
1877      */
1878     public int getMessageId() {
1879       return messageId_;
1880     }
1881
1882     // optional uint32 mode = 3;
1883     public static final int MODE_FIELD_NUMBER = 3;
1884     private int mode_;
1885     /**
1886      * <code>optional uint32 mode = 3;</code>
1887      */
1888     public boolean hasMode() {
1889       return ((bitField0_ & 0x00000004) == 0x00000004);
1890     }
1891     /**
1892      * <code>optional uint32 mode = 3;</code>
1893      */
1894     public int getMode() {
1895       return mode_;
1896     }
1897
1898     // optional uint32 pid = 4;
1899     public static final int PID_FIELD_NUMBER = 4;
1900     private int pid_;
1901     /**
1902      * <code>optional uint32 pid = 4;</code>
1903      */
1904     public boolean hasPid() {
1905       return ((bitField0_ & 0x00000008) == 0x00000008);
1906     }
1907     /**
1908      * <code>optional uint32 pid = 4;</code>
1909      */
1910     public int getPid() {
1911       return pid_;
1912     }
1913
1914     // optional bool success = 5;
1915     public static final int SUCCESS_FIELD_NUMBER = 5;
1916     private boolean success_;
1917     /**
1918      * <code>optional bool success = 5;</code>
1919      */
1920     public boolean hasSuccess() {
1921       return ((bitField0_ & 0x00000010) == 0x00000010);
1922     }
1923     /**
1924      * <code>optional bool success = 5;</code>
1925      */
1926     public boolean getSuccess() {
1927       return success_;
1928     }
1929
1930     // optional uint32 negative_response_code = 6;
1931     public static final int NEGATIVE_RESPONSE_CODE_FIELD_NUMBER = 6;
1932     private int negativeResponseCode_;
1933     /**
1934      * <code>optional uint32 negative_response_code = 6;</code>
1935      */
1936     public boolean hasNegativeResponseCode() {
1937       return ((bitField0_ & 0x00000020) == 0x00000020);
1938     }
1939     /**
1940      * <code>optional uint32 negative_response_code = 6;</code>
1941      */
1942     public int getNegativeResponseCode() {
1943       return negativeResponseCode_;
1944     }
1945
1946     // optional bytes payload = 7;
1947     public static final int PAYLOAD_FIELD_NUMBER = 7;
1948     private com.google.protobuf.ByteString payload_;
1949     /**
1950      * <code>optional bytes payload = 7;</code>
1951      *
1952      * <pre>
1953      * TODO we are capping this at 8 bytes for now - need to change when we
1954      * support multi-frame responses
1955      * </pre>
1956      */
1957     public boolean hasPayload() {
1958       return ((bitField0_ & 0x00000040) == 0x00000040);
1959     }
1960     /**
1961      * <code>optional bytes payload = 7;</code>
1962      *
1963      * <pre>
1964      * TODO we are capping this at 8 bytes for now - need to change when we
1965      * support multi-frame responses
1966      * </pre>
1967      */
1968     public com.google.protobuf.ByteString getPayload() {
1969       return payload_;
1970     }
1971
1972     private void initFields() {
1973       bus_ = 0;
1974       messageId_ = 0;
1975       mode_ = 0;
1976       pid_ = 0;
1977       success_ = false;
1978       negativeResponseCode_ = 0;
1979       payload_ = com.google.protobuf.ByteString.EMPTY;
1980     }
1981     private byte memoizedIsInitialized = -1;
1982     public final boolean isInitialized() {
1983       byte isInitialized = memoizedIsInitialized;
1984       if (isInitialized != -1) return isInitialized == 1;
1985
1986       memoizedIsInitialized = 1;
1987       return true;
1988     }
1989
1990     public void writeTo(com.google.protobuf.CodedOutputStream output)
1991                         throws java.io.IOException {
1992       getSerializedSize();
1993       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1994         output.writeInt32(1, bus_);
1995       }
1996       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1997         output.writeUInt32(2, messageId_);
1998       }
1999       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2000         output.writeUInt32(3, mode_);
2001       }
2002       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2003         output.writeUInt32(4, pid_);
2004       }
2005       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2006         output.writeBool(5, success_);
2007       }
2008       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2009         output.writeUInt32(6, negativeResponseCode_);
2010       }
2011       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2012         output.writeBytes(7, payload_);
2013       }
2014       getUnknownFields().writeTo(output);
2015     }
2016
2017     private int memoizedSerializedSize = -1;
2018     public int getSerializedSize() {
2019       int size = memoizedSerializedSize;
2020       if (size != -1) return size;
2021
2022       size = 0;
2023       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2024         size += com.google.protobuf.CodedOutputStream
2025           .computeInt32Size(1, bus_);
2026       }
2027       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2028         size += com.google.protobuf.CodedOutputStream
2029           .computeUInt32Size(2, messageId_);
2030       }
2031       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2032         size += com.google.protobuf.CodedOutputStream
2033           .computeUInt32Size(3, mode_);
2034       }
2035       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2036         size += com.google.protobuf.CodedOutputStream
2037           .computeUInt32Size(4, pid_);
2038       }
2039       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2040         size += com.google.protobuf.CodedOutputStream
2041           .computeBoolSize(5, success_);
2042       }
2043       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2044         size += com.google.protobuf.CodedOutputStream
2045           .computeUInt32Size(6, negativeResponseCode_);
2046       }
2047       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2048         size += com.google.protobuf.CodedOutputStream
2049           .computeBytesSize(7, payload_);
2050       }
2051       size += getUnknownFields().getSerializedSize();
2052       memoizedSerializedSize = size;
2053       return size;
2054     }
2055
2056     private static final long serialVersionUID = 0L;
2057     @java.lang.Override
2058     protected java.lang.Object writeReplace()
2059         throws java.io.ObjectStreamException {
2060       return super.writeReplace();
2061     }
2062
2063     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2064         com.google.protobuf.ByteString data)
2065         throws com.google.protobuf.InvalidProtocolBufferException {
2066       return PARSER.parseFrom(data);
2067     }
2068     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2069         com.google.protobuf.ByteString data,
2070         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2071         throws com.google.protobuf.InvalidProtocolBufferException {
2072       return PARSER.parseFrom(data, extensionRegistry);
2073     }
2074     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(byte[] data)
2075         throws com.google.protobuf.InvalidProtocolBufferException {
2076       return PARSER.parseFrom(data);
2077     }
2078     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2079         byte[] data,
2080         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2081         throws com.google.protobuf.InvalidProtocolBufferException {
2082       return PARSER.parseFrom(data, extensionRegistry);
2083     }
2084     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(java.io.InputStream input)
2085         throws java.io.IOException {
2086       return PARSER.parseFrom(input);
2087     }
2088     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2089         java.io.InputStream input,
2090         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2091         throws java.io.IOException {
2092       return PARSER.parseFrom(input, extensionRegistry);
2093     }
2094     public static com.openxc.BinaryMessages.DiagnosticMessage parseDelimitedFrom(java.io.InputStream input)
2095         throws java.io.IOException {
2096       return PARSER.parseDelimitedFrom(input);
2097     }
2098     public static com.openxc.BinaryMessages.DiagnosticMessage parseDelimitedFrom(
2099         java.io.InputStream input,
2100         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2101         throws java.io.IOException {
2102       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2103     }
2104     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2105         com.google.protobuf.CodedInputStream input)
2106         throws java.io.IOException {
2107       return PARSER.parseFrom(input);
2108     }
2109     public static com.openxc.BinaryMessages.DiagnosticMessage parseFrom(
2110         com.google.protobuf.CodedInputStream input,
2111         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2112         throws java.io.IOException {
2113       return PARSER.parseFrom(input, extensionRegistry);
2114     }
2115
2116     public static Builder newBuilder() { return Builder.create(); }
2117     public Builder newBuilderForType() { return newBuilder(); }
2118     public static Builder newBuilder(com.openxc.BinaryMessages.DiagnosticMessage prototype) {
2119       return newBuilder().mergeFrom(prototype);
2120     }
2121     public Builder toBuilder() { return newBuilder(this); }
2122
2123     @java.lang.Override
2124     protected Builder newBuilderForType(
2125         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2126       Builder builder = new Builder(parent);
2127       return builder;
2128     }
2129     /**
2130      * Protobuf type {@code openxc.DiagnosticMessage}
2131      */
2132     public static final class Builder extends
2133         com.google.protobuf.GeneratedMessage.Builder<Builder>
2134        implements com.openxc.BinaryMessages.DiagnosticMessageOrBuilder {
2135       public static final com.google.protobuf.Descriptors.Descriptor
2136           getDescriptor() {
2137         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_descriptor;
2138       }
2139
2140       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2141           internalGetFieldAccessorTable() {
2142         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_fieldAccessorTable
2143             .ensureFieldAccessorsInitialized(
2144                 com.openxc.BinaryMessages.DiagnosticMessage.class, com.openxc.BinaryMessages.DiagnosticMessage.Builder.class);
2145       }
2146
2147       // Construct using com.openxc.BinaryMessages.DiagnosticMessage.newBuilder()
2148       private Builder() {
2149         maybeForceBuilderInitialization();
2150       }
2151
2152       private Builder(
2153           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2154         super(parent);
2155         maybeForceBuilderInitialization();
2156       }
2157       private void maybeForceBuilderInitialization() {
2158         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2159         }
2160       }
2161       private static Builder create() {
2162         return new Builder();
2163       }
2164
2165       public Builder clear() {
2166         super.clear();
2167         bus_ = 0;
2168         bitField0_ = (bitField0_ & ~0x00000001);
2169         messageId_ = 0;
2170         bitField0_ = (bitField0_ & ~0x00000002);
2171         mode_ = 0;
2172         bitField0_ = (bitField0_ & ~0x00000004);
2173         pid_ = 0;
2174         bitField0_ = (bitField0_ & ~0x00000008);
2175         success_ = false;
2176         bitField0_ = (bitField0_ & ~0x00000010);
2177         negativeResponseCode_ = 0;
2178         bitField0_ = (bitField0_ & ~0x00000020);
2179         payload_ = com.google.protobuf.ByteString.EMPTY;
2180         bitField0_ = (bitField0_ & ~0x00000040);
2181         return this;
2182       }
2183
2184       public Builder clone() {
2185         return create().mergeFrom(buildPartial());
2186       }
2187
2188       public com.google.protobuf.Descriptors.Descriptor
2189           getDescriptorForType() {
2190         return com.openxc.BinaryMessages.internal_static_openxc_DiagnosticMessage_descriptor;
2191       }
2192
2193       public com.openxc.BinaryMessages.DiagnosticMessage getDefaultInstanceForType() {
2194         return com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance();
2195       }
2196
2197       public com.openxc.BinaryMessages.DiagnosticMessage build() {
2198         com.openxc.BinaryMessages.DiagnosticMessage result = buildPartial();
2199         if (!result.isInitialized()) {
2200           throw newUninitializedMessageException(result);
2201         }
2202         return result;
2203       }
2204
2205       public com.openxc.BinaryMessages.DiagnosticMessage buildPartial() {
2206         com.openxc.BinaryMessages.DiagnosticMessage result = new com.openxc.BinaryMessages.DiagnosticMessage(this);
2207         int from_bitField0_ = bitField0_;
2208         int to_bitField0_ = 0;
2209         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2210           to_bitField0_ |= 0x00000001;
2211         }
2212         result.bus_ = bus_;
2213         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2214           to_bitField0_ |= 0x00000002;
2215         }
2216         result.messageId_ = messageId_;
2217         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2218           to_bitField0_ |= 0x00000004;
2219         }
2220         result.mode_ = mode_;
2221         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2222           to_bitField0_ |= 0x00000008;
2223         }
2224         result.pid_ = pid_;
2225         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2226           to_bitField0_ |= 0x00000010;
2227         }
2228         result.success_ = success_;
2229         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2230           to_bitField0_ |= 0x00000020;
2231         }
2232         result.negativeResponseCode_ = negativeResponseCode_;
2233         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2234           to_bitField0_ |= 0x00000040;
2235         }
2236         result.payload_ = payload_;
2237         result.bitField0_ = to_bitField0_;
2238         onBuilt();
2239         return result;
2240       }
2241
2242       public Builder mergeFrom(com.google.protobuf.Message other) {
2243         if (other instanceof com.openxc.BinaryMessages.DiagnosticMessage) {
2244           return mergeFrom((com.openxc.BinaryMessages.DiagnosticMessage)other);
2245         } else {
2246           super.mergeFrom(other);
2247           return this;
2248         }
2249       }
2250
2251       public Builder mergeFrom(com.openxc.BinaryMessages.DiagnosticMessage other) {
2252         if (other == com.openxc.BinaryMessages.DiagnosticMessage.getDefaultInstance()) return this;
2253         if (other.hasBus()) {
2254           setBus(other.getBus());
2255         }
2256         if (other.hasMessageId()) {
2257           setMessageId(other.getMessageId());
2258         }
2259         if (other.hasMode()) {
2260           setMode(other.getMode());
2261         }
2262         if (other.hasPid()) {
2263           setPid(other.getPid());
2264         }
2265         if (other.hasSuccess()) {
2266           setSuccess(other.getSuccess());
2267         }
2268         if (other.hasNegativeResponseCode()) {
2269           setNegativeResponseCode(other.getNegativeResponseCode());
2270         }
2271         if (other.hasPayload()) {
2272           setPayload(other.getPayload());
2273         }
2274         this.mergeUnknownFields(other.getUnknownFields());
2275         return this;
2276       }
2277
2278       public final boolean isInitialized() {
2279         return true;
2280       }
2281
2282       public Builder mergeFrom(
2283           com.google.protobuf.CodedInputStream input,
2284           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2285           throws java.io.IOException {
2286         com.openxc.BinaryMessages.DiagnosticMessage parsedMessage = null;
2287         try {
2288           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2289         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2290           parsedMessage = (com.openxc.BinaryMessages.DiagnosticMessage) e.getUnfinishedMessage();
2291           throw e;
2292         } finally {
2293           if (parsedMessage != null) {
2294             mergeFrom(parsedMessage);
2295           }
2296         }
2297         return this;
2298       }
2299       private int bitField0_;
2300
2301       // optional int32 bus = 1;
2302       private int bus_ ;
2303       /**
2304        * <code>optional int32 bus = 1;</code>
2305        */
2306       public boolean hasBus() {
2307         return ((bitField0_ & 0x00000001) == 0x00000001);
2308       }
2309       /**
2310        * <code>optional int32 bus = 1;</code>
2311        */
2312       public int getBus() {
2313         return bus_;
2314       }
2315       /**
2316        * <code>optional int32 bus = 1;</code>
2317        */
2318       public Builder setBus(int value) {
2319         bitField0_ |= 0x00000001;
2320         bus_ = value;
2321         onChanged();
2322         return this;
2323       }
2324       /**
2325        * <code>optional int32 bus = 1;</code>
2326        */
2327       public Builder clearBus() {
2328         bitField0_ = (bitField0_ & ~0x00000001);
2329         bus_ = 0;
2330         onChanged();
2331         return this;
2332       }
2333
2334       // optional uint32 message_id = 2;
2335       private int messageId_ ;
2336       /**
2337        * <code>optional uint32 message_id = 2;</code>
2338        */
2339       public boolean hasMessageId() {
2340         return ((bitField0_ & 0x00000002) == 0x00000002);
2341       }
2342       /**
2343        * <code>optional uint32 message_id = 2;</code>
2344        */
2345       public int getMessageId() {
2346         return messageId_;
2347       }
2348       /**
2349        * <code>optional uint32 message_id = 2;</code>
2350        */
2351       public Builder setMessageId(int value) {
2352         bitField0_ |= 0x00000002;
2353         messageId_ = value;
2354         onChanged();
2355         return this;
2356       }
2357       /**
2358        * <code>optional uint32 message_id = 2;</code>
2359        */
2360       public Builder clearMessageId() {
2361         bitField0_ = (bitField0_ & ~0x00000002);
2362         messageId_ = 0;
2363         onChanged();
2364         return this;
2365       }
2366
2367       // optional uint32 mode = 3;
2368       private int mode_ ;
2369       /**
2370        * <code>optional uint32 mode = 3;</code>
2371        */
2372       public boolean hasMode() {
2373         return ((bitField0_ & 0x00000004) == 0x00000004);
2374       }
2375       /**
2376        * <code>optional uint32 mode = 3;</code>
2377        */
2378       public int getMode() {
2379         return mode_;
2380       }
2381       /**
2382        * <code>optional uint32 mode = 3;</code>
2383        */
2384       public Builder setMode(int value) {
2385         bitField0_ |= 0x00000004;
2386         mode_ = value;
2387         onChanged();
2388         return this;
2389       }
2390       /**
2391        * <code>optional uint32 mode = 3;</code>
2392        */
2393       public Builder clearMode() {
2394         bitField0_ = (bitField0_ & ~0x00000004);
2395         mode_ = 0;
2396         onChanged();
2397         return this;
2398       }
2399
2400       // optional uint32 pid = 4;
2401       private int pid_ ;
2402       /**
2403        * <code>optional uint32 pid = 4;</code>
2404        */
2405       public boolean hasPid() {
2406         return ((bitField0_ & 0x00000008) == 0x00000008);
2407       }
2408       /**
2409        * <code>optional uint32 pid = 4;</code>
2410        */
2411       public int getPid() {
2412         return pid_;
2413       }
2414       /**
2415        * <code>optional uint32 pid = 4;</code>
2416        */
2417       public Builder setPid(int value) {
2418         bitField0_ |= 0x00000008;
2419         pid_ = value;
2420         onChanged();
2421         return this;
2422       }
2423       /**
2424        * <code>optional uint32 pid = 4;</code>
2425        */
2426       public Builder clearPid() {
2427         bitField0_ = (bitField0_ & ~0x00000008);
2428         pid_ = 0;
2429         onChanged();
2430         return this;
2431       }
2432
2433       // optional bool success = 5;
2434       private boolean success_ ;
2435       /**
2436        * <code>optional bool success = 5;</code>
2437        */
2438       public boolean hasSuccess() {
2439         return ((bitField0_ & 0x00000010) == 0x00000010);
2440       }
2441       /**
2442        * <code>optional bool success = 5;</code>
2443        */
2444       public boolean getSuccess() {
2445         return success_;
2446       }
2447       /**
2448        * <code>optional bool success = 5;</code>
2449        */
2450       public Builder setSuccess(boolean value) {
2451         bitField0_ |= 0x00000010;
2452         success_ = value;
2453         onChanged();
2454         return this;
2455       }
2456       /**
2457        * <code>optional bool success = 5;</code>
2458        */
2459       public Builder clearSuccess() {
2460         bitField0_ = (bitField0_ & ~0x00000010);
2461         success_ = false;
2462         onChanged();
2463         return this;
2464       }
2465
2466       // optional uint32 negative_response_code = 6;
2467       private int negativeResponseCode_ ;
2468       /**
2469        * <code>optional uint32 negative_response_code = 6;</code>
2470        */
2471       public boolean hasNegativeResponseCode() {
2472         return ((bitField0_ & 0x00000020) == 0x00000020);
2473       }
2474       /**
2475        * <code>optional uint32 negative_response_code = 6;</code>
2476        */
2477       public int getNegativeResponseCode() {
2478         return negativeResponseCode_;
2479       }
2480       /**
2481        * <code>optional uint32 negative_response_code = 6;</code>
2482        */
2483       public Builder setNegativeResponseCode(int value) {
2484         bitField0_ |= 0x00000020;
2485         negativeResponseCode_ = value;
2486         onChanged();
2487         return this;
2488       }
2489       /**
2490        * <code>optional uint32 negative_response_code = 6;</code>
2491        */
2492       public Builder clearNegativeResponseCode() {
2493         bitField0_ = (bitField0_ & ~0x00000020);
2494         negativeResponseCode_ = 0;
2495         onChanged();
2496         return this;
2497       }
2498
2499       // optional bytes payload = 7;
2500       private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY;
2501       /**
2502        * <code>optional bytes payload = 7;</code>
2503        *
2504        * <pre>
2505        * TODO we are capping this at 8 bytes for now - need to change when we
2506        * support multi-frame responses
2507        * </pre>
2508        */
2509       public boolean hasPayload() {
2510         return ((bitField0_ & 0x00000040) == 0x00000040);
2511       }
2512       /**
2513        * <code>optional bytes payload = 7;</code>
2514        *
2515        * <pre>
2516        * TODO we are capping this at 8 bytes for now - need to change when we
2517        * support multi-frame responses
2518        * </pre>
2519        */
2520       public com.google.protobuf.ByteString getPayload() {
2521         return payload_;
2522       }
2523       /**
2524        * <code>optional bytes payload = 7;</code>
2525        *
2526        * <pre>
2527        * TODO we are capping this at 8 bytes for now - need to change when we
2528        * support multi-frame responses
2529        * </pre>
2530        */
2531       public Builder setPayload(com.google.protobuf.ByteString value) {
2532         if (value == null) {
2533     throw new NullPointerException();
2534   }
2535   bitField0_ |= 0x00000040;
2536         payload_ = value;
2537         onChanged();
2538         return this;
2539       }
2540       /**
2541        * <code>optional bytes payload = 7;</code>
2542        *
2543        * <pre>
2544        * TODO we are capping this at 8 bytes for now - need to change when we
2545        * support multi-frame responses
2546        * </pre>
2547        */
2548       public Builder clearPayload() {
2549         bitField0_ = (bitField0_ & ~0x00000040);
2550         payload_ = getDefaultInstance().getPayload();
2551         onChanged();
2552         return this;
2553       }
2554
2555       // @@protoc_insertion_point(builder_scope:openxc.DiagnosticMessage)
2556     }
2557
2558     static {
2559       defaultInstance = new DiagnosticMessage(true);
2560       defaultInstance.initFields();
2561     }
2562
2563     // @@protoc_insertion_point(class_scope:openxc.DiagnosticMessage)
2564   }
2565
2566   public interface TranslatedMessageOrBuilder
2567       extends com.google.protobuf.MessageOrBuilder {
2568
2569     // optional .openxc.TranslatedMessage.Type type = 1;
2570     /**
2571      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2572      */
2573     boolean hasType();
2574     /**
2575      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2576      */
2577     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
2578
2579     // optional string name = 2;
2580     /**
2581      * <code>optional string name = 2;</code>
2582      */
2583     boolean hasName();
2584     /**
2585      * <code>optional string name = 2;</code>
2586      */
2587     java.lang.String getName();
2588     /**
2589      * <code>optional string name = 2;</code>
2590      */
2591     com.google.protobuf.ByteString
2592         getNameBytes();
2593
2594     // optional string string_value = 3;
2595     /**
2596      * <code>optional string string_value = 3;</code>
2597      */
2598     boolean hasStringValue();
2599     /**
2600      * <code>optional string string_value = 3;</code>
2601      */
2602     java.lang.String getStringValue();
2603     /**
2604      * <code>optional string string_value = 3;</code>
2605      */
2606     com.google.protobuf.ByteString
2607         getStringValueBytes();
2608
2609     // optional double numeric_value = 4;
2610     /**
2611      * <code>optional double numeric_value = 4;</code>
2612      */
2613     boolean hasNumericValue();
2614     /**
2615      * <code>optional double numeric_value = 4;</code>
2616      */
2617     double getNumericValue();
2618
2619     // optional bool boolean_value = 5;
2620     /**
2621      * <code>optional bool boolean_value = 5;</code>
2622      */
2623     boolean hasBooleanValue();
2624     /**
2625      * <code>optional bool boolean_value = 5;</code>
2626      */
2627     boolean getBooleanValue();
2628
2629     // optional string string_event = 6;
2630     /**
2631      * <code>optional string string_event = 6;</code>
2632      */
2633     boolean hasStringEvent();
2634     /**
2635      * <code>optional string string_event = 6;</code>
2636      */
2637     java.lang.String getStringEvent();
2638     /**
2639      * <code>optional string string_event = 6;</code>
2640      */
2641     com.google.protobuf.ByteString
2642         getStringEventBytes();
2643
2644     // optional double numeric_event = 7;
2645     /**
2646      * <code>optional double numeric_event = 7;</code>
2647      */
2648     boolean hasNumericEvent();
2649     /**
2650      * <code>optional double numeric_event = 7;</code>
2651      */
2652     double getNumericEvent();
2653
2654     // optional bool boolean_event = 8;
2655     /**
2656      * <code>optional bool boolean_event = 8;</code>
2657      */
2658     boolean hasBooleanEvent();
2659     /**
2660      * <code>optional bool boolean_event = 8;</code>
2661      */
2662     boolean getBooleanEvent();
2663   }
2664   /**
2665    * Protobuf type {@code openxc.TranslatedMessage}
2666    */
2667   public static final class TranslatedMessage extends
2668       com.google.protobuf.GeneratedMessage
2669       implements TranslatedMessageOrBuilder {
2670     // Use TranslatedMessage.newBuilder() to construct.
2671     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2672       super(builder);
2673       this.unknownFields = builder.getUnknownFields();
2674     }
2675     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2676
2677     private static final TranslatedMessage defaultInstance;
2678     public static TranslatedMessage getDefaultInstance() {
2679       return defaultInstance;
2680     }
2681
2682     public TranslatedMessage getDefaultInstanceForType() {
2683       return defaultInstance;
2684     }
2685
2686     private final com.google.protobuf.UnknownFieldSet unknownFields;
2687     @java.lang.Override
2688     public final com.google.protobuf.UnknownFieldSet
2689         getUnknownFields() {
2690       return this.unknownFields;
2691     }
2692     private TranslatedMessage(
2693         com.google.protobuf.CodedInputStream input,
2694         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2695         throws com.google.protobuf.InvalidProtocolBufferException {
2696       initFields();
2697       int mutable_bitField0_ = 0;
2698       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2699           com.google.protobuf.UnknownFieldSet.newBuilder();
2700       try {
2701         boolean done = false;
2702         while (!done) {
2703           int tag = input.readTag();
2704           switch (tag) {
2705             case 0:
2706               done = true;
2707               break;
2708             default: {
2709               if (!parseUnknownField(input, unknownFields,
2710                                      extensionRegistry, tag)) {
2711                 done = true;
2712               }
2713               break;
2714             }
2715             case 8: {
2716               int rawValue = input.readEnum();
2717               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
2718               if (value == null) {
2719                 unknownFields.mergeVarintField(1, rawValue);
2720               } else {
2721                 bitField0_ |= 0x00000001;
2722                 type_ = value;
2723               }
2724               break;
2725             }
2726             case 18: {
2727               bitField0_ |= 0x00000002;
2728               name_ = input.readBytes();
2729               break;
2730             }
2731             case 26: {
2732               bitField0_ |= 0x00000004;
2733               stringValue_ = input.readBytes();
2734               break;
2735             }
2736             case 33: {
2737               bitField0_ |= 0x00000008;
2738               numericValue_ = input.readDouble();
2739               break;
2740             }
2741             case 40: {
2742               bitField0_ |= 0x00000010;
2743               booleanValue_ = input.readBool();
2744               break;
2745             }
2746             case 50: {
2747               bitField0_ |= 0x00000020;
2748               stringEvent_ = input.readBytes();
2749               break;
2750             }
2751             case 57: {
2752               bitField0_ |= 0x00000040;
2753               numericEvent_ = input.readDouble();
2754               break;
2755             }
2756             case 64: {
2757               bitField0_ |= 0x00000080;
2758               booleanEvent_ = input.readBool();
2759               break;
2760             }
2761           }
2762         }
2763       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2764         throw e.setUnfinishedMessage(this);
2765       } catch (java.io.IOException e) {
2766         throw new com.google.protobuf.InvalidProtocolBufferException(
2767             e.getMessage()).setUnfinishedMessage(this);
2768       } finally {
2769         this.unknownFields = unknownFields.build();
2770         makeExtensionsImmutable();
2771       }
2772     }
2773     public static final com.google.protobuf.Descriptors.Descriptor
2774         getDescriptor() {
2775       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
2776     }
2777
2778     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2779         internalGetFieldAccessorTable() {
2780       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
2781           .ensureFieldAccessorsInitialized(
2782               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
2783     }
2784
2785     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
2786         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
2787       public TranslatedMessage parsePartialFrom(
2788           com.google.protobuf.CodedInputStream input,
2789           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2790           throws com.google.protobuf.InvalidProtocolBufferException {
2791         return new TranslatedMessage(input, extensionRegistry);
2792       }
2793     };
2794
2795     @java.lang.Override
2796     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
2797       return PARSER;
2798     }
2799
2800     /**
2801      * Protobuf enum {@code openxc.TranslatedMessage.Type}
2802      */
2803     public enum Type
2804         implements com.google.protobuf.ProtocolMessageEnum {
2805       /**
2806        * <code>STRING = 1;</code>
2807        */
2808       STRING(0, 1),
2809       /**
2810        * <code>NUM = 2;</code>
2811        */
2812       NUM(1, 2),
2813       /**
2814        * <code>BOOL = 3;</code>
2815        */
2816       BOOL(2, 3),
2817       /**
2818        * <code>EVENTED_STRING = 4;</code>
2819        */
2820       EVENTED_STRING(3, 4),
2821       /**
2822        * <code>EVENTED_NUM = 5;</code>
2823        */
2824       EVENTED_NUM(4, 5),
2825       /**
2826        * <code>EVENTED_BOOL = 6;</code>
2827        */
2828       EVENTED_BOOL(5, 6),
2829       ;
2830
2831       /**
2832        * <code>STRING = 1;</code>
2833        */
2834       public static final int STRING_VALUE = 1;
2835       /**
2836        * <code>NUM = 2;</code>
2837        */
2838       public static final int NUM_VALUE = 2;
2839       /**
2840        * <code>BOOL = 3;</code>
2841        */
2842       public static final int BOOL_VALUE = 3;
2843       /**
2844        * <code>EVENTED_STRING = 4;</code>
2845        */
2846       public static final int EVENTED_STRING_VALUE = 4;
2847       /**
2848        * <code>EVENTED_NUM = 5;</code>
2849        */
2850       public static final int EVENTED_NUM_VALUE = 5;
2851       /**
2852        * <code>EVENTED_BOOL = 6;</code>
2853        */
2854       public static final int EVENTED_BOOL_VALUE = 6;
2855
2856
2857       public final int getNumber() { return value; }
2858
2859       public static Type valueOf(int value) {
2860         switch (value) {
2861           case 1: return STRING;
2862           case 2: return NUM;
2863           case 3: return BOOL;
2864           case 4: return EVENTED_STRING;
2865           case 5: return EVENTED_NUM;
2866           case 6: return EVENTED_BOOL;
2867           default: return null;
2868         }
2869       }
2870
2871       public static com.google.protobuf.Internal.EnumLiteMap<Type>
2872           internalGetValueMap() {
2873         return internalValueMap;
2874       }
2875       private static com.google.protobuf.Internal.EnumLiteMap<Type>
2876           internalValueMap =
2877             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
2878               public Type findValueByNumber(int number) {
2879                 return Type.valueOf(number);
2880               }
2881             };
2882
2883       public final com.google.protobuf.Descriptors.EnumValueDescriptor
2884           getValueDescriptor() {
2885         return getDescriptor().getValues().get(index);
2886       }
2887       public final com.google.protobuf.Descriptors.EnumDescriptor
2888           getDescriptorForType() {
2889         return getDescriptor();
2890       }
2891       public static final com.google.protobuf.Descriptors.EnumDescriptor
2892           getDescriptor() {
2893         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
2894       }
2895
2896       private static final Type[] VALUES = values();
2897
2898       public static Type valueOf(
2899           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
2900         if (desc.getType() != getDescriptor()) {
2901           throw new java.lang.IllegalArgumentException(
2902             "EnumValueDescriptor is not for this type.");
2903         }
2904         return VALUES[desc.getIndex()];
2905       }
2906
2907       private final int index;
2908       private final int value;
2909
2910       private Type(int index, int value) {
2911         this.index = index;
2912         this.value = value;
2913       }
2914
2915       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
2916     }
2917
2918     private int bitField0_;
2919     // optional .openxc.TranslatedMessage.Type type = 1;
2920     public static final int TYPE_FIELD_NUMBER = 1;
2921     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
2922     /**
2923      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2924      */
2925     public boolean hasType() {
2926       return ((bitField0_ & 0x00000001) == 0x00000001);
2927     }
2928     /**
2929      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2930      */
2931     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
2932       return type_;
2933     }
2934
2935     // optional string name = 2;
2936     public static final int NAME_FIELD_NUMBER = 2;
2937     private java.lang.Object name_;
2938     /**
2939      * <code>optional string name = 2;</code>
2940      */
2941     public boolean hasName() {
2942       return ((bitField0_ & 0x00000002) == 0x00000002);
2943     }
2944     /**
2945      * <code>optional string name = 2;</code>
2946      */
2947     public java.lang.String getName() {
2948       java.lang.Object ref = name_;
2949       if (ref instanceof java.lang.String) {
2950         return (java.lang.String) ref;
2951       } else {
2952         com.google.protobuf.ByteString bs =
2953             (com.google.protobuf.ByteString) ref;
2954         java.lang.String s = bs.toStringUtf8();
2955         if (bs.isValidUtf8()) {
2956           name_ = s;
2957         }
2958         return s;
2959       }
2960     }
2961     /**
2962      * <code>optional string name = 2;</code>
2963      */
2964     public com.google.protobuf.ByteString
2965         getNameBytes() {
2966       java.lang.Object ref = name_;
2967       if (ref instanceof java.lang.String) {
2968         com.google.protobuf.ByteString b =
2969             com.google.protobuf.ByteString.copyFromUtf8(
2970                 (java.lang.String) ref);
2971         name_ = b;
2972         return b;
2973       } else {
2974         return (com.google.protobuf.ByteString) ref;
2975       }
2976     }
2977
2978     // optional string string_value = 3;
2979     public static final int STRING_VALUE_FIELD_NUMBER = 3;
2980     private java.lang.Object stringValue_;
2981     /**
2982      * <code>optional string string_value = 3;</code>
2983      */
2984     public boolean hasStringValue() {
2985       return ((bitField0_ & 0x00000004) == 0x00000004);
2986     }
2987     /**
2988      * <code>optional string string_value = 3;</code>
2989      */
2990     public java.lang.String getStringValue() {
2991       java.lang.Object ref = stringValue_;
2992       if (ref instanceof java.lang.String) {
2993         return (java.lang.String) ref;
2994       } else {
2995         com.google.protobuf.ByteString bs =
2996             (com.google.protobuf.ByteString) ref;
2997         java.lang.String s = bs.toStringUtf8();
2998         if (bs.isValidUtf8()) {
2999           stringValue_ = s;
3000         }
3001         return s;
3002       }
3003     }
3004     /**
3005      * <code>optional string string_value = 3;</code>
3006      */
3007     public com.google.protobuf.ByteString
3008         getStringValueBytes() {
3009       java.lang.Object ref = stringValue_;
3010       if (ref instanceof java.lang.String) {
3011         com.google.protobuf.ByteString b =
3012             com.google.protobuf.ByteString.copyFromUtf8(
3013                 (java.lang.String) ref);
3014         stringValue_ = b;
3015         return b;
3016       } else {
3017         return (com.google.protobuf.ByteString) ref;
3018       }
3019     }
3020
3021     // optional double numeric_value = 4;
3022     public static final int NUMERIC_VALUE_FIELD_NUMBER = 4;
3023     private double numericValue_;
3024     /**
3025      * <code>optional double numeric_value = 4;</code>
3026      */
3027     public boolean hasNumericValue() {
3028       return ((bitField0_ & 0x00000008) == 0x00000008);
3029     }
3030     /**
3031      * <code>optional double numeric_value = 4;</code>
3032      */
3033     public double getNumericValue() {
3034       return numericValue_;
3035     }
3036
3037     // optional bool boolean_value = 5;
3038     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 5;
3039     private boolean booleanValue_;
3040     /**
3041      * <code>optional bool boolean_value = 5;</code>
3042      */
3043     public boolean hasBooleanValue() {
3044       return ((bitField0_ & 0x00000010) == 0x00000010);
3045     }
3046     /**
3047      * <code>optional bool boolean_value = 5;</code>
3048      */
3049     public boolean getBooleanValue() {
3050       return booleanValue_;
3051     }
3052
3053     // optional string string_event = 6;
3054     public static final int STRING_EVENT_FIELD_NUMBER = 6;
3055     private java.lang.Object stringEvent_;
3056     /**
3057      * <code>optional string string_event = 6;</code>
3058      */
3059     public boolean hasStringEvent() {
3060       return ((bitField0_ & 0x00000020) == 0x00000020);
3061     }
3062     /**
3063      * <code>optional string string_event = 6;</code>
3064      */
3065     public java.lang.String getStringEvent() {
3066       java.lang.Object ref = stringEvent_;
3067       if (ref instanceof java.lang.String) {
3068         return (java.lang.String) ref;
3069       } else {
3070         com.google.protobuf.ByteString bs =
3071             (com.google.protobuf.ByteString) ref;
3072         java.lang.String s = bs.toStringUtf8();
3073         if (bs.isValidUtf8()) {
3074           stringEvent_ = s;
3075         }
3076         return s;
3077       }
3078     }
3079     /**
3080      * <code>optional string string_event = 6;</code>
3081      */
3082     public com.google.protobuf.ByteString
3083         getStringEventBytes() {
3084       java.lang.Object ref = stringEvent_;
3085       if (ref instanceof java.lang.String) {
3086         com.google.protobuf.ByteString b =
3087             com.google.protobuf.ByteString.copyFromUtf8(
3088                 (java.lang.String) ref);
3089         stringEvent_ = b;
3090         return b;
3091       } else {
3092         return (com.google.protobuf.ByteString) ref;
3093       }
3094     }
3095
3096     // optional double numeric_event = 7;
3097     public static final int NUMERIC_EVENT_FIELD_NUMBER = 7;
3098     private double numericEvent_;
3099     /**
3100      * <code>optional double numeric_event = 7;</code>
3101      */
3102     public boolean hasNumericEvent() {
3103       return ((bitField0_ & 0x00000040) == 0x00000040);
3104     }
3105     /**
3106      * <code>optional double numeric_event = 7;</code>
3107      */
3108     public double getNumericEvent() {
3109       return numericEvent_;
3110     }
3111
3112     // optional bool boolean_event = 8;
3113     public static final int BOOLEAN_EVENT_FIELD_NUMBER = 8;
3114     private boolean booleanEvent_;
3115     /**
3116      * <code>optional bool boolean_event = 8;</code>
3117      */
3118     public boolean hasBooleanEvent() {
3119       return ((bitField0_ & 0x00000080) == 0x00000080);
3120     }
3121     /**
3122      * <code>optional bool boolean_event = 8;</code>
3123      */
3124     public boolean getBooleanEvent() {
3125       return booleanEvent_;
3126     }
3127
3128     private void initFields() {
3129       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3130       name_ = "";
3131       stringValue_ = "";
3132       numericValue_ = 0D;
3133       booleanValue_ = false;
3134       stringEvent_ = "";
3135       numericEvent_ = 0D;
3136       booleanEvent_ = false;
3137     }
3138     private byte memoizedIsInitialized = -1;
3139     public final boolean isInitialized() {
3140       byte isInitialized = memoizedIsInitialized;
3141       if (isInitialized != -1) return isInitialized == 1;
3142
3143       memoizedIsInitialized = 1;
3144       return true;
3145     }
3146
3147     public void writeTo(com.google.protobuf.CodedOutputStream output)
3148                         throws java.io.IOException {
3149       getSerializedSize();
3150       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3151         output.writeEnum(1, type_.getNumber());
3152       }
3153       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3154         output.writeBytes(2, getNameBytes());
3155       }
3156       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3157         output.writeBytes(3, getStringValueBytes());
3158       }
3159       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3160         output.writeDouble(4, numericValue_);
3161       }
3162       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3163         output.writeBool(5, booleanValue_);
3164       }
3165       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3166         output.writeBytes(6, getStringEventBytes());
3167       }
3168       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3169         output.writeDouble(7, numericEvent_);
3170       }
3171       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3172         output.writeBool(8, booleanEvent_);
3173       }
3174       getUnknownFields().writeTo(output);
3175     }
3176
3177     private int memoizedSerializedSize = -1;
3178     public int getSerializedSize() {
3179       int size = memoizedSerializedSize;
3180       if (size != -1) return size;
3181
3182       size = 0;
3183       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3184         size += com.google.protobuf.CodedOutputStream
3185           .computeEnumSize(1, type_.getNumber());
3186       }
3187       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3188         size += com.google.protobuf.CodedOutputStream
3189           .computeBytesSize(2, getNameBytes());
3190       }
3191       if (((bitField0_ & 0x00000004) == 0x00000004)) {
3192         size += com.google.protobuf.CodedOutputStream
3193           .computeBytesSize(3, getStringValueBytes());
3194       }
3195       if (((bitField0_ & 0x00000008) == 0x00000008)) {
3196         size += com.google.protobuf.CodedOutputStream
3197           .computeDoubleSize(4, numericValue_);
3198       }
3199       if (((bitField0_ & 0x00000010) == 0x00000010)) {
3200         size += com.google.protobuf.CodedOutputStream
3201           .computeBoolSize(5, booleanValue_);
3202       }
3203       if (((bitField0_ & 0x00000020) == 0x00000020)) {
3204         size += com.google.protobuf.CodedOutputStream
3205           .computeBytesSize(6, getStringEventBytes());
3206       }
3207       if (((bitField0_ & 0x00000040) == 0x00000040)) {
3208         size += com.google.protobuf.CodedOutputStream
3209           .computeDoubleSize(7, numericEvent_);
3210       }
3211       if (((bitField0_ & 0x00000080) == 0x00000080)) {
3212         size += com.google.protobuf.CodedOutputStream
3213           .computeBoolSize(8, booleanEvent_);
3214       }
3215       size += getUnknownFields().getSerializedSize();
3216       memoizedSerializedSize = size;
3217       return size;
3218     }
3219
3220     private static final long serialVersionUID = 0L;
3221     @java.lang.Override
3222     protected java.lang.Object writeReplace()
3223         throws java.io.ObjectStreamException {
3224       return super.writeReplace();
3225     }
3226
3227     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3228         com.google.protobuf.ByteString data)
3229         throws com.google.protobuf.InvalidProtocolBufferException {
3230       return PARSER.parseFrom(data);
3231     }
3232     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3233         com.google.protobuf.ByteString data,
3234         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3235         throws com.google.protobuf.InvalidProtocolBufferException {
3236       return PARSER.parseFrom(data, extensionRegistry);
3237     }
3238     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
3239         throws com.google.protobuf.InvalidProtocolBufferException {
3240       return PARSER.parseFrom(data);
3241     }
3242     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3243         byte[] data,
3244         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3245         throws com.google.protobuf.InvalidProtocolBufferException {
3246       return PARSER.parseFrom(data, extensionRegistry);
3247     }
3248     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
3249         throws java.io.IOException {
3250       return PARSER.parseFrom(input);
3251     }
3252     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3253         java.io.InputStream input,
3254         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3255         throws java.io.IOException {
3256       return PARSER.parseFrom(input, extensionRegistry);
3257     }
3258     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
3259         throws java.io.IOException {
3260       return PARSER.parseDelimitedFrom(input);
3261     }
3262     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
3263         java.io.InputStream input,
3264         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3265         throws java.io.IOException {
3266       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3267     }
3268     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3269         com.google.protobuf.CodedInputStream input)
3270         throws java.io.IOException {
3271       return PARSER.parseFrom(input);
3272     }
3273     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
3274         com.google.protobuf.CodedInputStream input,
3275         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3276         throws java.io.IOException {
3277       return PARSER.parseFrom(input, extensionRegistry);
3278     }
3279
3280     public static Builder newBuilder() { return Builder.create(); }
3281     public Builder newBuilderForType() { return newBuilder(); }
3282     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
3283       return newBuilder().mergeFrom(prototype);
3284     }
3285     public Builder toBuilder() { return newBuilder(this); }
3286
3287     @java.lang.Override
3288     protected Builder newBuilderForType(
3289         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3290       Builder builder = new Builder(parent);
3291       return builder;
3292     }
3293     /**
3294      * Protobuf type {@code openxc.TranslatedMessage}
3295      */
3296     public static final class Builder extends
3297         com.google.protobuf.GeneratedMessage.Builder<Builder>
3298        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
3299       public static final com.google.protobuf.Descriptors.Descriptor
3300           getDescriptor() {
3301         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
3302       }
3303
3304       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3305           internalGetFieldAccessorTable() {
3306         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
3307             .ensureFieldAccessorsInitialized(
3308                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
3309       }
3310
3311       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
3312       private Builder() {
3313         maybeForceBuilderInitialization();
3314       }
3315
3316       private Builder(
3317           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3318         super(parent);
3319         maybeForceBuilderInitialization();
3320       }
3321       private void maybeForceBuilderInitialization() {
3322         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3323         }
3324       }
3325       private static Builder create() {
3326         return new Builder();
3327       }
3328
3329       public Builder clear() {
3330         super.clear();
3331         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3332         bitField0_ = (bitField0_ & ~0x00000001);
3333         name_ = "";
3334         bitField0_ = (bitField0_ & ~0x00000002);
3335         stringValue_ = "";
3336         bitField0_ = (bitField0_ & ~0x00000004);
3337         numericValue_ = 0D;
3338         bitField0_ = (bitField0_ & ~0x00000008);
3339         booleanValue_ = false;
3340         bitField0_ = (bitField0_ & ~0x00000010);
3341         stringEvent_ = "";
3342         bitField0_ = (bitField0_ & ~0x00000020);
3343         numericEvent_ = 0D;
3344         bitField0_ = (bitField0_ & ~0x00000040);
3345         booleanEvent_ = false;
3346         bitField0_ = (bitField0_ & ~0x00000080);
3347         return this;
3348       }
3349
3350       public Builder clone() {
3351         return create().mergeFrom(buildPartial());
3352       }
3353
3354       public com.google.protobuf.Descriptors.Descriptor
3355           getDescriptorForType() {
3356         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
3357       }
3358
3359       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
3360         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
3361       }
3362
3363       public com.openxc.BinaryMessages.TranslatedMessage build() {
3364         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
3365         if (!result.isInitialized()) {
3366           throw newUninitializedMessageException(result);
3367         }
3368         return result;
3369       }
3370
3371       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
3372         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
3373         int from_bitField0_ = bitField0_;
3374         int to_bitField0_ = 0;
3375         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3376           to_bitField0_ |= 0x00000001;
3377         }
3378         result.type_ = type_;
3379         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3380           to_bitField0_ |= 0x00000002;
3381         }
3382         result.name_ = name_;
3383         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
3384           to_bitField0_ |= 0x00000004;
3385         }
3386         result.stringValue_ = stringValue_;
3387         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
3388           to_bitField0_ |= 0x00000008;
3389         }
3390         result.numericValue_ = numericValue_;
3391         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
3392           to_bitField0_ |= 0x00000010;
3393         }
3394         result.booleanValue_ = booleanValue_;
3395         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
3396           to_bitField0_ |= 0x00000020;
3397         }
3398         result.stringEvent_ = stringEvent_;
3399         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
3400           to_bitField0_ |= 0x00000040;
3401         }
3402         result.numericEvent_ = numericEvent_;
3403         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
3404           to_bitField0_ |= 0x00000080;
3405         }
3406         result.booleanEvent_ = booleanEvent_;
3407         result.bitField0_ = to_bitField0_;
3408         onBuilt();
3409         return result;
3410       }
3411
3412       public Builder mergeFrom(com.google.protobuf.Message other) {
3413         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
3414           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
3415         } else {
3416           super.mergeFrom(other);
3417           return this;
3418         }
3419       }
3420
3421       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
3422         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
3423         if (other.hasType()) {
3424           setType(other.getType());
3425         }
3426         if (other.hasName()) {
3427           bitField0_ |= 0x00000002;
3428           name_ = other.name_;
3429           onChanged();
3430         }
3431         if (other.hasStringValue()) {
3432           bitField0_ |= 0x00000004;
3433           stringValue_ = other.stringValue_;
3434           onChanged();
3435         }
3436         if (other.hasNumericValue()) {
3437           setNumericValue(other.getNumericValue());
3438         }
3439         if (other.hasBooleanValue()) {
3440           setBooleanValue(other.getBooleanValue());
3441         }
3442         if (other.hasStringEvent()) {
3443           bitField0_ |= 0x00000020;
3444           stringEvent_ = other.stringEvent_;
3445           onChanged();
3446         }
3447         if (other.hasNumericEvent()) {
3448           setNumericEvent(other.getNumericEvent());
3449         }
3450         if (other.hasBooleanEvent()) {
3451           setBooleanEvent(other.getBooleanEvent());
3452         }
3453         this.mergeUnknownFields(other.getUnknownFields());
3454         return this;
3455       }
3456
3457       public final boolean isInitialized() {
3458         return true;
3459       }
3460
3461       public Builder mergeFrom(
3462           com.google.protobuf.CodedInputStream input,
3463           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3464           throws java.io.IOException {
3465         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
3466         try {
3467           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3468         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3469           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
3470           throw e;
3471         } finally {
3472           if (parsedMessage != null) {
3473             mergeFrom(parsedMessage);
3474           }
3475         }
3476         return this;
3477       }
3478       private int bitField0_;
3479
3480       // optional .openxc.TranslatedMessage.Type type = 1;
3481       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3482       /**
3483        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3484        */
3485       public boolean hasType() {
3486         return ((bitField0_ & 0x00000001) == 0x00000001);
3487       }
3488       /**
3489        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3490        */
3491       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
3492         return type_;
3493       }
3494       /**
3495        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3496        */
3497       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
3498         if (value == null) {
3499           throw new NullPointerException();
3500         }
3501         bitField0_ |= 0x00000001;
3502         type_ = value;
3503         onChanged();
3504         return this;
3505       }
3506       /**
3507        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
3508        */
3509       public Builder clearType() {
3510         bitField0_ = (bitField0_ & ~0x00000001);
3511         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
3512         onChanged();
3513         return this;
3514       }
3515
3516       // optional string name = 2;
3517       private java.lang.Object name_ = "";
3518       /**
3519        * <code>optional string name = 2;</code>
3520        */
3521       public boolean hasName() {
3522         return ((bitField0_ & 0x00000002) == 0x00000002);
3523       }
3524       /**
3525        * <code>optional string name = 2;</code>
3526        */
3527       public java.lang.String getName() {
3528         java.lang.Object ref = name_;
3529         if (!(ref instanceof java.lang.String)) {
3530           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3531               .toStringUtf8();
3532           name_ = s;
3533           return s;
3534         } else {
3535           return (java.lang.String) ref;
3536         }
3537       }
3538       /**
3539        * <code>optional string name = 2;</code>
3540        */
3541       public com.google.protobuf.ByteString
3542           getNameBytes() {
3543         java.lang.Object ref = name_;
3544         if (ref instanceof String) {
3545           com.google.protobuf.ByteString b =
3546               com.google.protobuf.ByteString.copyFromUtf8(
3547                   (java.lang.String) ref);
3548           name_ = b;
3549           return b;
3550         } else {
3551           return (com.google.protobuf.ByteString) ref;
3552         }
3553       }
3554       /**
3555        * <code>optional string name = 2;</code>
3556        */
3557       public Builder setName(
3558           java.lang.String value) {
3559         if (value == null) {
3560     throw new NullPointerException();
3561   }
3562   bitField0_ |= 0x00000002;
3563         name_ = value;
3564         onChanged();
3565         return this;
3566       }
3567       /**
3568        * <code>optional string name = 2;</code>
3569        */
3570       public Builder clearName() {
3571         bitField0_ = (bitField0_ & ~0x00000002);
3572         name_ = getDefaultInstance().getName();
3573         onChanged();
3574         return this;
3575       }
3576       /**
3577        * <code>optional string name = 2;</code>
3578        */
3579       public Builder setNameBytes(
3580           com.google.protobuf.ByteString value) {
3581         if (value == null) {
3582     throw new NullPointerException();
3583   }
3584   bitField0_ |= 0x00000002;
3585         name_ = value;
3586         onChanged();
3587         return this;
3588       }
3589
3590       // optional string string_value = 3;
3591       private java.lang.Object stringValue_ = "";
3592       /**
3593        * <code>optional string string_value = 3;</code>
3594        */
3595       public boolean hasStringValue() {
3596         return ((bitField0_ & 0x00000004) == 0x00000004);
3597       }
3598       /**
3599        * <code>optional string string_value = 3;</code>
3600        */
3601       public java.lang.String getStringValue() {
3602         java.lang.Object ref = stringValue_;
3603         if (!(ref instanceof java.lang.String)) {
3604           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3605               .toStringUtf8();
3606           stringValue_ = s;
3607           return s;
3608         } else {
3609           return (java.lang.String) ref;
3610         }
3611       }
3612       /**
3613        * <code>optional string string_value = 3;</code>
3614        */
3615       public com.google.protobuf.ByteString
3616           getStringValueBytes() {
3617         java.lang.Object ref = stringValue_;
3618         if (ref instanceof String) {
3619           com.google.protobuf.ByteString b =
3620               com.google.protobuf.ByteString.copyFromUtf8(
3621                   (java.lang.String) ref);
3622           stringValue_ = b;
3623           return b;
3624         } else {
3625           return (com.google.protobuf.ByteString) ref;
3626         }
3627       }
3628       /**
3629        * <code>optional string string_value = 3;</code>
3630        */
3631       public Builder setStringValue(
3632           java.lang.String value) {
3633         if (value == null) {
3634     throw new NullPointerException();
3635   }
3636   bitField0_ |= 0x00000004;
3637         stringValue_ = value;
3638         onChanged();
3639         return this;
3640       }
3641       /**
3642        * <code>optional string string_value = 3;</code>
3643        */
3644       public Builder clearStringValue() {
3645         bitField0_ = (bitField0_ & ~0x00000004);
3646         stringValue_ = getDefaultInstance().getStringValue();
3647         onChanged();
3648         return this;
3649       }
3650       /**
3651        * <code>optional string string_value = 3;</code>
3652        */
3653       public Builder setStringValueBytes(
3654           com.google.protobuf.ByteString value) {
3655         if (value == null) {
3656     throw new NullPointerException();
3657   }
3658   bitField0_ |= 0x00000004;
3659         stringValue_ = value;
3660         onChanged();
3661         return this;
3662       }
3663
3664       // optional double numeric_value = 4;
3665       private double numericValue_ ;
3666       /**
3667        * <code>optional double numeric_value = 4;</code>
3668        */
3669       public boolean hasNumericValue() {
3670         return ((bitField0_ & 0x00000008) == 0x00000008);
3671       }
3672       /**
3673        * <code>optional double numeric_value = 4;</code>
3674        */
3675       public double getNumericValue() {
3676         return numericValue_;
3677       }
3678       /**
3679        * <code>optional double numeric_value = 4;</code>
3680        */
3681       public Builder setNumericValue(double value) {
3682         bitField0_ |= 0x00000008;
3683         numericValue_ = value;
3684         onChanged();
3685         return this;
3686       }
3687       /**
3688        * <code>optional double numeric_value = 4;</code>
3689        */
3690       public Builder clearNumericValue() {
3691         bitField0_ = (bitField0_ & ~0x00000008);
3692         numericValue_ = 0D;
3693         onChanged();
3694         return this;
3695       }
3696
3697       // optional bool boolean_value = 5;
3698       private boolean booleanValue_ ;
3699       /**
3700        * <code>optional bool boolean_value = 5;</code>
3701        */
3702       public boolean hasBooleanValue() {
3703         return ((bitField0_ & 0x00000010) == 0x00000010);
3704       }
3705       /**
3706        * <code>optional bool boolean_value = 5;</code>
3707        */
3708       public boolean getBooleanValue() {
3709         return booleanValue_;
3710       }
3711       /**
3712        * <code>optional bool boolean_value = 5;</code>
3713        */
3714       public Builder setBooleanValue(boolean value) {
3715         bitField0_ |= 0x00000010;
3716         booleanValue_ = value;
3717         onChanged();
3718         return this;
3719       }
3720       /**
3721        * <code>optional bool boolean_value = 5;</code>
3722        */
3723       public Builder clearBooleanValue() {
3724         bitField0_ = (bitField0_ & ~0x00000010);
3725         booleanValue_ = false;
3726         onChanged();
3727         return this;
3728       }
3729
3730       // optional string string_event = 6;
3731       private java.lang.Object stringEvent_ = "";
3732       /**
3733        * <code>optional string string_event = 6;</code>
3734        */
3735       public boolean hasStringEvent() {
3736         return ((bitField0_ & 0x00000020) == 0x00000020);
3737       }
3738       /**
3739        * <code>optional string string_event = 6;</code>
3740        */
3741       public java.lang.String getStringEvent() {
3742         java.lang.Object ref = stringEvent_;
3743         if (!(ref instanceof java.lang.String)) {
3744           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3745               .toStringUtf8();
3746           stringEvent_ = s;
3747           return s;
3748         } else {
3749           return (java.lang.String) ref;
3750         }
3751       }
3752       /**
3753        * <code>optional string string_event = 6;</code>
3754        */
3755       public com.google.protobuf.ByteString
3756           getStringEventBytes() {
3757         java.lang.Object ref = stringEvent_;
3758         if (ref instanceof String) {
3759           com.google.protobuf.ByteString b =
3760               com.google.protobuf.ByteString.copyFromUtf8(
3761                   (java.lang.String) ref);
3762           stringEvent_ = b;
3763           return b;
3764         } else {
3765           return (com.google.protobuf.ByteString) ref;
3766         }
3767       }
3768       /**
3769        * <code>optional string string_event = 6;</code>
3770        */
3771       public Builder setStringEvent(
3772           java.lang.String value) {
3773         if (value == null) {
3774     throw new NullPointerException();
3775   }
3776   bitField0_ |= 0x00000020;
3777         stringEvent_ = value;
3778         onChanged();
3779         return this;
3780       }
3781       /**
3782        * <code>optional string string_event = 6;</code>
3783        */
3784       public Builder clearStringEvent() {
3785         bitField0_ = (bitField0_ & ~0x00000020);
3786         stringEvent_ = getDefaultInstance().getStringEvent();
3787         onChanged();
3788         return this;
3789       }
3790       /**
3791        * <code>optional string string_event = 6;</code>
3792        */
3793       public Builder setStringEventBytes(
3794           com.google.protobuf.ByteString value) {
3795         if (value == null) {
3796     throw new NullPointerException();
3797   }
3798   bitField0_ |= 0x00000020;
3799         stringEvent_ = value;
3800         onChanged();
3801         return this;
3802       }
3803
3804       // optional double numeric_event = 7;
3805       private double numericEvent_ ;
3806       /**
3807        * <code>optional double numeric_event = 7;</code>
3808        */
3809       public boolean hasNumericEvent() {
3810         return ((bitField0_ & 0x00000040) == 0x00000040);
3811       }
3812       /**
3813        * <code>optional double numeric_event = 7;</code>
3814        */
3815       public double getNumericEvent() {
3816         return numericEvent_;
3817       }
3818       /**
3819        * <code>optional double numeric_event = 7;</code>
3820        */
3821       public Builder setNumericEvent(double value) {
3822         bitField0_ |= 0x00000040;
3823         numericEvent_ = value;
3824         onChanged();
3825         return this;
3826       }
3827       /**
3828        * <code>optional double numeric_event = 7;</code>
3829        */
3830       public Builder clearNumericEvent() {
3831         bitField0_ = (bitField0_ & ~0x00000040);
3832         numericEvent_ = 0D;
3833         onChanged();
3834         return this;
3835       }
3836
3837       // optional bool boolean_event = 8;
3838       private boolean booleanEvent_ ;
3839       /**
3840        * <code>optional bool boolean_event = 8;</code>
3841        */
3842       public boolean hasBooleanEvent() {
3843         return ((bitField0_ & 0x00000080) == 0x00000080);
3844       }
3845       /**
3846        * <code>optional bool boolean_event = 8;</code>
3847        */
3848       public boolean getBooleanEvent() {
3849         return booleanEvent_;
3850       }
3851       /**
3852        * <code>optional bool boolean_event = 8;</code>
3853        */
3854       public Builder setBooleanEvent(boolean value) {
3855         bitField0_ |= 0x00000080;
3856         booleanEvent_ = value;
3857         onChanged();
3858         return this;
3859       }
3860       /**
3861        * <code>optional bool boolean_event = 8;</code>
3862        */
3863       public Builder clearBooleanEvent() {
3864         bitField0_ = (bitField0_ & ~0x00000080);
3865         booleanEvent_ = false;
3866         onChanged();
3867         return this;
3868       }
3869
3870       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
3871     }
3872
3873     static {
3874       defaultInstance = new TranslatedMessage(true);
3875       defaultInstance.initFields();
3876     }
3877
3878     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
3879   }
3880
3881   private static com.google.protobuf.Descriptors.Descriptor
3882     internal_static_openxc_VehicleMessage_descriptor;
3883   private static
3884     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3885       internal_static_openxc_VehicleMessage_fieldAccessorTable;
3886   private static com.google.protobuf.Descriptors.Descriptor
3887     internal_static_openxc_RawMessage_descriptor;
3888   private static
3889     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3890       internal_static_openxc_RawMessage_fieldAccessorTable;
3891   private static com.google.protobuf.Descriptors.Descriptor
3892     internal_static_openxc_DiagnosticMessage_descriptor;
3893   private static
3894     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3895       internal_static_openxc_DiagnosticMessage_fieldAccessorTable;
3896   private static com.google.protobuf.Descriptors.Descriptor
3897     internal_static_openxc_TranslatedMessage_descriptor;
3898   private static
3899     com.google.protobuf.GeneratedMessage.FieldAccessorTable
3900       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
3901
3902   public static com.google.protobuf.Descriptors.FileDescriptor
3903       getDescriptor() {
3904     return descriptor;
3905   }
3906   private static com.google.protobuf.Descriptors.FileDescriptor
3907       descriptor;
3908   static {
3909     java.lang.String[] descriptorData = {
3910       "\n\014openxc.proto\022\006openxc\"\203\002\n\016VehicleMessag" +
3911       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
3912       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
3913       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
3914       "xc.TranslatedMessage\0225\n\022diagnostic_messa" +
3915       "ge\030\004 \001(\0132\031.openxc.DiagnosticMessage\"/\n\004T" +
3916       "ype\022\007\n\003RAW\020\001\022\016\n\nTRANSLATED\020\002\022\016\n\nDIAGNOST" +
3917       "IC\020\003\";\n\nRawMessage\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessa" +
3918       "ge_id\030\002 \001(\r\022\014\n\004data\030\003 \001(\004\"\221\001\n\021Diagnostic" +
3919       "Message\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessage_id\030\002 \001(\r",
3920       "\022\014\n\004mode\030\003 \001(\r\022\013\n\003pid\030\004 \001(\r\022\017\n\007success\030\005" +
3921       " \001(\010\022\036\n\026negative_response_code\030\006 \001(\r\022\017\n\007" +
3922       "payload\030\007 \001(\014\"\265\002\n\021TranslatedMessage\022,\n\004t" +
3923       "ype\030\001 \001(\0162\036.openxc.TranslatedMessage.Typ" +
3924       "e\022\014\n\004name\030\002 \001(\t\022\024\n\014string_value\030\003 \001(\t\022\025\n" +
3925       "\rnumeric_value\030\004 \001(\001\022\025\n\rboolean_value\030\005 " +
3926       "\001(\010\022\024\n\014string_event\030\006 \001(\t\022\025\n\rnumeric_eve" +
3927       "nt\030\007 \001(\001\022\025\n\rboolean_event\030\010 \001(\010\"\\\n\004Type\022" +
3928       "\n\n\006STRING\020\001\022\007\n\003NUM\020\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTE" +
3929       "D_STRING\020\004\022\017\n\013EVENTED_NUM\020\005\022\020\n\014EVENTED_B",
3930       "OOL\020\006B\034\n\ncom.openxcB\016BinaryMessages"
3931     };
3932     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
3933       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
3934         public com.google.protobuf.ExtensionRegistry assignDescriptors(
3935             com.google.protobuf.Descriptors.FileDescriptor root) {
3936           descriptor = root;
3937           internal_static_openxc_VehicleMessage_descriptor =
3938             getDescriptor().getMessageTypes().get(0);
3939           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
3940             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3941               internal_static_openxc_VehicleMessage_descriptor,
3942               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", "DiagnosticMessage", });
3943           internal_static_openxc_RawMessage_descriptor =
3944             getDescriptor().getMessageTypes().get(1);
3945           internal_static_openxc_RawMessage_fieldAccessorTable = new
3946             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3947               internal_static_openxc_RawMessage_descriptor,
3948               new java.lang.String[] { "Bus", "MessageId", "Data", });
3949           internal_static_openxc_DiagnosticMessage_descriptor =
3950             getDescriptor().getMessageTypes().get(2);
3951           internal_static_openxc_DiagnosticMessage_fieldAccessorTable = new
3952             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3953               internal_static_openxc_DiagnosticMessage_descriptor,
3954               new java.lang.String[] { "Bus", "MessageId", "Mode", "Pid", "Success", "NegativeResponseCode", "Payload", });
3955           internal_static_openxc_TranslatedMessage_descriptor =
3956             getDescriptor().getMessageTypes().get(3);
3957           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
3958             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
3959               internal_static_openxc_TranslatedMessage_descriptor,
3960               new java.lang.String[] { "Type", "Name", "StringValue", "NumericValue", "BooleanValue", "StringEvent", "NumericEvent", "BooleanEvent", });
3961           return null;
3962         }
3963       };
3964     com.google.protobuf.Descriptors.FileDescriptor
3965       .internalBuildGeneratedFileFrom(descriptorData,
3966         new com.google.protobuf.Descriptors.FileDescriptor[] {
3967         }, assigner);
3968   }
3969
3970   // @@protoc_insertion_point(outer_class_scope)
3971 }