gen/java/com/openxc/BinaryMessages.java

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