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   /**
  53    * Protobuf type {@code openxc.VehicleMessage}
  54    */
  55   public static final class VehicleMessage extends
  56       com.google.protobuf.GeneratedMessage
  57       implements VehicleMessageOrBuilder {
  58     // Use VehicleMessage.newBuilder() to construct.
  59     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
  60       super(builder);
  61       this.unknownFields = builder.getUnknownFields();
  62     }
  63     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
  64
  65     private static final VehicleMessage defaultInstance;
  66     public static VehicleMessage getDefaultInstance() {
  67       return defaultInstance;
  68     }
  69
  70     public VehicleMessage getDefaultInstanceForType() {
  71       return defaultInstance;
  72     }
  73
  74     private final com.google.protobuf.UnknownFieldSet unknownFields;
  75     @java.lang.Override
  76     public final com.google.protobuf.UnknownFieldSet
  77         getUnknownFields() {
  78       return this.unknownFields;
  79     }
  80     private VehicleMessage(
  81         com.google.protobuf.CodedInputStream input,
  82         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
  83         throws com.google.protobuf.InvalidProtocolBufferException {
  84       initFields();
  85       int mutable_bitField0_ = 0;
  86       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
  87           com.google.protobuf.UnknownFieldSet.newBuilder();
  88       try {
  89         boolean done = false;
  90         while (!done) {
  91           int tag = input.readTag();
  92           switch (tag) {
  93             case 0:
  94               done = true;
  95               break;
  96             default: {
  97               if (!parseUnknownField(input, unknownFields,
  98                                      extensionRegistry, tag)) {
  99                 done = true;
 100               }
 101               break;
 102             }
 103             case 8: {
 104               int rawValue = input.readEnum();
 105               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 106               if (value == null) {
 107                 unknownFields.mergeVarintField(1, rawValue);
 108               } else {
 109                 bitField0_ |= 0x00000001;
 110                 type_ = value;
 111               }
 112               break;
 113             }
 114             case 18: {
 115               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
 116               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 117                 subBuilder = rawMessage_.toBuilder();
 118               }
 119               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
 120               if (subBuilder != null) {
 121                 subBuilder.mergeFrom(rawMessage_);
 122                 rawMessage_ = subBuilder.buildPartial();
 123               }
 124               bitField0_ |= 0x00000002;
 125               break;
 126             }
 127             case 26: {
 128               com.openxc.BinaryMessages.TranslatedMessage.Builder subBuilder = null;
 129               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 130                 subBuilder = translatedMessage_.toBuilder();
 131               }
 132               translatedMessage_ = input.readMessage(com.openxc.BinaryMessages.TranslatedMessage.PARSER, extensionRegistry);
 133               if (subBuilder != null) {
 134                 subBuilder.mergeFrom(translatedMessage_);
 135                 translatedMessage_ = subBuilder.buildPartial();
 136               }
 137               bitField0_ |= 0x00000004;
 138               break;
 139             }
 140           }
 141         }
 142       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 143         throw e.setUnfinishedMessage(this);
 144       } catch (java.io.IOException e) {
 145         throw new com.google.protobuf.InvalidProtocolBufferException(
 146             e.getMessage()).setUnfinishedMessage(this);
 147       } finally {
 148         this.unknownFields = unknownFields.build();
 149         makeExtensionsImmutable();
 150       }
 151     }
 152     public static final com.google.protobuf.Descriptors.Descriptor
 153         getDescriptor() {
 154       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 155     }
 156
 157     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 158         internalGetFieldAccessorTable() {
 159       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 160           .ensureFieldAccessorsInitialized(
 161               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 162     }
 163
 164     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 165         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 166       public VehicleMessage parsePartialFrom(
 167           com.google.protobuf.CodedInputStream input,
 168           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 169           throws com.google.protobuf.InvalidProtocolBufferException {
 170         return new VehicleMessage(input, extensionRegistry);
 171       }
 172     };
 173
 174     @java.lang.Override
 175     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 176       return PARSER;
 177     }
 178
 179     /**
 180      * Protobuf enum {@code openxc.VehicleMessage.Type}
 181      */
 182     public enum Type
 183         implements com.google.protobuf.ProtocolMessageEnum {
 184       /**
 185        * <code>RAW = 1;</code>
 186        */
 187       RAW(0, 1),
 188       /**
 189        * <code>TRANSLATED = 2;</code>
 190        */
 191       TRANSLATED(1, 2),
 192       ;
 193
 194       /**
 195        * <code>RAW = 1;</code>
 196        */
 197       public static final int RAW_VALUE = 1;
 198       /**
 199        * <code>TRANSLATED = 2;</code>
 200        */
 201       public static final int TRANSLATED_VALUE = 2;
 202
 203
 204       public final int getNumber() { return value; }
 205
 206       public static Type valueOf(int value) {
 207         switch (value) {
 208           case 1: return RAW;
 209           case 2: return TRANSLATED;
 210           default: return null;
 211         }
 212       }
 213
 214       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 215           internalGetValueMap() {
 216         return internalValueMap;
 217       }
 218       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 219           internalValueMap =
 220             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 221               public Type findValueByNumber(int number) {
 222                 return Type.valueOf(number);
 223               }
 224             };
 225
 226       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 227           getValueDescriptor() {
 228         return getDescriptor().getValues().get(index);
 229       }
 230       public final com.google.protobuf.Descriptors.EnumDescriptor
 231           getDescriptorForType() {
 232         return getDescriptor();
 233       }
 234       public static final com.google.protobuf.Descriptors.EnumDescriptor
 235           getDescriptor() {
 236         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 237       }
 238
 239       private static final Type[] VALUES = values();
 240
 241       public static Type valueOf(
 242           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 243         if (desc.getType() != getDescriptor()) {
 244           throw new java.lang.IllegalArgumentException(
 245             "EnumValueDescriptor is not for this type.");
 246         }
 247         return VALUES[desc.getIndex()];
 248       }
 249
 250       private final int index;
 251       private final int value;
 252
 253       private Type(int index, int value) {
 254         this.index = index;
 255         this.value = value;
 256       }
 257
 258       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 259     }
 260
 261     private int bitField0_;
 262     // optional .openxc.VehicleMessage.Type type = 1;
 263     public static final int TYPE_FIELD_NUMBER = 1;
 264     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 265     /**
 266      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 267      */
 268     public boolean hasType() {
 269       return ((bitField0_ & 0x00000001) == 0x00000001);
 270     }
 271     /**
 272      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 273      */
 274     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 275       return type_;
 276     }
 277
 278     // optional .openxc.RawMessage raw_message = 2;
 279     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
 280     private com.openxc.BinaryMessages.RawMessage rawMessage_;
 281     /**
 282      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 283      */
 284     public boolean hasRawMessage() {
 285       return ((bitField0_ & 0x00000002) == 0x00000002);
 286     }
 287     /**
 288      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 289      */
 290     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 291       return rawMessage_;
 292     }
 293     /**
 294      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 295      */
 296     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 297       return rawMessage_;
 298     }
 299
 300     // optional .openxc.TranslatedMessage translated_message = 3;
 301     public static final int TRANSLATED_MESSAGE_FIELD_NUMBER = 3;
 302     private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_;
 303     /**
 304      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 305      */
 306     public boolean hasTranslatedMessage() {
 307       return ((bitField0_ & 0x00000004) == 0x00000004);
 308     }
 309     /**
 310      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 311      */
 312     public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 313       return translatedMessage_;
 314     }
 315     /**
 316      * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 317      */
 318     public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 319       return translatedMessage_;
 320     }
 321
 322     private void initFields() {
 323       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 324       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 325       translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 326     }
 327     private byte memoizedIsInitialized = -1;
 328     public final boolean isInitialized() {
 329       byte isInitialized = memoizedIsInitialized;
 330       if (isInitialized != -1) return isInitialized == 1;
 331
 332       memoizedIsInitialized = 1;
 333       return true;
 334     }
 335
 336     public void writeTo(com.google.protobuf.CodedOutputStream output)
 337                         throws java.io.IOException {
 338       getSerializedSize();
 339       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 340         output.writeEnum(1, type_.getNumber());
 341       }
 342       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 343         output.writeMessage(2, rawMessage_);
 344       }
 345       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 346         output.writeMessage(3, translatedMessage_);
 347       }
 348       getUnknownFields().writeTo(output);
 349     }
 350
 351     private int memoizedSerializedSize = -1;
 352     public int getSerializedSize() {
 353       int size = memoizedSerializedSize;
 354       if (size != -1) return size;
 355
 356       size = 0;
 357       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 358         size += com.google.protobuf.CodedOutputStream
 359           .computeEnumSize(1, type_.getNumber());
 360       }
 361       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 362         size += com.google.protobuf.CodedOutputStream
 363           .computeMessageSize(2, rawMessage_);
 364       }
 365       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 366         size += com.google.protobuf.CodedOutputStream
 367           .computeMessageSize(3, translatedMessage_);
 368       }
 369       size += getUnknownFields().getSerializedSize();
 370       memoizedSerializedSize = size;
 371       return size;
 372     }
 373
 374     private static final long serialVersionUID = 0L;
 375     @java.lang.Override
 376     protected java.lang.Object writeReplace()
 377         throws java.io.ObjectStreamException {
 378       return super.writeReplace();
 379     }
 380
 381     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 382         com.google.protobuf.ByteString data)
 383         throws com.google.protobuf.InvalidProtocolBufferException {
 384       return PARSER.parseFrom(data);
 385     }
 386     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 387         com.google.protobuf.ByteString data,
 388         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 389         throws com.google.protobuf.InvalidProtocolBufferException {
 390       return PARSER.parseFrom(data, extensionRegistry);
 391     }
 392     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 393         throws com.google.protobuf.InvalidProtocolBufferException {
 394       return PARSER.parseFrom(data);
 395     }
 396     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 397         byte[] data,
 398         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 399         throws com.google.protobuf.InvalidProtocolBufferException {
 400       return PARSER.parseFrom(data, extensionRegistry);
 401     }
 402     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 403         throws java.io.IOException {
 404       return PARSER.parseFrom(input);
 405     }
 406     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 407         java.io.InputStream input,
 408         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 409         throws java.io.IOException {
 410       return PARSER.parseFrom(input, extensionRegistry);
 411     }
 412     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 413         throws java.io.IOException {
 414       return PARSER.parseDelimitedFrom(input);
 415     }
 416     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 417         java.io.InputStream input,
 418         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 419         throws java.io.IOException {
 420       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 421     }
 422     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 423         com.google.protobuf.CodedInputStream input)
 424         throws java.io.IOException {
 425       return PARSER.parseFrom(input);
 426     }
 427     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 428         com.google.protobuf.CodedInputStream input,
 429         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 430         throws java.io.IOException {
 431       return PARSER.parseFrom(input, extensionRegistry);
 432     }
 433
 434     public static Builder newBuilder() { return Builder.create(); }
 435     public Builder newBuilderForType() { return newBuilder(); }
 436     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 437       return newBuilder().mergeFrom(prototype);
 438     }
 439     public Builder toBuilder() { return newBuilder(this); }
 440
 441     @java.lang.Override
 442     protected Builder newBuilderForType(
 443         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 444       Builder builder = new Builder(parent);
 445       return builder;
 446     }
 447     /**
 448      * Protobuf type {@code openxc.VehicleMessage}
 449      */
 450     public static final class Builder extends
 451         com.google.protobuf.GeneratedMessage.Builder<Builder>
 452        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 453       public static final com.google.protobuf.Descriptors.Descriptor
 454           getDescriptor() {
 455         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 456       }
 457
 458       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 459           internalGetFieldAccessorTable() {
 460         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 461             .ensureFieldAccessorsInitialized(
 462                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 463       }
 464
 465       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 466       private Builder() {
 467         maybeForceBuilderInitialization();
 468       }
 469
 470       private Builder(
 471           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 472         super(parent);
 473         maybeForceBuilderInitialization();
 474       }
 475       private void maybeForceBuilderInitialization() {
 476         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 477           getRawMessageFieldBuilder();
 478           getTranslatedMessageFieldBuilder();
 479         }
 480       }
 481       private static Builder create() {
 482         return new Builder();
 483       }
 484
 485       public Builder clear() {
 486         super.clear();
 487         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 488         bitField0_ = (bitField0_ & ~0x00000001);
 489         if (rawMessageBuilder_ == null) {
 490           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 491         } else {
 492           rawMessageBuilder_.clear();
 493         }
 494         bitField0_ = (bitField0_ & ~0x00000002);
 495         if (translatedMessageBuilder_ == null) {
 496           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 497         } else {
 498           translatedMessageBuilder_.clear();
 499         }
 500         bitField0_ = (bitField0_ & ~0x00000004);
 501         return this;
 502       }
 503
 504       public Builder clone() {
 505         return create().mergeFrom(buildPartial());
 506       }
 507
 508       public com.google.protobuf.Descriptors.Descriptor
 509           getDescriptorForType() {
 510         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 511       }
 512
 513       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 514         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 515       }
 516
 517       public com.openxc.BinaryMessages.VehicleMessage build() {
 518         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 519         if (!result.isInitialized()) {
 520           throw newUninitializedMessageException(result);
 521         }
 522         return result;
 523       }
 524
 525       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 526         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 527         int from_bitField0_ = bitField0_;
 528         int to_bitField0_ = 0;
 529         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 530           to_bitField0_ |= 0x00000001;
 531         }
 532         result.type_ = type_;
 533         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 534           to_bitField0_ |= 0x00000002;
 535         }
 536         if (rawMessageBuilder_ == null) {
 537           result.rawMessage_ = rawMessage_;
 538         } else {
 539           result.rawMessage_ = rawMessageBuilder_.build();
 540         }
 541         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 542           to_bitField0_ |= 0x00000004;
 543         }
 544         if (translatedMessageBuilder_ == null) {
 545           result.translatedMessage_ = translatedMessage_;
 546         } else {
 547           result.translatedMessage_ = translatedMessageBuilder_.build();
 548         }
 549         result.bitField0_ = to_bitField0_;
 550         onBuilt();
 551         return result;
 552       }
 553
 554       public Builder mergeFrom(com.google.protobuf.Message other) {
 555         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 556           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 557         } else {
 558           super.mergeFrom(other);
 559           return this;
 560         }
 561       }
 562
 563       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 564         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 565         if (other.hasType()) {
 566           setType(other.getType());
 567         }
 568         if (other.hasRawMessage()) {
 569           mergeRawMessage(other.getRawMessage());
 570         }
 571         if (other.hasTranslatedMessage()) {
 572           mergeTranslatedMessage(other.getTranslatedMessage());
 573         }
 574         this.mergeUnknownFields(other.getUnknownFields());
 575         return this;
 576       }
 577
 578       public final boolean isInitialized() {
 579         return true;
 580       }
 581
 582       public Builder mergeFrom(
 583           com.google.protobuf.CodedInputStream input,
 584           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 585           throws java.io.IOException {
 586         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
 587         try {
 588           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
 589         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 590           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
 591           throw e;
 592         } finally {
 593           if (parsedMessage != null) {
 594             mergeFrom(parsedMessage);
 595           }
 596         }
 597         return this;
 598       }
 599       private int bitField0_;
 600
 601       // optional .openxc.VehicleMessage.Type type = 1;
 602       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 603       /**
 604        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 605        */
 606       public boolean hasType() {
 607         return ((bitField0_ & 0x00000001) == 0x00000001);
 608       }
 609       /**
 610        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 611        */
 612       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 613         return type_;
 614       }
 615       /**
 616        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 617        */
 618       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
 619         if (value == null) {
 620           throw new NullPointerException();
 621         }
 622         bitField0_ |= 0x00000001;
 623         type_ = value;
 624         onChanged();
 625         return this;
 626       }
 627       /**
 628        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 629        */
 630       public Builder clearType() {
 631         bitField0_ = (bitField0_ & ~0x00000001);
 632         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 633         onChanged();
 634         return this;
 635       }
 636
 637       // optional .openxc.RawMessage raw_message = 2;
 638       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 639       private com.google.protobuf.SingleFieldBuilder<
 640           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
 641       /**
 642        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 643        */
 644       public boolean hasRawMessage() {
 645         return ((bitField0_ & 0x00000002) == 0x00000002);
 646       }
 647       /**
 648        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 649        */
 650       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 651         if (rawMessageBuilder_ == null) {
 652           return rawMessage_;
 653         } else {
 654           return rawMessageBuilder_.getMessage();
 655         }
 656       }
 657       /**
 658        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 659        */
 660       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 661         if (rawMessageBuilder_ == null) {
 662           if (value == null) {
 663             throw new NullPointerException();
 664           }
 665           rawMessage_ = value;
 666           onChanged();
 667         } else {
 668           rawMessageBuilder_.setMessage(value);
 669         }
 670         bitField0_ |= 0x00000002;
 671         return this;
 672       }
 673       /**
 674        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 675        */
 676       public Builder setRawMessage(
 677           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
 678         if (rawMessageBuilder_ == null) {
 679           rawMessage_ = builderForValue.build();
 680           onChanged();
 681         } else {
 682           rawMessageBuilder_.setMessage(builderForValue.build());
 683         }
 684         bitField0_ |= 0x00000002;
 685         return this;
 686       }
 687       /**
 688        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 689        */
 690       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
 691         if (rawMessageBuilder_ == null) {
 692           if (((bitField0_ & 0x00000002) == 0x00000002) &&
 693               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
 694             rawMessage_ =
 695               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
 696           } else {
 697             rawMessage_ = value;
 698           }
 699           onChanged();
 700         } else {
 701           rawMessageBuilder_.mergeFrom(value);
 702         }
 703         bitField0_ |= 0x00000002;
 704         return this;
 705       }
 706       /**
 707        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 708        */
 709       public Builder clearRawMessage() {
 710         if (rawMessageBuilder_ == null) {
 711           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 712           onChanged();
 713         } else {
 714           rawMessageBuilder_.clear();
 715         }
 716         bitField0_ = (bitField0_ & ~0x00000002);
 717         return this;
 718       }
 719       /**
 720        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 721        */
 722       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
 723         bitField0_ |= 0x00000002;
 724         onChanged();
 725         return getRawMessageFieldBuilder().getBuilder();
 726       }
 727       /**
 728        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 729        */
 730       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 731         if (rawMessageBuilder_ != null) {
 732           return rawMessageBuilder_.getMessageOrBuilder();
 733         } else {
 734           return rawMessage_;
 735         }
 736       }
 737       /**
 738        * <code>optional .openxc.RawMessage raw_message = 2;</code>
 739        */
 740       private com.google.protobuf.SingleFieldBuilder<
 741           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>
 742           getRawMessageFieldBuilder() {
 743         if (rawMessageBuilder_ == null) {
 744           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 745               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
 746                   rawMessage_,
 747                   getParentForChildren(),
 748                   isClean());
 749           rawMessage_ = null;
 750         }
 751         return rawMessageBuilder_;
 752       }
 753
 754       // optional .openxc.TranslatedMessage translated_message = 3;
 755       private com.openxc.BinaryMessages.TranslatedMessage translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 756       private com.google.protobuf.SingleFieldBuilder<
 757           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder> translatedMessageBuilder_;
 758       /**
 759        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 760        */
 761       public boolean hasTranslatedMessage() {
 762         return ((bitField0_ & 0x00000004) == 0x00000004);
 763       }
 764       /**
 765        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 766        */
 767       public com.openxc.BinaryMessages.TranslatedMessage getTranslatedMessage() {
 768         if (translatedMessageBuilder_ == null) {
 769           return translatedMessage_;
 770         } else {
 771           return translatedMessageBuilder_.getMessage();
 772         }
 773       }
 774       /**
 775        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 776        */
 777       public Builder setTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
 778         if (translatedMessageBuilder_ == null) {
 779           if (value == null) {
 780             throw new NullPointerException();
 781           }
 782           translatedMessage_ = value;
 783           onChanged();
 784         } else {
 785           translatedMessageBuilder_.setMessage(value);
 786         }
 787         bitField0_ |= 0x00000004;
 788         return this;
 789       }
 790       /**
 791        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 792        */
 793       public Builder setTranslatedMessage(
 794           com.openxc.BinaryMessages.TranslatedMessage.Builder builderForValue) {
 795         if (translatedMessageBuilder_ == null) {
 796           translatedMessage_ = builderForValue.build();
 797           onChanged();
 798         } else {
 799           translatedMessageBuilder_.setMessage(builderForValue.build());
 800         }
 801         bitField0_ |= 0x00000004;
 802         return this;
 803       }
 804       /**
 805        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 806        */
 807       public Builder mergeTranslatedMessage(com.openxc.BinaryMessages.TranslatedMessage value) {
 808         if (translatedMessageBuilder_ == null) {
 809           if (((bitField0_ & 0x00000004) == 0x00000004) &&
 810               translatedMessage_ != com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) {
 811             translatedMessage_ =
 812               com.openxc.BinaryMessages.TranslatedMessage.newBuilder(translatedMessage_).mergeFrom(value).buildPartial();
 813           } else {
 814             translatedMessage_ = value;
 815           }
 816           onChanged();
 817         } else {
 818           translatedMessageBuilder_.mergeFrom(value);
 819         }
 820         bitField0_ |= 0x00000004;
 821         return this;
 822       }
 823       /**
 824        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 825        */
 826       public Builder clearTranslatedMessage() {
 827         if (translatedMessageBuilder_ == null) {
 828           translatedMessage_ = com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
 829           onChanged();
 830         } else {
 831           translatedMessageBuilder_.clear();
 832         }
 833         bitField0_ = (bitField0_ & ~0x00000004);
 834         return this;
 835       }
 836       /**
 837        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 838        */
 839       public com.openxc.BinaryMessages.TranslatedMessage.Builder getTranslatedMessageBuilder() {
 840         bitField0_ |= 0x00000004;
 841         onChanged();
 842         return getTranslatedMessageFieldBuilder().getBuilder();
 843       }
 844       /**
 845        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 846        */
 847       public com.openxc.BinaryMessages.TranslatedMessageOrBuilder getTranslatedMessageOrBuilder() {
 848         if (translatedMessageBuilder_ != null) {
 849           return translatedMessageBuilder_.getMessageOrBuilder();
 850         } else {
 851           return translatedMessage_;
 852         }
 853       }
 854       /**
 855        * <code>optional .openxc.TranslatedMessage translated_message = 3;</code>
 856        */
 857       private com.google.protobuf.SingleFieldBuilder<
 858           com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>
 859           getTranslatedMessageFieldBuilder() {
 860         if (translatedMessageBuilder_ == null) {
 861           translatedMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
 862               com.openxc.BinaryMessages.TranslatedMessage, com.openxc.BinaryMessages.TranslatedMessage.Builder, com.openxc.BinaryMessages.TranslatedMessageOrBuilder>(
 863                   translatedMessage_,
 864                   getParentForChildren(),
 865                   isClean());
 866           translatedMessage_ = null;
 867         }
 868         return translatedMessageBuilder_;
 869       }
 870
 871       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
 872     }
 873
 874     static {
 875       defaultInstance = new VehicleMessage(true);
 876       defaultInstance.initFields();
 877     }
 878
 879     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
 880   }
 881
 882   public interface RawMessageOrBuilder
 883       extends com.google.protobuf.MessageOrBuilder {
 884
 885     // optional int32 bus = 1;
 886     /**
 887      * <code>optional int32 bus = 1;</code>
 888      */
 889     boolean hasBus();
 890     /**
 891      * <code>optional int32 bus = 1;</code>
 892      */
 893     int getBus();
 894
 895     // optional uint32 message_id = 2;
 896     /**
 897      * <code>optional uint32 message_id = 2;</code>
 898      */
 899     boolean hasMessageId();
 900     /**
 901      * <code>optional uint32 message_id = 2;</code>
 902      */
 903     int getMessageId();
 904
 905     // optional uint64 data = 3;
 906     /**
 907      * <code>optional uint64 data = 3;</code>
 908      */
 909     boolean hasData();
 910     /**
 911      * <code>optional uint64 data = 3;</code>
 912      */
 913     long getData();
 914   }
 915   /**
 916    * Protobuf type {@code openxc.RawMessage}
 917    */
 918   public static final class RawMessage extends
 919       com.google.protobuf.GeneratedMessage
 920       implements RawMessageOrBuilder {
 921     // Use RawMessage.newBuilder() to construct.
 922     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 923       super(builder);
 924       this.unknownFields = builder.getUnknownFields();
 925     }
 926     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 927
 928     private static final RawMessage defaultInstance;
 929     public static RawMessage getDefaultInstance() {
 930       return defaultInstance;
 931     }
 932
 933     public RawMessage getDefaultInstanceForType() {
 934       return defaultInstance;
 935     }
 936
 937     private final com.google.protobuf.UnknownFieldSet unknownFields;
 938     @java.lang.Override
 939     public final com.google.protobuf.UnknownFieldSet
 940         getUnknownFields() {
 941       return this.unknownFields;
 942     }
 943     private RawMessage(
 944         com.google.protobuf.CodedInputStream input,
 945         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 946         throws com.google.protobuf.InvalidProtocolBufferException {
 947       initFields();
 948       int mutable_bitField0_ = 0;
 949       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 950           com.google.protobuf.UnknownFieldSet.newBuilder();
 951       try {
 952         boolean done = false;
 953         while (!done) {
 954           int tag = input.readTag();
 955           switch (tag) {
 956             case 0:
 957               done = true;
 958               break;
 959             default: {
 960               if (!parseUnknownField(input, unknownFields,
 961                                      extensionRegistry, tag)) {
 962                 done = true;
 963               }
 964               break;
 965             }
 966             case 8: {
 967               bitField0_ |= 0x00000001;
 968               bus_ = input.readInt32();
 969               break;
 970             }
 971             case 16: {
 972               bitField0_ |= 0x00000002;
 973               messageId_ = input.readUInt32();
 974               break;
 975             }
 976             case 24: {
 977               bitField0_ |= 0x00000004;
 978               data_ = input.readUInt64();
 979               break;
 980             }
 981           }
 982         }
 983       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 984         throw e.setUnfinishedMessage(this);
 985       } catch (java.io.IOException e) {
 986         throw new com.google.protobuf.InvalidProtocolBufferException(
 987             e.getMessage()).setUnfinishedMessage(this);
 988       } finally {
 989         this.unknownFields = unknownFields.build();
 990         makeExtensionsImmutable();
 991       }
 992     }
 993     public static final com.google.protobuf.Descriptors.Descriptor
 994         getDescriptor() {
 995       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
 996     }
 997
 998     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 999         internalGetFieldAccessorTable() {
1000       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1001           .ensureFieldAccessorsInitialized(
1002               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1003     }
1004
1005     public static com.google.protobuf.Parser<RawMessage> PARSER =
1006         new com.google.protobuf.AbstractParser<RawMessage>() {
1007       public RawMessage parsePartialFrom(
1008           com.google.protobuf.CodedInputStream input,
1009           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1010           throws com.google.protobuf.InvalidProtocolBufferException {
1011         return new RawMessage(input, extensionRegistry);
1012       }
1013     };
1014
1015     @java.lang.Override
1016     public com.google.protobuf.Parser<RawMessage> getParserForType() {
1017       return PARSER;
1018     }
1019
1020     private int bitField0_;
1021     // optional int32 bus = 1;
1022     public static final int BUS_FIELD_NUMBER = 1;
1023     private int bus_;
1024     /**
1025      * <code>optional int32 bus = 1;</code>
1026      */
1027     public boolean hasBus() {
1028       return ((bitField0_ & 0x00000001) == 0x00000001);
1029     }
1030     /**
1031      * <code>optional int32 bus = 1;</code>
1032      */
1033     public int getBus() {
1034       return bus_;
1035     }
1036
1037     // optional uint32 message_id = 2;
1038     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
1039     private int messageId_;
1040     /**
1041      * <code>optional uint32 message_id = 2;</code>
1042      */
1043     public boolean hasMessageId() {
1044       return ((bitField0_ & 0x00000002) == 0x00000002);
1045     }
1046     /**
1047      * <code>optional uint32 message_id = 2;</code>
1048      */
1049     public int getMessageId() {
1050       return messageId_;
1051     }
1052
1053     // optional uint64 data = 3;
1054     public static final int DATA_FIELD_NUMBER = 3;
1055     private long data_;
1056     /**
1057      * <code>optional uint64 data = 3;</code>
1058      */
1059     public boolean hasData() {
1060       return ((bitField0_ & 0x00000004) == 0x00000004);
1061     }
1062     /**
1063      * <code>optional uint64 data = 3;</code>
1064      */
1065     public long getData() {
1066       return data_;
1067     }
1068
1069     private void initFields() {
1070       bus_ = 0;
1071       messageId_ = 0;
1072       data_ = 0L;
1073     }
1074     private byte memoizedIsInitialized = -1;
1075     public final boolean isInitialized() {
1076       byte isInitialized = memoizedIsInitialized;
1077       if (isInitialized != -1) return isInitialized == 1;
1078
1079       memoizedIsInitialized = 1;
1080       return true;
1081     }
1082
1083     public void writeTo(com.google.protobuf.CodedOutputStream output)
1084                         throws java.io.IOException {
1085       getSerializedSize();
1086       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1087         output.writeInt32(1, bus_);
1088       }
1089       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1090         output.writeUInt32(2, messageId_);
1091       }
1092       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1093         output.writeUInt64(3, data_);
1094       }
1095       getUnknownFields().writeTo(output);
1096     }
1097
1098     private int memoizedSerializedSize = -1;
1099     public int getSerializedSize() {
1100       int size = memoizedSerializedSize;
1101       if (size != -1) return size;
1102
1103       size = 0;
1104       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1105         size += com.google.protobuf.CodedOutputStream
1106           .computeInt32Size(1, bus_);
1107       }
1108       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1109         size += com.google.protobuf.CodedOutputStream
1110           .computeUInt32Size(2, messageId_);
1111       }
1112       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1113         size += com.google.protobuf.CodedOutputStream
1114           .computeUInt64Size(3, data_);
1115       }
1116       size += getUnknownFields().getSerializedSize();
1117       memoizedSerializedSize = size;
1118       return size;
1119     }
1120
1121     private static final long serialVersionUID = 0L;
1122     @java.lang.Override
1123     protected java.lang.Object writeReplace()
1124         throws java.io.ObjectStreamException {
1125       return super.writeReplace();
1126     }
1127
1128     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1129         com.google.protobuf.ByteString data)
1130         throws com.google.protobuf.InvalidProtocolBufferException {
1131       return PARSER.parseFrom(data);
1132     }
1133     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1134         com.google.protobuf.ByteString data,
1135         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1136         throws com.google.protobuf.InvalidProtocolBufferException {
1137       return PARSER.parseFrom(data, extensionRegistry);
1138     }
1139     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
1140         throws com.google.protobuf.InvalidProtocolBufferException {
1141       return PARSER.parseFrom(data);
1142     }
1143     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1144         byte[] data,
1145         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1146         throws com.google.protobuf.InvalidProtocolBufferException {
1147       return PARSER.parseFrom(data, extensionRegistry);
1148     }
1149     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
1150         throws java.io.IOException {
1151       return PARSER.parseFrom(input);
1152     }
1153     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1154         java.io.InputStream input,
1155         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1156         throws java.io.IOException {
1157       return PARSER.parseFrom(input, extensionRegistry);
1158     }
1159     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
1160         throws java.io.IOException {
1161       return PARSER.parseDelimitedFrom(input);
1162     }
1163     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
1164         java.io.InputStream input,
1165         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1166         throws java.io.IOException {
1167       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1168     }
1169     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1170         com.google.protobuf.CodedInputStream input)
1171         throws java.io.IOException {
1172       return PARSER.parseFrom(input);
1173     }
1174     public static com.openxc.BinaryMessages.RawMessage parseFrom(
1175         com.google.protobuf.CodedInputStream input,
1176         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1177         throws java.io.IOException {
1178       return PARSER.parseFrom(input, extensionRegistry);
1179     }
1180
1181     public static Builder newBuilder() { return Builder.create(); }
1182     public Builder newBuilderForType() { return newBuilder(); }
1183     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
1184       return newBuilder().mergeFrom(prototype);
1185     }
1186     public Builder toBuilder() { return newBuilder(this); }
1187
1188     @java.lang.Override
1189     protected Builder newBuilderForType(
1190         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1191       Builder builder = new Builder(parent);
1192       return builder;
1193     }
1194     /**
1195      * Protobuf type {@code openxc.RawMessage}
1196      */
1197     public static final class Builder extends
1198         com.google.protobuf.GeneratedMessage.Builder<Builder>
1199        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
1200       public static final com.google.protobuf.Descriptors.Descriptor
1201           getDescriptor() {
1202         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1203       }
1204
1205       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1206           internalGetFieldAccessorTable() {
1207         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1208             .ensureFieldAccessorsInitialized(
1209                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1210       }
1211
1212       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
1213       private Builder() {
1214         maybeForceBuilderInitialization();
1215       }
1216
1217       private Builder(
1218           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
1219         super(parent);
1220         maybeForceBuilderInitialization();
1221       }
1222       private void maybeForceBuilderInitialization() {
1223         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
1224         }
1225       }
1226       private static Builder create() {
1227         return new Builder();
1228       }
1229
1230       public Builder clear() {
1231         super.clear();
1232         bus_ = 0;
1233         bitField0_ = (bitField0_ & ~0x00000001);
1234         messageId_ = 0;
1235         bitField0_ = (bitField0_ & ~0x00000002);
1236         data_ = 0L;
1237         bitField0_ = (bitField0_ & ~0x00000004);
1238         return this;
1239       }
1240
1241       public Builder clone() {
1242         return create().mergeFrom(buildPartial());
1243       }
1244
1245       public com.google.protobuf.Descriptors.Descriptor
1246           getDescriptorForType() {
1247         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1248       }
1249
1250       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
1251         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1252       }
1253
1254       public com.openxc.BinaryMessages.RawMessage build() {
1255         com.openxc.BinaryMessages.RawMessage result = buildPartial();
1256         if (!result.isInitialized()) {
1257           throw newUninitializedMessageException(result);
1258         }
1259         return result;
1260       }
1261
1262       public com.openxc.BinaryMessages.RawMessage buildPartial() {
1263         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
1264         int from_bitField0_ = bitField0_;
1265         int to_bitField0_ = 0;
1266         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
1267           to_bitField0_ |= 0x00000001;
1268         }
1269         result.bus_ = bus_;
1270         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
1271           to_bitField0_ |= 0x00000002;
1272         }
1273         result.messageId_ = messageId_;
1274         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
1275           to_bitField0_ |= 0x00000004;
1276         }
1277         result.data_ = data_;
1278         result.bitField0_ = to_bitField0_;
1279         onBuilt();
1280         return result;
1281       }
1282
1283       public Builder mergeFrom(com.google.protobuf.Message other) {
1284         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
1285           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
1286         } else {
1287           super.mergeFrom(other);
1288           return this;
1289         }
1290       }
1291
1292       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
1293         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
1294         if (other.hasBus()) {
1295           setBus(other.getBus());
1296         }
1297         if (other.hasMessageId()) {
1298           setMessageId(other.getMessageId());
1299         }
1300         if (other.hasData()) {
1301           setData(other.getData());
1302         }
1303         this.mergeUnknownFields(other.getUnknownFields());
1304         return this;
1305       }
1306
1307       public final boolean isInitialized() {
1308         return true;
1309       }
1310
1311       public Builder mergeFrom(
1312           com.google.protobuf.CodedInputStream input,
1313           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1314           throws java.io.IOException {
1315         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
1316         try {
1317           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1318         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1319           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
1320           throw e;
1321         } finally {
1322           if (parsedMessage != null) {
1323             mergeFrom(parsedMessage);
1324           }
1325         }
1326         return this;
1327       }
1328       private int bitField0_;
1329
1330       // optional int32 bus = 1;
1331       private int bus_ ;
1332       /**
1333        * <code>optional int32 bus = 1;</code>
1334        */
1335       public boolean hasBus() {
1336         return ((bitField0_ & 0x00000001) == 0x00000001);
1337       }
1338       /**
1339        * <code>optional int32 bus = 1;</code>
1340        */
1341       public int getBus() {
1342         return bus_;
1343       }
1344       /**
1345        * <code>optional int32 bus = 1;</code>
1346        */
1347       public Builder setBus(int value) {
1348         bitField0_ |= 0x00000001;
1349         bus_ = value;
1350         onChanged();
1351         return this;
1352       }
1353       /**
1354        * <code>optional int32 bus = 1;</code>
1355        */
1356       public Builder clearBus() {
1357         bitField0_ = (bitField0_ & ~0x00000001);
1358         bus_ = 0;
1359         onChanged();
1360         return this;
1361       }
1362
1363       // optional uint32 message_id = 2;
1364       private int messageId_ ;
1365       /**
1366        * <code>optional uint32 message_id = 2;</code>
1367        */
1368       public boolean hasMessageId() {
1369         return ((bitField0_ & 0x00000002) == 0x00000002);
1370       }
1371       /**
1372        * <code>optional uint32 message_id = 2;</code>
1373        */
1374       public int getMessageId() {
1375         return messageId_;
1376       }
1377       /**
1378        * <code>optional uint32 message_id = 2;</code>
1379        */
1380       public Builder setMessageId(int value) {
1381         bitField0_ |= 0x00000002;
1382         messageId_ = value;
1383         onChanged();
1384         return this;
1385       }
1386       /**
1387        * <code>optional uint32 message_id = 2;</code>
1388        */
1389       public Builder clearMessageId() {
1390         bitField0_ = (bitField0_ & ~0x00000002);
1391         messageId_ = 0;
1392         onChanged();
1393         return this;
1394       }
1395
1396       // optional uint64 data = 3;
1397       private long data_ ;
1398       /**
1399        * <code>optional uint64 data = 3;</code>
1400        */
1401       public boolean hasData() {
1402         return ((bitField0_ & 0x00000004) == 0x00000004);
1403       }
1404       /**
1405        * <code>optional uint64 data = 3;</code>
1406        */
1407       public long getData() {
1408         return data_;
1409       }
1410       /**
1411        * <code>optional uint64 data = 3;</code>
1412        */
1413       public Builder setData(long value) {
1414         bitField0_ |= 0x00000004;
1415         data_ = value;
1416         onChanged();
1417         return this;
1418       }
1419       /**
1420        * <code>optional uint64 data = 3;</code>
1421        */
1422       public Builder clearData() {
1423         bitField0_ = (bitField0_ & ~0x00000004);
1424         data_ = 0L;
1425         onChanged();
1426         return this;
1427       }
1428
1429       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
1430     }
1431
1432     static {
1433       defaultInstance = new RawMessage(true);
1434       defaultInstance.initFields();
1435     }
1436
1437     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
1438   }
1439
1440   public interface TranslatedMessageOrBuilder
1441       extends com.google.protobuf.MessageOrBuilder {
1442
1443     // optional string name = 1;
1444     /**
1445      * <code>optional string name = 1;</code>
1446      */
1447     boolean hasName();
1448     /**
1449      * <code>optional string name = 1;</code>
1450      */
1451     java.lang.String getName();
1452     /**
1453      * <code>optional string name = 1;</code>
1454      */
1455     com.google.protobuf.ByteString
1456         getNameBytes();
1457
1458     // optional string string_value = 2;
1459     /**
1460      * <code>optional string string_value = 2;</code>
1461      */
1462     boolean hasStringValue();
1463     /**
1464      * <code>optional string string_value = 2;</code>
1465      */
1466     java.lang.String getStringValue();
1467     /**
1468      * <code>optional string string_value = 2;</code>
1469      */
1470     com.google.protobuf.ByteString
1471         getStringValueBytes();
1472
1473     // optional double numerical_value = 3;
1474     /**
1475      * <code>optional double numerical_value = 3;</code>
1476      */
1477     boolean hasNumericalValue();
1478     /**
1479      * <code>optional double numerical_value = 3;</code>
1480      */
1481     double getNumericalValue();
1482
1483     // optional bool boolean_value = 4;
1484     /**
1485      * <code>optional bool boolean_value = 4;</code>
1486      */
1487     boolean hasBooleanValue();
1488     /**
1489      * <code>optional bool boolean_value = 4;</code>
1490      */
1491     boolean getBooleanValue();
1492
1493     // optional string string_event = 5;
1494     /**
1495      * <code>optional string string_event = 5;</code>
1496      */
1497     boolean hasStringEvent();
1498     /**
1499      * <code>optional string string_event = 5;</code>
1500      */
1501     java.lang.String getStringEvent();
1502     /**
1503      * <code>optional string string_event = 5;</code>
1504      */
1505     com.google.protobuf.ByteString
1506         getStringEventBytes();
1507
1508     // optional double numerical_event = 6;
1509     /**
1510      * <code>optional double numerical_event = 6;</code>
1511      */
1512     boolean hasNumericalEvent();
1513     /**
1514      * <code>optional double numerical_event = 6;</code>
1515      */
1516     double getNumericalEvent();
1517
1518     // optional bool boolean_event = 7;
1519     /**
1520      * <code>optional bool boolean_event = 7;</code>
1521      */
1522     boolean hasBooleanEvent();
1523     /**
1524      * <code>optional bool boolean_event = 7;</code>
1525      */
1526     boolean getBooleanEvent();
1527   }
1528   /**
1529    * Protobuf type {@code openxc.TranslatedMessage}
1530    */
1531   public static final class TranslatedMessage extends
1532       com.google.protobuf.GeneratedMessage
1533       implements TranslatedMessageOrBuilder {
1534     // Use TranslatedMessage.newBuilder() to construct.
1535     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1536       super(builder);
1537       this.unknownFields = builder.getUnknownFields();
1538     }
1539     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1540
1541     private static final TranslatedMessage defaultInstance;
1542     public static TranslatedMessage getDefaultInstance() {
1543       return defaultInstance;
1544     }
1545
1546     public TranslatedMessage getDefaultInstanceForType() {
1547       return defaultInstance;
1548     }
1549
1550     private final com.google.protobuf.UnknownFieldSet unknownFields;
1551     @java.lang.Override
1552     public final com.google.protobuf.UnknownFieldSet
1553         getUnknownFields() {
1554       return this.unknownFields;
1555     }
1556     private TranslatedMessage(
1557         com.google.protobuf.CodedInputStream input,
1558         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1559         throws com.google.protobuf.InvalidProtocolBufferException {
1560       initFields();
1561       int mutable_bitField0_ = 0;
1562       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1563           com.google.protobuf.UnknownFieldSet.newBuilder();
1564       try {
1565         boolean done = false;
1566         while (!done) {
1567           int tag = input.readTag();
1568           switch (tag) {
1569             case 0:
1570               done = true;
1571               break;
1572             default: {
1573               if (!parseUnknownField(input, unknownFields,
1574                                      extensionRegistry, tag)) {
1575                 done = true;
1576               }
1577               break;
1578             }
1579             case 10: {
1580               bitField0_ |= 0x00000001;
1581               name_ = input.readBytes();
1582               break;
1583             }
1584             case 18: {
1585               bitField0_ |= 0x00000002;
1586               stringValue_ = input.readBytes();
1587               break;
1588             }
1589             case 25: {
1590               bitField0_ |= 0x00000004;
1591               numericalValue_ = input.readDouble();
1592               break;
1593             }
1594             case 32: {
1595               bitField0_ |= 0x00000008;
1596               booleanValue_ = input.readBool();
1597               break;
1598             }
1599             case 42: {
1600               bitField0_ |= 0x00000010;
1601               stringEvent_ = input.readBytes();
1602               break;
1603             }
1604             case 49: {
1605               bitField0_ |= 0x00000020;
1606               numericalEvent_ = input.readDouble();
1607               break;
1608             }
1609             case 56: {
1610               bitField0_ |= 0x00000040;
1611               booleanEvent_ = input.readBool();
1612               break;
1613             }
1614           }
1615         }
1616       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1617         throw e.setUnfinishedMessage(this);
1618       } catch (java.io.IOException e) {
1619         throw new com.google.protobuf.InvalidProtocolBufferException(
1620             e.getMessage()).setUnfinishedMessage(this);
1621       } finally {
1622         this.unknownFields = unknownFields.build();
1623         makeExtensionsImmutable();
1624       }
1625     }
1626     public static final com.google.protobuf.Descriptors.Descriptor
1627         getDescriptor() {
1628       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
1629     }
1630
1631     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1632         internalGetFieldAccessorTable() {
1633       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
1634           .ensureFieldAccessorsInitialized(
1635               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
1636     }
1637
1638     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
1639         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
1640       public TranslatedMessage parsePartialFrom(
1641           com.google.protobuf.CodedInputStream input,
1642           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1643           throws com.google.protobuf.InvalidProtocolBufferException {
1644         return new TranslatedMessage(input, extensionRegistry);
1645       }
1646     };
1647
1648     @java.lang.Override
1649     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
1650       return PARSER;
1651     }
1652
1653     private int bitField0_;
1654     // optional string name = 1;
1655     public static final int NAME_FIELD_NUMBER = 1;
1656     private java.lang.Object name_;
1657     /**
1658      * <code>optional string name = 1;</code>
1659      */
1660     public boolean hasName() {
1661       return ((bitField0_ & 0x00000001) == 0x00000001);
1662     }
1663     /**
1664      * <code>optional string name = 1;</code>
1665      */
1666     public java.lang.String getName() {
1667       java.lang.Object ref = name_;
1668       if (ref instanceof java.lang.String) {
1669         return (java.lang.String) ref;
1670       } else {
1671         com.google.protobuf.ByteString bs =
1672             (com.google.protobuf.ByteString) ref;
1673         java.lang.String s = bs.toStringUtf8();
1674         if (bs.isValidUtf8()) {
1675           name_ = s;
1676         }
1677         return s;
1678       }
1679     }
1680     /**
1681      * <code>optional string name = 1;</code>
1682      */
1683     public com.google.protobuf.ByteString
1684         getNameBytes() {
1685       java.lang.Object ref = name_;
1686       if (ref instanceof java.lang.String) {
1687         com.google.protobuf.ByteString b =
1688             com.google.protobuf.ByteString.copyFromUtf8(
1689                 (java.lang.String) ref);
1690         name_ = b;
1691         return b;
1692       } else {
1693         return (com.google.protobuf.ByteString) ref;
1694       }
1695     }
1696
1697     // optional string string_value = 2;
1698     public static final int STRING_VALUE_FIELD_NUMBER = 2;
1699     private java.lang.Object stringValue_;
1700     /**
1701      * <code>optional string string_value = 2;</code>
1702      */
1703     public boolean hasStringValue() {
1704       return ((bitField0_ & 0x00000002) == 0x00000002);
1705     }
1706     /**
1707      * <code>optional string string_value = 2;</code>
1708      */
1709     public java.lang.String getStringValue() {
1710       java.lang.Object ref = stringValue_;
1711       if (ref instanceof java.lang.String) {
1712         return (java.lang.String) ref;
1713       } else {
1714         com.google.protobuf.ByteString bs =
1715             (com.google.protobuf.ByteString) ref;
1716         java.lang.String s = bs.toStringUtf8();
1717         if (bs.isValidUtf8()) {
1718           stringValue_ = s;
1719         }
1720         return s;
1721       }
1722     }
1723     /**
1724      * <code>optional string string_value = 2;</code>
1725      */
1726     public com.google.protobuf.ByteString
1727         getStringValueBytes() {
1728       java.lang.Object ref = stringValue_;
1729       if (ref instanceof java.lang.String) {
1730         com.google.protobuf.ByteString b =
1731             com.google.protobuf.ByteString.copyFromUtf8(
1732                 (java.lang.String) ref);
1733         stringValue_ = b;
1734         return b;
1735       } else {
1736         return (com.google.protobuf.ByteString) ref;
1737       }
1738     }
1739
1740     // optional double numerical_value = 3;
1741     public static final int NUMERICAL_VALUE_FIELD_NUMBER = 3;
1742     private double numericalValue_;
1743     /**
1744      * <code>optional double numerical_value = 3;</code>
1745      */
1746     public boolean hasNumericalValue() {
1747       return ((bitField0_ & 0x00000004) == 0x00000004);
1748     }
1749     /**
1750      * <code>optional double numerical_value = 3;</code>
1751      */
1752     public double getNumericalValue() {
1753       return numericalValue_;
1754     }
1755
1756     // optional bool boolean_value = 4;
1757     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 4;
1758     private boolean booleanValue_;
1759     /**
1760      * <code>optional bool boolean_value = 4;</code>
1761      */
1762     public boolean hasBooleanValue() {
1763       return ((bitField0_ & 0x00000008) == 0x00000008);
1764     }
1765     /**
1766      * <code>optional bool boolean_value = 4;</code>
1767      */
1768     public boolean getBooleanValue() {
1769       return booleanValue_;
1770     }
1771
1772     // optional string string_event = 5;
1773     public static final int STRING_EVENT_FIELD_NUMBER = 5;
1774     private java.lang.Object stringEvent_;
1775     /**
1776      * <code>optional string string_event = 5;</code>
1777      */
1778     public boolean hasStringEvent() {
1779       return ((bitField0_ & 0x00000010) == 0x00000010);
1780     }
1781     /**
1782      * <code>optional string string_event = 5;</code>
1783      */
1784     public java.lang.String getStringEvent() {
1785       java.lang.Object ref = stringEvent_;
1786       if (ref instanceof java.lang.String) {
1787         return (java.lang.String) ref;
1788       } else {
1789         com.google.protobuf.ByteString bs =
1790             (com.google.protobuf.ByteString) ref;
1791         java.lang.String s = bs.toStringUtf8();
1792         if (bs.isValidUtf8()) {
1793           stringEvent_ = s;
1794         }
1795         return s;
1796       }
1797     }
1798     /**
1799      * <code>optional string string_event = 5;</code>
1800      */
1801     public com.google.protobuf.ByteString
1802         getStringEventBytes() {
1803       java.lang.Object ref = stringEvent_;
1804       if (ref instanceof java.lang.String) {
1805         com.google.protobuf.ByteString b =
1806             com.google.protobuf.ByteString.copyFromUtf8(
1807                 (java.lang.String) ref);
1808         stringEvent_ = b;
1809         return b;
1810       } else {
1811         return (com.google.protobuf.ByteString) ref;
1812       }
1813     }
1814
1815     // optional double numerical_event = 6;
1816     public static final int NUMERICAL_EVENT_FIELD_NUMBER = 6;
1817     private double numericalEvent_;
1818     /**
1819      * <code>optional double numerical_event = 6;</code>
1820      */
1821     public boolean hasNumericalEvent() {
1822       return ((bitField0_ & 0x00000020) == 0x00000020);
1823     }
1824     /**
1825      * <code>optional double numerical_event = 6;</code>
1826      */
1827     public double getNumericalEvent() {
1828       return numericalEvent_;
1829     }
1830
1831     // optional bool boolean_event = 7;
1832     public static final int BOOLEAN_EVENT_FIELD_NUMBER = 7;
1833     private boolean booleanEvent_;
1834     /**
1835      * <code>optional bool boolean_event = 7;</code>
1836      */
1837     public boolean hasBooleanEvent() {
1838       return ((bitField0_ & 0x00000040) == 0x00000040);
1839     }
1840     /**
1841      * <code>optional bool boolean_event = 7;</code>
1842      */
1843     public boolean getBooleanEvent() {
1844       return booleanEvent_;
1845     }
1846
1847     private void initFields() {
1848       name_ = "";
1849       stringValue_ = "";
1850       numericalValue_ = 0D;
1851       booleanValue_ = false;
1852       stringEvent_ = "";
1853       numericalEvent_ = 0D;
1854       booleanEvent_ = false;
1855     }
1856     private byte memoizedIsInitialized = -1;
1857     public final boolean isInitialized() {
1858       byte isInitialized = memoizedIsInitialized;
1859       if (isInitialized != -1) return isInitialized == 1;
1860
1861       memoizedIsInitialized = 1;
1862       return true;
1863     }
1864
1865     public void writeTo(com.google.protobuf.CodedOutputStream output)
1866                         throws java.io.IOException {
1867       getSerializedSize();
1868       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1869         output.writeBytes(1, getNameBytes());
1870       }
1871       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1872         output.writeBytes(2, getStringValueBytes());
1873       }
1874       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1875         output.writeDouble(3, numericalValue_);
1876       }
1877       if (((bitField0_ & 0x00000008) == 0x00000008)) {
1878         output.writeBool(4, booleanValue_);
1879       }
1880       if (((bitField0_ & 0x00000010) == 0x00000010)) {
1881         output.writeBytes(5, getStringEventBytes());
1882       }
1883       if (((bitField0_ & 0x00000020) == 0x00000020)) {
1884         output.writeDouble(6, numericalEvent_);
1885       }
1886       if (((bitField0_ & 0x00000040) == 0x00000040)) {
1887         output.writeBool(7, booleanEvent_);
1888       }
1889       getUnknownFields().writeTo(output);
1890     }
1891
1892     private int memoizedSerializedSize = -1;
1893     public int getSerializedSize() {
1894       int size = memoizedSerializedSize;
1895       if (size != -1) return size;
1896
1897       size = 0;
1898       if (((bitField0_ & 0x00000001) == 0x00000001)) {
1899         size += com.google.protobuf.CodedOutputStream
1900           .computeBytesSize(1, getNameBytes());
1901       }
1902       if (((bitField0_ & 0x00000002) == 0x00000002)) {
1903         size += com.google.protobuf.CodedOutputStream
1904           .computeBytesSize(2, getStringValueBytes());
1905       }
1906       if (((bitField0_ & 0x00000004) == 0x00000004)) {
1907         size += com.google.protobuf.CodedOutputStream
1908           .computeDoubleSize(3, numericalValue_);
1909       }
1910       if (((bitField0_ & 0x00000008) == 0x00000008)) {
1911         size += com.google.protobuf.CodedOutputStream
1912           .computeBoolSize(4, booleanValue_);
1913       }
1914       if (((bitField0_ & 0x00000010) == 0x00000010)) {
1915         size += com.google.protobuf.CodedOutputStream
1916           .computeBytesSize(5, getStringEventBytes());
1917       }
1918       if (((bitField0_ & 0x00000020) == 0x00000020)) {
1919         size += com.google.protobuf.CodedOutputStream
1920           .computeDoubleSize(6, numericalEvent_);
1921       }
1922       if (((bitField0_ & 0x00000040) == 0x00000040)) {
1923         size += com.google.protobuf.CodedOutputStream
1924           .computeBoolSize(7, booleanEvent_);
1925       }
1926       size += getUnknownFields().getSerializedSize();
1927       memoizedSerializedSize = size;
1928       return size;
1929     }
1930
1931     private static final long serialVersionUID = 0L;
1932     @java.lang.Override
1933     protected java.lang.Object writeReplace()
1934         throws java.io.ObjectStreamException {
1935       return super.writeReplace();
1936     }
1937
1938     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
1939         com.google.protobuf.ByteString data)
1940         throws com.google.protobuf.InvalidProtocolBufferException {
1941       return PARSER.parseFrom(data);
1942     }
1943     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
1944         com.google.protobuf.ByteString data,
1945         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1946         throws com.google.protobuf.InvalidProtocolBufferException {
1947       return PARSER.parseFrom(data, extensionRegistry);
1948     }
1949     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
1950         throws com.google.protobuf.InvalidProtocolBufferException {
1951       return PARSER.parseFrom(data);
1952     }
1953     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
1954         byte[] data,
1955         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1956         throws com.google.protobuf.InvalidProtocolBufferException {
1957       return PARSER.parseFrom(data, extensionRegistry);
1958     }
1959     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
1960         throws java.io.IOException {
1961       return PARSER.parseFrom(input);
1962     }
1963     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
1964         java.io.InputStream input,
1965         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1966         throws java.io.IOException {
1967       return PARSER.parseFrom(input, extensionRegistry);
1968     }
1969     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
1970         throws java.io.IOException {
1971       return PARSER.parseDelimitedFrom(input);
1972     }
1973     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
1974         java.io.InputStream input,
1975         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1976         throws java.io.IOException {
1977       return PARSER.parseDelimitedFrom(input, extensionRegistry);
1978     }
1979     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
1980         com.google.protobuf.CodedInputStream input)
1981         throws java.io.IOException {
1982       return PARSER.parseFrom(input);
1983     }
1984     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
1985         com.google.protobuf.CodedInputStream input,
1986         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1987         throws java.io.IOException {
1988       return PARSER.parseFrom(input, extensionRegistry);
1989     }
1990
1991     public static Builder newBuilder() { return Builder.create(); }
1992     public Builder newBuilderForType() { return newBuilder(); }
1993     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
1994       return newBuilder().mergeFrom(prototype);
1995     }
1996     public Builder toBuilder() { return newBuilder(this); }
1997
1998     @java.lang.Override
1999     protected Builder newBuilderForType(
2000         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2001       Builder builder = new Builder(parent);
2002       return builder;
2003     }
2004     /**
2005      * Protobuf type {@code openxc.TranslatedMessage}
2006      */
2007     public static final class Builder extends
2008         com.google.protobuf.GeneratedMessage.Builder<Builder>
2009        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
2010       public static final com.google.protobuf.Descriptors.Descriptor
2011           getDescriptor() {
2012         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
2013       }
2014
2015       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2016           internalGetFieldAccessorTable() {
2017         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
2018             .ensureFieldAccessorsInitialized(
2019                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
2020       }
2021
2022       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
2023       private Builder() {
2024         maybeForceBuilderInitialization();
2025       }
2026
2027       private Builder(
2028           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2029         super(parent);
2030         maybeForceBuilderInitialization();
2031       }
2032       private void maybeForceBuilderInitialization() {
2033         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2034         }
2035       }
2036       private static Builder create() {
2037         return new Builder();
2038       }
2039
2040       public Builder clear() {
2041         super.clear();
2042         name_ = "";
2043         bitField0_ = (bitField0_ & ~0x00000001);
2044         stringValue_ = "";
2045         bitField0_ = (bitField0_ & ~0x00000002);
2046         numericalValue_ = 0D;
2047         bitField0_ = (bitField0_ & ~0x00000004);
2048         booleanValue_ = false;
2049         bitField0_ = (bitField0_ & ~0x00000008);
2050         stringEvent_ = "";
2051         bitField0_ = (bitField0_ & ~0x00000010);
2052         numericalEvent_ = 0D;
2053         bitField0_ = (bitField0_ & ~0x00000020);
2054         booleanEvent_ = false;
2055         bitField0_ = (bitField0_ & ~0x00000040);
2056         return this;
2057       }
2058
2059       public Builder clone() {
2060         return create().mergeFrom(buildPartial());
2061       }
2062
2063       public com.google.protobuf.Descriptors.Descriptor
2064           getDescriptorForType() {
2065         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
2066       }
2067
2068       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
2069         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
2070       }
2071
2072       public com.openxc.BinaryMessages.TranslatedMessage build() {
2073         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
2074         if (!result.isInitialized()) {
2075           throw newUninitializedMessageException(result);
2076         }
2077         return result;
2078       }
2079
2080       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
2081         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
2082         int from_bitField0_ = bitField0_;
2083         int to_bitField0_ = 0;
2084         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2085           to_bitField0_ |= 0x00000001;
2086         }
2087         result.name_ = name_;
2088         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2089           to_bitField0_ |= 0x00000002;
2090         }
2091         result.stringValue_ = stringValue_;
2092         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2093           to_bitField0_ |= 0x00000004;
2094         }
2095         result.numericalValue_ = numericalValue_;
2096         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2097           to_bitField0_ |= 0x00000008;
2098         }
2099         result.booleanValue_ = booleanValue_;
2100         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2101           to_bitField0_ |= 0x00000010;
2102         }
2103         result.stringEvent_ = stringEvent_;
2104         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2105           to_bitField0_ |= 0x00000020;
2106         }
2107         result.numericalEvent_ = numericalEvent_;
2108         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2109           to_bitField0_ |= 0x00000040;
2110         }
2111         result.booleanEvent_ = booleanEvent_;
2112         result.bitField0_ = to_bitField0_;
2113         onBuilt();
2114         return result;
2115       }
2116
2117       public Builder mergeFrom(com.google.protobuf.Message other) {
2118         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
2119           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
2120         } else {
2121           super.mergeFrom(other);
2122           return this;
2123         }
2124       }
2125
2126       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
2127         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
2128         if (other.hasName()) {
2129           bitField0_ |= 0x00000001;
2130           name_ = other.name_;
2131           onChanged();
2132         }
2133         if (other.hasStringValue()) {
2134           bitField0_ |= 0x00000002;
2135           stringValue_ = other.stringValue_;
2136           onChanged();
2137         }
2138         if (other.hasNumericalValue()) {
2139           setNumericalValue(other.getNumericalValue());
2140         }
2141         if (other.hasBooleanValue()) {
2142           setBooleanValue(other.getBooleanValue());
2143         }
2144         if (other.hasStringEvent()) {
2145           bitField0_ |= 0x00000010;
2146           stringEvent_ = other.stringEvent_;
2147           onChanged();
2148         }
2149         if (other.hasNumericalEvent()) {
2150           setNumericalEvent(other.getNumericalEvent());
2151         }
2152         if (other.hasBooleanEvent()) {
2153           setBooleanEvent(other.getBooleanEvent());
2154         }
2155         this.mergeUnknownFields(other.getUnknownFields());
2156         return this;
2157       }
2158
2159       public final boolean isInitialized() {
2160         return true;
2161       }
2162
2163       public Builder mergeFrom(
2164           com.google.protobuf.CodedInputStream input,
2165           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2166           throws java.io.IOException {
2167         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
2168         try {
2169           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2170         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2171           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
2172           throw e;
2173         } finally {
2174           if (parsedMessage != null) {
2175             mergeFrom(parsedMessage);
2176           }
2177         }
2178         return this;
2179       }
2180       private int bitField0_;
2181
2182       // optional string name = 1;
2183       private java.lang.Object name_ = "";
2184       /**
2185        * <code>optional string name = 1;</code>
2186        */
2187       public boolean hasName() {
2188         return ((bitField0_ & 0x00000001) == 0x00000001);
2189       }
2190       /**
2191        * <code>optional string name = 1;</code>
2192        */
2193       public java.lang.String getName() {
2194         java.lang.Object ref = name_;
2195         if (!(ref instanceof java.lang.String)) {
2196           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2197               .toStringUtf8();
2198           name_ = s;
2199           return s;
2200         } else {
2201           return (java.lang.String) ref;
2202         }
2203       }
2204       /**
2205        * <code>optional string name = 1;</code>
2206        */
2207       public com.google.protobuf.ByteString
2208           getNameBytes() {
2209         java.lang.Object ref = name_;
2210         if (ref instanceof String) {
2211           com.google.protobuf.ByteString b =
2212               com.google.protobuf.ByteString.copyFromUtf8(
2213                   (java.lang.String) ref);
2214           name_ = b;
2215           return b;
2216         } else {
2217           return (com.google.protobuf.ByteString) ref;
2218         }
2219       }
2220       /**
2221        * <code>optional string name = 1;</code>
2222        */
2223       public Builder setName(
2224           java.lang.String value) {
2225         if (value == null) {
2226     throw new NullPointerException();
2227   }
2228   bitField0_ |= 0x00000001;
2229         name_ = value;
2230         onChanged();
2231         return this;
2232       }
2233       /**
2234        * <code>optional string name = 1;</code>
2235        */
2236       public Builder clearName() {
2237         bitField0_ = (bitField0_ & ~0x00000001);
2238         name_ = getDefaultInstance().getName();
2239         onChanged();
2240         return this;
2241       }
2242       /**
2243        * <code>optional string name = 1;</code>
2244        */
2245       public Builder setNameBytes(
2246           com.google.protobuf.ByteString value) {
2247         if (value == null) {
2248     throw new NullPointerException();
2249   }
2250   bitField0_ |= 0x00000001;
2251         name_ = value;
2252         onChanged();
2253         return this;
2254       }
2255
2256       // optional string string_value = 2;
2257       private java.lang.Object stringValue_ = "";
2258       /**
2259        * <code>optional string string_value = 2;</code>
2260        */
2261       public boolean hasStringValue() {
2262         return ((bitField0_ & 0x00000002) == 0x00000002);
2263       }
2264       /**
2265        * <code>optional string string_value = 2;</code>
2266        */
2267       public java.lang.String getStringValue() {
2268         java.lang.Object ref = stringValue_;
2269         if (!(ref instanceof java.lang.String)) {
2270           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2271               .toStringUtf8();
2272           stringValue_ = s;
2273           return s;
2274         } else {
2275           return (java.lang.String) ref;
2276         }
2277       }
2278       /**
2279        * <code>optional string string_value = 2;</code>
2280        */
2281       public com.google.protobuf.ByteString
2282           getStringValueBytes() {
2283         java.lang.Object ref = stringValue_;
2284         if (ref instanceof String) {
2285           com.google.protobuf.ByteString b =
2286               com.google.protobuf.ByteString.copyFromUtf8(
2287                   (java.lang.String) ref);
2288           stringValue_ = b;
2289           return b;
2290         } else {
2291           return (com.google.protobuf.ByteString) ref;
2292         }
2293       }
2294       /**
2295        * <code>optional string string_value = 2;</code>
2296        */
2297       public Builder setStringValue(
2298           java.lang.String value) {
2299         if (value == null) {
2300     throw new NullPointerException();
2301   }
2302   bitField0_ |= 0x00000002;
2303         stringValue_ = value;
2304         onChanged();
2305         return this;
2306       }
2307       /**
2308        * <code>optional string string_value = 2;</code>
2309        */
2310       public Builder clearStringValue() {
2311         bitField0_ = (bitField0_ & ~0x00000002);
2312         stringValue_ = getDefaultInstance().getStringValue();
2313         onChanged();
2314         return this;
2315       }
2316       /**
2317        * <code>optional string string_value = 2;</code>
2318        */
2319       public Builder setStringValueBytes(
2320           com.google.protobuf.ByteString value) {
2321         if (value == null) {
2322     throw new NullPointerException();
2323   }
2324   bitField0_ |= 0x00000002;
2325         stringValue_ = value;
2326         onChanged();
2327         return this;
2328       }
2329
2330       // optional double numerical_value = 3;
2331       private double numericalValue_ ;
2332       /**
2333        * <code>optional double numerical_value = 3;</code>
2334        */
2335       public boolean hasNumericalValue() {
2336         return ((bitField0_ & 0x00000004) == 0x00000004);
2337       }
2338       /**
2339        * <code>optional double numerical_value = 3;</code>
2340        */
2341       public double getNumericalValue() {
2342         return numericalValue_;
2343       }
2344       /**
2345        * <code>optional double numerical_value = 3;</code>
2346        */
2347       public Builder setNumericalValue(double value) {
2348         bitField0_ |= 0x00000004;
2349         numericalValue_ = value;
2350         onChanged();
2351         return this;
2352       }
2353       /**
2354        * <code>optional double numerical_value = 3;</code>
2355        */
2356       public Builder clearNumericalValue() {
2357         bitField0_ = (bitField0_ & ~0x00000004);
2358         numericalValue_ = 0D;
2359         onChanged();
2360         return this;
2361       }
2362
2363       // optional bool boolean_value = 4;
2364       private boolean booleanValue_ ;
2365       /**
2366        * <code>optional bool boolean_value = 4;</code>
2367        */
2368       public boolean hasBooleanValue() {
2369         return ((bitField0_ & 0x00000008) == 0x00000008);
2370       }
2371       /**
2372        * <code>optional bool boolean_value = 4;</code>
2373        */
2374       public boolean getBooleanValue() {
2375         return booleanValue_;
2376       }
2377       /**
2378        * <code>optional bool boolean_value = 4;</code>
2379        */
2380       public Builder setBooleanValue(boolean value) {
2381         bitField0_ |= 0x00000008;
2382         booleanValue_ = value;
2383         onChanged();
2384         return this;
2385       }
2386       /**
2387        * <code>optional bool boolean_value = 4;</code>
2388        */
2389       public Builder clearBooleanValue() {
2390         bitField0_ = (bitField0_ & ~0x00000008);
2391         booleanValue_ = false;
2392         onChanged();
2393         return this;
2394       }
2395
2396       // optional string string_event = 5;
2397       private java.lang.Object stringEvent_ = "";
2398       /**
2399        * <code>optional string string_event = 5;</code>
2400        */
2401       public boolean hasStringEvent() {
2402         return ((bitField0_ & 0x00000010) == 0x00000010);
2403       }
2404       /**
2405        * <code>optional string string_event = 5;</code>
2406        */
2407       public java.lang.String getStringEvent() {
2408         java.lang.Object ref = stringEvent_;
2409         if (!(ref instanceof java.lang.String)) {
2410           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2411               .toStringUtf8();
2412           stringEvent_ = s;
2413           return s;
2414         } else {
2415           return (java.lang.String) ref;
2416         }
2417       }
2418       /**
2419        * <code>optional string string_event = 5;</code>
2420        */
2421       public com.google.protobuf.ByteString
2422           getStringEventBytes() {
2423         java.lang.Object ref = stringEvent_;
2424         if (ref instanceof String) {
2425           com.google.protobuf.ByteString b =
2426               com.google.protobuf.ByteString.copyFromUtf8(
2427                   (java.lang.String) ref);
2428           stringEvent_ = b;
2429           return b;
2430         } else {
2431           return (com.google.protobuf.ByteString) ref;
2432         }
2433       }
2434       /**
2435        * <code>optional string string_event = 5;</code>
2436        */
2437       public Builder setStringEvent(
2438           java.lang.String value) {
2439         if (value == null) {
2440     throw new NullPointerException();
2441   }
2442   bitField0_ |= 0x00000010;
2443         stringEvent_ = value;
2444         onChanged();
2445         return this;
2446       }
2447       /**
2448        * <code>optional string string_event = 5;</code>
2449        */
2450       public Builder clearStringEvent() {
2451         bitField0_ = (bitField0_ & ~0x00000010);
2452         stringEvent_ = getDefaultInstance().getStringEvent();
2453         onChanged();
2454         return this;
2455       }
2456       /**
2457        * <code>optional string string_event = 5;</code>
2458        */
2459       public Builder setStringEventBytes(
2460           com.google.protobuf.ByteString value) {
2461         if (value == null) {
2462     throw new NullPointerException();
2463   }
2464   bitField0_ |= 0x00000010;
2465         stringEvent_ = value;
2466         onChanged();
2467         return this;
2468       }
2469
2470       // optional double numerical_event = 6;
2471       private double numericalEvent_ ;
2472       /**
2473        * <code>optional double numerical_event = 6;</code>
2474        */
2475       public boolean hasNumericalEvent() {
2476         return ((bitField0_ & 0x00000020) == 0x00000020);
2477       }
2478       /**
2479        * <code>optional double numerical_event = 6;</code>
2480        */
2481       public double getNumericalEvent() {
2482         return numericalEvent_;
2483       }
2484       /**
2485        * <code>optional double numerical_event = 6;</code>
2486        */
2487       public Builder setNumericalEvent(double value) {
2488         bitField0_ |= 0x00000020;
2489         numericalEvent_ = value;
2490         onChanged();
2491         return this;
2492       }
2493       /**
2494        * <code>optional double numerical_event = 6;</code>
2495        */
2496       public Builder clearNumericalEvent() {
2497         bitField0_ = (bitField0_ & ~0x00000020);
2498         numericalEvent_ = 0D;
2499         onChanged();
2500         return this;
2501       }
2502
2503       // optional bool boolean_event = 7;
2504       private boolean booleanEvent_ ;
2505       /**
2506        * <code>optional bool boolean_event = 7;</code>
2507        */
2508       public boolean hasBooleanEvent() {
2509         return ((bitField0_ & 0x00000040) == 0x00000040);
2510       }
2511       /**
2512        * <code>optional bool boolean_event = 7;</code>
2513        */
2514       public boolean getBooleanEvent() {
2515         return booleanEvent_;
2516       }
2517       /**
2518        * <code>optional bool boolean_event = 7;</code>
2519        */
2520       public Builder setBooleanEvent(boolean value) {
2521         bitField0_ |= 0x00000040;
2522         booleanEvent_ = value;
2523         onChanged();
2524         return this;
2525       }
2526       /**
2527        * <code>optional bool boolean_event = 7;</code>
2528        */
2529       public Builder clearBooleanEvent() {
2530         bitField0_ = (bitField0_ & ~0x00000040);
2531         booleanEvent_ = false;
2532         onChanged();
2533         return this;
2534       }
2535
2536       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
2537     }
2538
2539     static {
2540       defaultInstance = new TranslatedMessage(true);
2541       defaultInstance.initFields();
2542     }
2543
2544     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
2545   }
2546
2547   private static com.google.protobuf.Descriptors.Descriptor
2548     internal_static_openxc_VehicleMessage_descriptor;
2549   private static
2550     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2551       internal_static_openxc_VehicleMessage_fieldAccessorTable;
2552   private static com.google.protobuf.Descriptors.Descriptor
2553     internal_static_openxc_RawMessage_descriptor;
2554   private static
2555     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2556       internal_static_openxc_RawMessage_fieldAccessorTable;
2557   private static com.google.protobuf.Descriptors.Descriptor
2558     internal_static_openxc_TranslatedMessage_descriptor;
2559   private static
2560     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2561       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
2562
2563   public static com.google.protobuf.Descriptors.FileDescriptor
2564       getDescriptor() {
2565     return descriptor;
2566   }
2567   private static com.google.protobuf.Descriptors.FileDescriptor
2568       descriptor;
2569   static {
2570     java.lang.String[] descriptorData = {
2571       "\n\014openxc.proto\022\006openxc\"\274\001\n\016VehicleMessag" +
2572       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
2573       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
2574       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
2575       "xc.TranslatedMessage\"\037\n\004Type\022\007\n\003RAW\020\001\022\016\n" +
2576       "\nTRANSLATED\020\002\";\n\nRawMessage\022\013\n\003bus\030\001 \001(\005" +
2577       "\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004data\030\003 \001(\004\"\255\001\n\021T" +
2578       "ranslatedMessage\022\014\n\004name\030\001 \001(\t\022\024\n\014string" +
2579       "_value\030\002 \001(\t\022\027\n\017numerical_value\030\003 \001(\001\022\025\n" +
2580       "\rboolean_value\030\004 \001(\010\022\024\n\014string_event\030\005 \001",
2581       "(\t\022\027\n\017numerical_event\030\006 \001(\001\022\025\n\rboolean_e" +
2582       "vent\030\007 \001(\010B\034\n\ncom.openxcB\016BinaryMessages"
2583     };
2584     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
2585       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
2586         public com.google.protobuf.ExtensionRegistry assignDescriptors(
2587             com.google.protobuf.Descriptors.FileDescriptor root) {
2588           descriptor = root;
2589           internal_static_openxc_VehicleMessage_descriptor =
2590             getDescriptor().getMessageTypes().get(0);
2591           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
2592             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2593               internal_static_openxc_VehicleMessage_descriptor,
2594               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", });
2595           internal_static_openxc_RawMessage_descriptor =
2596             getDescriptor().getMessageTypes().get(1);
2597           internal_static_openxc_RawMessage_fieldAccessorTable = new
2598             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2599               internal_static_openxc_RawMessage_descriptor,
2600               new java.lang.String[] { "Bus", "MessageId", "Data", });
2601           internal_static_openxc_TranslatedMessage_descriptor =
2602             getDescriptor().getMessageTypes().get(2);
2603           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
2604             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2605               internal_static_openxc_TranslatedMessage_descriptor,
2606               new java.lang.String[] { "Name", "StringValue", "NumericalValue", "BooleanValue", "StringEvent", "NumericalEvent", "BooleanEvent", });
2607           return null;
2608         }
2609       };
2610     com.google.protobuf.Descriptors.FileDescriptor
2611       .internalBuildGeneratedFileFrom(descriptorData,
2612         new com.google.protobuf.Descriptors.FileDescriptor[] {
2613         }, assigner);
2614   }
2615
2616   // @@protoc_insertion_point(outer_class_scope)
2617 }