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 .openxc.TranslatedMessage.Type type = 1;
1444     /**
1445      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
1446      */
1447     boolean hasType();
1448     /**
1449      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
1450      */
1451     com.openxc.BinaryMessages.TranslatedMessage.Type getType();
1452
1453     // optional string name = 2;
1454     /**
1455      * <code>optional string name = 2;</code>
1456      */
1457     boolean hasName();
1458     /**
1459      * <code>optional string name = 2;</code>
1460      */
1461     java.lang.String getName();
1462     /**
1463      * <code>optional string name = 2;</code>
1464      */
1465     com.google.protobuf.ByteString
1466         getNameBytes();
1467
1468     // optional string string_value = 3;
1469     /**
1470      * <code>optional string string_value = 3;</code>
1471      */
1472     boolean hasStringValue();
1473     /**
1474      * <code>optional string string_value = 3;</code>
1475      */
1476     java.lang.String getStringValue();
1477     /**
1478      * <code>optional string string_value = 3;</code>
1479      */
1480     com.google.protobuf.ByteString
1481         getStringValueBytes();
1482
1483     // optional double numeric_value = 4;
1484     /**
1485      * <code>optional double numeric_value = 4;</code>
1486      */
1487     boolean hasNumericValue();
1488     /**
1489      * <code>optional double numeric_value = 4;</code>
1490      */
1491     double getNumericValue();
1492
1493     // optional bool boolean_value = 5;
1494     /**
1495      * <code>optional bool boolean_value = 5;</code>
1496      */
1497     boolean hasBooleanValue();
1498     /**
1499      * <code>optional bool boolean_value = 5;</code>
1500      */
1501     boolean getBooleanValue();
1502
1503     // optional string string_event = 6;
1504     /**
1505      * <code>optional string string_event = 6;</code>
1506      */
1507     boolean hasStringEvent();
1508     /**
1509      * <code>optional string string_event = 6;</code>
1510      */
1511     java.lang.String getStringEvent();
1512     /**
1513      * <code>optional string string_event = 6;</code>
1514      */
1515     com.google.protobuf.ByteString
1516         getStringEventBytes();
1517
1518     // optional double numeric_event = 7;
1519     /**
1520      * <code>optional double numeric_event = 7;</code>
1521      */
1522     boolean hasNumericEvent();
1523     /**
1524      * <code>optional double numeric_event = 7;</code>
1525      */
1526     double getNumericEvent();
1527
1528     // optional bool boolean_event = 8;
1529     /**
1530      * <code>optional bool boolean_event = 8;</code>
1531      */
1532     boolean hasBooleanEvent();
1533     /**
1534      * <code>optional bool boolean_event = 8;</code>
1535      */
1536     boolean getBooleanEvent();
1537   }
1538   /**
1539    * Protobuf type {@code openxc.TranslatedMessage}
1540    */
1541   public static final class TranslatedMessage extends
1542       com.google.protobuf.GeneratedMessage
1543       implements TranslatedMessageOrBuilder {
1544     // Use TranslatedMessage.newBuilder() to construct.
1545     private TranslatedMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1546       super(builder);
1547       this.unknownFields = builder.getUnknownFields();
1548     }
1549     private TranslatedMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1550
1551     private static final TranslatedMessage defaultInstance;
1552     public static TranslatedMessage getDefaultInstance() {
1553       return defaultInstance;
1554     }
1555
1556     public TranslatedMessage getDefaultInstanceForType() {
1557       return defaultInstance;
1558     }
1559
1560     private final com.google.protobuf.UnknownFieldSet unknownFields;
1561     @java.lang.Override
1562     public final com.google.protobuf.UnknownFieldSet
1563         getUnknownFields() {
1564       return this.unknownFields;
1565     }
1566     private TranslatedMessage(
1567         com.google.protobuf.CodedInputStream input,
1568         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1569         throws com.google.protobuf.InvalidProtocolBufferException {
1570       initFields();
1571       int mutable_bitField0_ = 0;
1572       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1573           com.google.protobuf.UnknownFieldSet.newBuilder();
1574       try {
1575         boolean done = false;
1576         while (!done) {
1577           int tag = input.readTag();
1578           switch (tag) {
1579             case 0:
1580               done = true;
1581               break;
1582             default: {
1583               if (!parseUnknownField(input, unknownFields,
1584                                      extensionRegistry, tag)) {
1585                 done = true;
1586               }
1587               break;
1588             }
1589             case 8: {
1590               int rawValue = input.readEnum();
1591               com.openxc.BinaryMessages.TranslatedMessage.Type value = com.openxc.BinaryMessages.TranslatedMessage.Type.valueOf(rawValue);
1592               if (value == null) {
1593                 unknownFields.mergeVarintField(1, rawValue);
1594               } else {
1595                 bitField0_ |= 0x00000001;
1596                 type_ = value;
1597               }
1598               break;
1599             }
1600             case 18: {
1601               bitField0_ |= 0x00000002;
1602               name_ = input.readBytes();
1603               break;
1604             }
1605             case 26: {
1606               bitField0_ |= 0x00000004;
1607               stringValue_ = input.readBytes();
1608               break;
1609             }
1610             case 33: {
1611               bitField0_ |= 0x00000008;
1612               numericValue_ = input.readDouble();
1613               break;
1614             }
1615             case 40: {
1616               bitField0_ |= 0x00000010;
1617               booleanValue_ = input.readBool();
1618               break;
1619             }
1620             case 50: {
1621               bitField0_ |= 0x00000020;
1622               stringEvent_ = input.readBytes();
1623               break;
1624             }
1625             case 57: {
1626               bitField0_ |= 0x00000040;
1627               numericEvent_ = input.readDouble();
1628               break;
1629             }
1630             case 64: {
1631               bitField0_ |= 0x00000080;
1632               booleanEvent_ = input.readBool();
1633               break;
1634             }
1635           }
1636         }
1637       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1638         throw e.setUnfinishedMessage(this);
1639       } catch (java.io.IOException e) {
1640         throw new com.google.protobuf.InvalidProtocolBufferException(
1641             e.getMessage()).setUnfinishedMessage(this);
1642       } finally {
1643         this.unknownFields = unknownFields.build();
1644         makeExtensionsImmutable();
1645       }
1646     }
1647     public static final com.google.protobuf.Descriptors.Descriptor
1648         getDescriptor() {
1649       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
1650     }
1651
1652     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1653         internalGetFieldAccessorTable() {
1654       return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
1655           .ensureFieldAccessorsInitialized(
1656               com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
1657     }
1658
1659     public static com.google.protobuf.Parser<TranslatedMessage> PARSER =
1660         new com.google.protobuf.AbstractParser<TranslatedMessage>() {
1661       public TranslatedMessage parsePartialFrom(
1662           com.google.protobuf.CodedInputStream input,
1663           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1664           throws com.google.protobuf.InvalidProtocolBufferException {
1665         return new TranslatedMessage(input, extensionRegistry);
1666       }
1667     };
1668
1669     @java.lang.Override
1670     public com.google.protobuf.Parser<TranslatedMessage> getParserForType() {
1671       return PARSER;
1672     }
1673
1674     /**
1675      * Protobuf enum {@code openxc.TranslatedMessage.Type}
1676      */
1677     public enum Type
1678         implements com.google.protobuf.ProtocolMessageEnum {
1679       /**
1680        * <code>STRING = 1;</code>
1681        */
1682       STRING(0, 1),
1683       /**
1684        * <code>NUM = 2;</code>
1685        */
1686       NUM(1, 2),
1687       /**
1688        * <code>BOOL = 3;</code>
1689        */
1690       BOOL(2, 3),
1691       /**
1692        * <code>EVENTED_STRING = 4;</code>
1693        */
1694       EVENTED_STRING(3, 4),
1695       /**
1696        * <code>EVENTED_NUM = 5;</code>
1697        */
1698       EVENTED_NUM(4, 5),
1699       /**
1700        * <code>EVENTED_BOOL = 6;</code>
1701        */
1702       EVENTED_BOOL(5, 6),
1703       ;
1704
1705       /**
1706        * <code>STRING = 1;</code>
1707        */
1708       public static final int STRING_VALUE = 1;
1709       /**
1710        * <code>NUM = 2;</code>
1711        */
1712       public static final int NUM_VALUE = 2;
1713       /**
1714        * <code>BOOL = 3;</code>
1715        */
1716       public static final int BOOL_VALUE = 3;
1717       /**
1718        * <code>EVENTED_STRING = 4;</code>
1719        */
1720       public static final int EVENTED_STRING_VALUE = 4;
1721       /**
1722        * <code>EVENTED_NUM = 5;</code>
1723        */
1724       public static final int EVENTED_NUM_VALUE = 5;
1725       /**
1726        * <code>EVENTED_BOOL = 6;</code>
1727        */
1728       public static final int EVENTED_BOOL_VALUE = 6;
1729
1730
1731       public final int getNumber() { return value; }
1732
1733       public static Type valueOf(int value) {
1734         switch (value) {
1735           case 1: return STRING;
1736           case 2: return NUM;
1737           case 3: return BOOL;
1738           case 4: return EVENTED_STRING;
1739           case 5: return EVENTED_NUM;
1740           case 6: return EVENTED_BOOL;
1741           default: return null;
1742         }
1743       }
1744
1745       public static com.google.protobuf.Internal.EnumLiteMap<Type>
1746           internalGetValueMap() {
1747         return internalValueMap;
1748       }
1749       private static com.google.protobuf.Internal.EnumLiteMap<Type>
1750           internalValueMap =
1751             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
1752               public Type findValueByNumber(int number) {
1753                 return Type.valueOf(number);
1754               }
1755             };
1756
1757       public final com.google.protobuf.Descriptors.EnumValueDescriptor
1758           getValueDescriptor() {
1759         return getDescriptor().getValues().get(index);
1760       }
1761       public final com.google.protobuf.Descriptors.EnumDescriptor
1762           getDescriptorForType() {
1763         return getDescriptor();
1764       }
1765       public static final com.google.protobuf.Descriptors.EnumDescriptor
1766           getDescriptor() {
1767         return com.openxc.BinaryMessages.TranslatedMessage.getDescriptor().getEnumTypes().get(0);
1768       }
1769
1770       private static final Type[] VALUES = values();
1771
1772       public static Type valueOf(
1773           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1774         if (desc.getType() != getDescriptor()) {
1775           throw new java.lang.IllegalArgumentException(
1776             "EnumValueDescriptor is not for this type.");
1777         }
1778         return VALUES[desc.getIndex()];
1779       }
1780
1781       private final int index;
1782       private final int value;
1783
1784       private Type(int index, int value) {
1785         this.index = index;
1786         this.value = value;
1787       }
1788
1789       // @@protoc_insertion_point(enum_scope:openxc.TranslatedMessage.Type)
1790     }
1791
1792     private int bitField0_;
1793     // optional .openxc.TranslatedMessage.Type type = 1;
1794     public static final int TYPE_FIELD_NUMBER = 1;
1795     private com.openxc.BinaryMessages.TranslatedMessage.Type type_;
1796     /**
1797      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
1798      */
1799     public boolean hasType() {
1800       return ((bitField0_ & 0x00000001) == 0x00000001);
1801     }
1802     /**
1803      * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
1804      */
1805     public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
1806       return type_;
1807     }
1808
1809     // optional string name = 2;
1810     public static final int NAME_FIELD_NUMBER = 2;
1811     private java.lang.Object name_;
1812     /**
1813      * <code>optional string name = 2;</code>
1814      */
1815     public boolean hasName() {
1816       return ((bitField0_ & 0x00000002) == 0x00000002);
1817     }
1818     /**
1819      * <code>optional string name = 2;</code>
1820      */
1821     public java.lang.String getName() {
1822       java.lang.Object ref = name_;
1823       if (ref instanceof java.lang.String) {
1824         return (java.lang.String) ref;
1825       } else {
1826         com.google.protobuf.ByteString bs =
1827             (com.google.protobuf.ByteString) ref;
1828         java.lang.String s = bs.toStringUtf8();
1829         if (bs.isValidUtf8()) {
1830           name_ = s;
1831         }
1832         return s;
1833       }
1834     }
1835     /**
1836      * <code>optional string name = 2;</code>
1837      */
1838     public com.google.protobuf.ByteString
1839         getNameBytes() {
1840       java.lang.Object ref = name_;
1841       if (ref instanceof java.lang.String) {
1842         com.google.protobuf.ByteString b =
1843             com.google.protobuf.ByteString.copyFromUtf8(
1844                 (java.lang.String) ref);
1845         name_ = b;
1846         return b;
1847       } else {
1848         return (com.google.protobuf.ByteString) ref;
1849       }
1850     }
1851
1852     // optional string string_value = 3;
1853     public static final int STRING_VALUE_FIELD_NUMBER = 3;
1854     private java.lang.Object stringValue_;
1855     /**
1856      * <code>optional string string_value = 3;</code>
1857      */
1858     public boolean hasStringValue() {
1859       return ((bitField0_ & 0x00000004) == 0x00000004);
1860     }
1861     /**
1862      * <code>optional string string_value = 3;</code>
1863      */
1864     public java.lang.String getStringValue() {
1865       java.lang.Object ref = stringValue_;
1866       if (ref instanceof java.lang.String) {
1867         return (java.lang.String) ref;
1868       } else {
1869         com.google.protobuf.ByteString bs =
1870             (com.google.protobuf.ByteString) ref;
1871         java.lang.String s = bs.toStringUtf8();
1872         if (bs.isValidUtf8()) {
1873           stringValue_ = s;
1874         }
1875         return s;
1876       }
1877     }
1878     /**
1879      * <code>optional string string_value = 3;</code>
1880      */
1881     public com.google.protobuf.ByteString
1882         getStringValueBytes() {
1883       java.lang.Object ref = stringValue_;
1884       if (ref instanceof java.lang.String) {
1885         com.google.protobuf.ByteString b =
1886             com.google.protobuf.ByteString.copyFromUtf8(
1887                 (java.lang.String) ref);
1888         stringValue_ = b;
1889         return b;
1890       } else {
1891         return (com.google.protobuf.ByteString) ref;
1892       }
1893     }
1894
1895     // optional double numeric_value = 4;
1896     public static final int NUMERIC_VALUE_FIELD_NUMBER = 4;
1897     private double numericValue_;
1898     /**
1899      * <code>optional double numeric_value = 4;</code>
1900      */
1901     public boolean hasNumericValue() {
1902       return ((bitField0_ & 0x00000008) == 0x00000008);
1903     }
1904     /**
1905      * <code>optional double numeric_value = 4;</code>
1906      */
1907     public double getNumericValue() {
1908       return numericValue_;
1909     }
1910
1911     // optional bool boolean_value = 5;
1912     public static final int BOOLEAN_VALUE_FIELD_NUMBER = 5;
1913     private boolean booleanValue_;
1914     /**
1915      * <code>optional bool boolean_value = 5;</code>
1916      */
1917     public boolean hasBooleanValue() {
1918       return ((bitField0_ & 0x00000010) == 0x00000010);
1919     }
1920     /**
1921      * <code>optional bool boolean_value = 5;</code>
1922      */
1923     public boolean getBooleanValue() {
1924       return booleanValue_;
1925     }
1926
1927     // optional string string_event = 6;
1928     public static final int STRING_EVENT_FIELD_NUMBER = 6;
1929     private java.lang.Object stringEvent_;
1930     /**
1931      * <code>optional string string_event = 6;</code>
1932      */
1933     public boolean hasStringEvent() {
1934       return ((bitField0_ & 0x00000020) == 0x00000020);
1935     }
1936     /**
1937      * <code>optional string string_event = 6;</code>
1938      */
1939     public java.lang.String getStringEvent() {
1940       java.lang.Object ref = stringEvent_;
1941       if (ref instanceof java.lang.String) {
1942         return (java.lang.String) ref;
1943       } else {
1944         com.google.protobuf.ByteString bs =
1945             (com.google.protobuf.ByteString) ref;
1946         java.lang.String s = bs.toStringUtf8();
1947         if (bs.isValidUtf8()) {
1948           stringEvent_ = s;
1949         }
1950         return s;
1951       }
1952     }
1953     /**
1954      * <code>optional string string_event = 6;</code>
1955      */
1956     public com.google.protobuf.ByteString
1957         getStringEventBytes() {
1958       java.lang.Object ref = stringEvent_;
1959       if (ref instanceof java.lang.String) {
1960         com.google.protobuf.ByteString b =
1961             com.google.protobuf.ByteString.copyFromUtf8(
1962                 (java.lang.String) ref);
1963         stringEvent_ = b;
1964         return b;
1965       } else {
1966         return (com.google.protobuf.ByteString) ref;
1967       }
1968     }
1969
1970     // optional double numeric_event = 7;
1971     public static final int NUMERIC_EVENT_FIELD_NUMBER = 7;
1972     private double numericEvent_;
1973     /**
1974      * <code>optional double numeric_event = 7;</code>
1975      */
1976     public boolean hasNumericEvent() {
1977       return ((bitField0_ & 0x00000040) == 0x00000040);
1978     }
1979     /**
1980      * <code>optional double numeric_event = 7;</code>
1981      */
1982     public double getNumericEvent() {
1983       return numericEvent_;
1984     }
1985
1986     // optional bool boolean_event = 8;
1987     public static final int BOOLEAN_EVENT_FIELD_NUMBER = 8;
1988     private boolean booleanEvent_;
1989     /**
1990      * <code>optional bool boolean_event = 8;</code>
1991      */
1992     public boolean hasBooleanEvent() {
1993       return ((bitField0_ & 0x00000080) == 0x00000080);
1994     }
1995     /**
1996      * <code>optional bool boolean_event = 8;</code>
1997      */
1998     public boolean getBooleanEvent() {
1999       return booleanEvent_;
2000     }
2001
2002     private void initFields() {
2003       type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
2004       name_ = "";
2005       stringValue_ = "";
2006       numericValue_ = 0D;
2007       booleanValue_ = false;
2008       stringEvent_ = "";
2009       numericEvent_ = 0D;
2010       booleanEvent_ = false;
2011     }
2012     private byte memoizedIsInitialized = -1;
2013     public final boolean isInitialized() {
2014       byte isInitialized = memoizedIsInitialized;
2015       if (isInitialized != -1) return isInitialized == 1;
2016
2017       memoizedIsInitialized = 1;
2018       return true;
2019     }
2020
2021     public void writeTo(com.google.protobuf.CodedOutputStream output)
2022                         throws java.io.IOException {
2023       getSerializedSize();
2024       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2025         output.writeEnum(1, type_.getNumber());
2026       }
2027       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2028         output.writeBytes(2, getNameBytes());
2029       }
2030       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2031         output.writeBytes(3, getStringValueBytes());
2032       }
2033       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2034         output.writeDouble(4, numericValue_);
2035       }
2036       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2037         output.writeBool(5, booleanValue_);
2038       }
2039       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2040         output.writeBytes(6, getStringEventBytes());
2041       }
2042       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2043         output.writeDouble(7, numericEvent_);
2044       }
2045       if (((bitField0_ & 0x00000080) == 0x00000080)) {
2046         output.writeBool(8, booleanEvent_);
2047       }
2048       getUnknownFields().writeTo(output);
2049     }
2050
2051     private int memoizedSerializedSize = -1;
2052     public int getSerializedSize() {
2053       int size = memoizedSerializedSize;
2054       if (size != -1) return size;
2055
2056       size = 0;
2057       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2058         size += com.google.protobuf.CodedOutputStream
2059           .computeEnumSize(1, type_.getNumber());
2060       }
2061       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2062         size += com.google.protobuf.CodedOutputStream
2063           .computeBytesSize(2, getNameBytes());
2064       }
2065       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2066         size += com.google.protobuf.CodedOutputStream
2067           .computeBytesSize(3, getStringValueBytes());
2068       }
2069       if (((bitField0_ & 0x00000008) == 0x00000008)) {
2070         size += com.google.protobuf.CodedOutputStream
2071           .computeDoubleSize(4, numericValue_);
2072       }
2073       if (((bitField0_ & 0x00000010) == 0x00000010)) {
2074         size += com.google.protobuf.CodedOutputStream
2075           .computeBoolSize(5, booleanValue_);
2076       }
2077       if (((bitField0_ & 0x00000020) == 0x00000020)) {
2078         size += com.google.protobuf.CodedOutputStream
2079           .computeBytesSize(6, getStringEventBytes());
2080       }
2081       if (((bitField0_ & 0x00000040) == 0x00000040)) {
2082         size += com.google.protobuf.CodedOutputStream
2083           .computeDoubleSize(7, numericEvent_);
2084       }
2085       if (((bitField0_ & 0x00000080) == 0x00000080)) {
2086         size += com.google.protobuf.CodedOutputStream
2087           .computeBoolSize(8, booleanEvent_);
2088       }
2089       size += getUnknownFields().getSerializedSize();
2090       memoizedSerializedSize = size;
2091       return size;
2092     }
2093
2094     private static final long serialVersionUID = 0L;
2095     @java.lang.Override
2096     protected java.lang.Object writeReplace()
2097         throws java.io.ObjectStreamException {
2098       return super.writeReplace();
2099     }
2100
2101     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
2102         com.google.protobuf.ByteString data)
2103         throws com.google.protobuf.InvalidProtocolBufferException {
2104       return PARSER.parseFrom(data);
2105     }
2106     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
2107         com.google.protobuf.ByteString data,
2108         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2109         throws com.google.protobuf.InvalidProtocolBufferException {
2110       return PARSER.parseFrom(data, extensionRegistry);
2111     }
2112     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(byte[] data)
2113         throws com.google.protobuf.InvalidProtocolBufferException {
2114       return PARSER.parseFrom(data);
2115     }
2116     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
2117         byte[] data,
2118         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2119         throws com.google.protobuf.InvalidProtocolBufferException {
2120       return PARSER.parseFrom(data, extensionRegistry);
2121     }
2122     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(java.io.InputStream input)
2123         throws java.io.IOException {
2124       return PARSER.parseFrom(input);
2125     }
2126     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
2127         java.io.InputStream input,
2128         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2129         throws java.io.IOException {
2130       return PARSER.parseFrom(input, extensionRegistry);
2131     }
2132     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(java.io.InputStream input)
2133         throws java.io.IOException {
2134       return PARSER.parseDelimitedFrom(input);
2135     }
2136     public static com.openxc.BinaryMessages.TranslatedMessage parseDelimitedFrom(
2137         java.io.InputStream input,
2138         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2139         throws java.io.IOException {
2140       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2141     }
2142     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
2143         com.google.protobuf.CodedInputStream input)
2144         throws java.io.IOException {
2145       return PARSER.parseFrom(input);
2146     }
2147     public static com.openxc.BinaryMessages.TranslatedMessage parseFrom(
2148         com.google.protobuf.CodedInputStream input,
2149         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2150         throws java.io.IOException {
2151       return PARSER.parseFrom(input, extensionRegistry);
2152     }
2153
2154     public static Builder newBuilder() { return Builder.create(); }
2155     public Builder newBuilderForType() { return newBuilder(); }
2156     public static Builder newBuilder(com.openxc.BinaryMessages.TranslatedMessage prototype) {
2157       return newBuilder().mergeFrom(prototype);
2158     }
2159     public Builder toBuilder() { return newBuilder(this); }
2160
2161     @java.lang.Override
2162     protected Builder newBuilderForType(
2163         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2164       Builder builder = new Builder(parent);
2165       return builder;
2166     }
2167     /**
2168      * Protobuf type {@code openxc.TranslatedMessage}
2169      */
2170     public static final class Builder extends
2171         com.google.protobuf.GeneratedMessage.Builder<Builder>
2172        implements com.openxc.BinaryMessages.TranslatedMessageOrBuilder {
2173       public static final com.google.protobuf.Descriptors.Descriptor
2174           getDescriptor() {
2175         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
2176       }
2177
2178       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2179           internalGetFieldAccessorTable() {
2180         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_fieldAccessorTable
2181             .ensureFieldAccessorsInitialized(
2182                 com.openxc.BinaryMessages.TranslatedMessage.class, com.openxc.BinaryMessages.TranslatedMessage.Builder.class);
2183       }
2184
2185       // Construct using com.openxc.BinaryMessages.TranslatedMessage.newBuilder()
2186       private Builder() {
2187         maybeForceBuilderInitialization();
2188       }
2189
2190       private Builder(
2191           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2192         super(parent);
2193         maybeForceBuilderInitialization();
2194       }
2195       private void maybeForceBuilderInitialization() {
2196         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2197         }
2198       }
2199       private static Builder create() {
2200         return new Builder();
2201       }
2202
2203       public Builder clear() {
2204         super.clear();
2205         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
2206         bitField0_ = (bitField0_ & ~0x00000001);
2207         name_ = "";
2208         bitField0_ = (bitField0_ & ~0x00000002);
2209         stringValue_ = "";
2210         bitField0_ = (bitField0_ & ~0x00000004);
2211         numericValue_ = 0D;
2212         bitField0_ = (bitField0_ & ~0x00000008);
2213         booleanValue_ = false;
2214         bitField0_ = (bitField0_ & ~0x00000010);
2215         stringEvent_ = "";
2216         bitField0_ = (bitField0_ & ~0x00000020);
2217         numericEvent_ = 0D;
2218         bitField0_ = (bitField0_ & ~0x00000040);
2219         booleanEvent_ = false;
2220         bitField0_ = (bitField0_ & ~0x00000080);
2221         return this;
2222       }
2223
2224       public Builder clone() {
2225         return create().mergeFrom(buildPartial());
2226       }
2227
2228       public com.google.protobuf.Descriptors.Descriptor
2229           getDescriptorForType() {
2230         return com.openxc.BinaryMessages.internal_static_openxc_TranslatedMessage_descriptor;
2231       }
2232
2233       public com.openxc.BinaryMessages.TranslatedMessage getDefaultInstanceForType() {
2234         return com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance();
2235       }
2236
2237       public com.openxc.BinaryMessages.TranslatedMessage build() {
2238         com.openxc.BinaryMessages.TranslatedMessage result = buildPartial();
2239         if (!result.isInitialized()) {
2240           throw newUninitializedMessageException(result);
2241         }
2242         return result;
2243       }
2244
2245       public com.openxc.BinaryMessages.TranslatedMessage buildPartial() {
2246         com.openxc.BinaryMessages.TranslatedMessage result = new com.openxc.BinaryMessages.TranslatedMessage(this);
2247         int from_bitField0_ = bitField0_;
2248         int to_bitField0_ = 0;
2249         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2250           to_bitField0_ |= 0x00000001;
2251         }
2252         result.type_ = type_;
2253         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2254           to_bitField0_ |= 0x00000002;
2255         }
2256         result.name_ = name_;
2257         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2258           to_bitField0_ |= 0x00000004;
2259         }
2260         result.stringValue_ = stringValue_;
2261         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2262           to_bitField0_ |= 0x00000008;
2263         }
2264         result.numericValue_ = numericValue_;
2265         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2266           to_bitField0_ |= 0x00000010;
2267         }
2268         result.booleanValue_ = booleanValue_;
2269         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2270           to_bitField0_ |= 0x00000020;
2271         }
2272         result.stringEvent_ = stringEvent_;
2273         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2274           to_bitField0_ |= 0x00000040;
2275         }
2276         result.numericEvent_ = numericEvent_;
2277         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
2278           to_bitField0_ |= 0x00000080;
2279         }
2280         result.booleanEvent_ = booleanEvent_;
2281         result.bitField0_ = to_bitField0_;
2282         onBuilt();
2283         return result;
2284       }
2285
2286       public Builder mergeFrom(com.google.protobuf.Message other) {
2287         if (other instanceof com.openxc.BinaryMessages.TranslatedMessage) {
2288           return mergeFrom((com.openxc.BinaryMessages.TranslatedMessage)other);
2289         } else {
2290           super.mergeFrom(other);
2291           return this;
2292         }
2293       }
2294
2295       public Builder mergeFrom(com.openxc.BinaryMessages.TranslatedMessage other) {
2296         if (other == com.openxc.BinaryMessages.TranslatedMessage.getDefaultInstance()) return this;
2297         if (other.hasType()) {
2298           setType(other.getType());
2299         }
2300         if (other.hasName()) {
2301           bitField0_ |= 0x00000002;
2302           name_ = other.name_;
2303           onChanged();
2304         }
2305         if (other.hasStringValue()) {
2306           bitField0_ |= 0x00000004;
2307           stringValue_ = other.stringValue_;
2308           onChanged();
2309         }
2310         if (other.hasNumericValue()) {
2311           setNumericValue(other.getNumericValue());
2312         }
2313         if (other.hasBooleanValue()) {
2314           setBooleanValue(other.getBooleanValue());
2315         }
2316         if (other.hasStringEvent()) {
2317           bitField0_ |= 0x00000020;
2318           stringEvent_ = other.stringEvent_;
2319           onChanged();
2320         }
2321         if (other.hasNumericEvent()) {
2322           setNumericEvent(other.getNumericEvent());
2323         }
2324         if (other.hasBooleanEvent()) {
2325           setBooleanEvent(other.getBooleanEvent());
2326         }
2327         this.mergeUnknownFields(other.getUnknownFields());
2328         return this;
2329       }
2330
2331       public final boolean isInitialized() {
2332         return true;
2333       }
2334
2335       public Builder mergeFrom(
2336           com.google.protobuf.CodedInputStream input,
2337           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2338           throws java.io.IOException {
2339         com.openxc.BinaryMessages.TranslatedMessage parsedMessage = null;
2340         try {
2341           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2342         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2343           parsedMessage = (com.openxc.BinaryMessages.TranslatedMessage) e.getUnfinishedMessage();
2344           throw e;
2345         } finally {
2346           if (parsedMessage != null) {
2347             mergeFrom(parsedMessage);
2348           }
2349         }
2350         return this;
2351       }
2352       private int bitField0_;
2353
2354       // optional .openxc.TranslatedMessage.Type type = 1;
2355       private com.openxc.BinaryMessages.TranslatedMessage.Type type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
2356       /**
2357        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2358        */
2359       public boolean hasType() {
2360         return ((bitField0_ & 0x00000001) == 0x00000001);
2361       }
2362       /**
2363        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2364        */
2365       public com.openxc.BinaryMessages.TranslatedMessage.Type getType() {
2366         return type_;
2367       }
2368       /**
2369        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2370        */
2371       public Builder setType(com.openxc.BinaryMessages.TranslatedMessage.Type value) {
2372         if (value == null) {
2373           throw new NullPointerException();
2374         }
2375         bitField0_ |= 0x00000001;
2376         type_ = value;
2377         onChanged();
2378         return this;
2379       }
2380       /**
2381        * <code>optional .openxc.TranslatedMessage.Type type = 1;</code>
2382        */
2383       public Builder clearType() {
2384         bitField0_ = (bitField0_ & ~0x00000001);
2385         type_ = com.openxc.BinaryMessages.TranslatedMessage.Type.STRING;
2386         onChanged();
2387         return this;
2388       }
2389
2390       // optional string name = 2;
2391       private java.lang.Object name_ = "";
2392       /**
2393        * <code>optional string name = 2;</code>
2394        */
2395       public boolean hasName() {
2396         return ((bitField0_ & 0x00000002) == 0x00000002);
2397       }
2398       /**
2399        * <code>optional string name = 2;</code>
2400        */
2401       public java.lang.String getName() {
2402         java.lang.Object ref = name_;
2403         if (!(ref instanceof java.lang.String)) {
2404           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2405               .toStringUtf8();
2406           name_ = s;
2407           return s;
2408         } else {
2409           return (java.lang.String) ref;
2410         }
2411       }
2412       /**
2413        * <code>optional string name = 2;</code>
2414        */
2415       public com.google.protobuf.ByteString
2416           getNameBytes() {
2417         java.lang.Object ref = name_;
2418         if (ref instanceof String) {
2419           com.google.protobuf.ByteString b =
2420               com.google.protobuf.ByteString.copyFromUtf8(
2421                   (java.lang.String) ref);
2422           name_ = b;
2423           return b;
2424         } else {
2425           return (com.google.protobuf.ByteString) ref;
2426         }
2427       }
2428       /**
2429        * <code>optional string name = 2;</code>
2430        */
2431       public Builder setName(
2432           java.lang.String value) {
2433         if (value == null) {
2434     throw new NullPointerException();
2435   }
2436   bitField0_ |= 0x00000002;
2437         name_ = value;
2438         onChanged();
2439         return this;
2440       }
2441       /**
2442        * <code>optional string name = 2;</code>
2443        */
2444       public Builder clearName() {
2445         bitField0_ = (bitField0_ & ~0x00000002);
2446         name_ = getDefaultInstance().getName();
2447         onChanged();
2448         return this;
2449       }
2450       /**
2451        * <code>optional string name = 2;</code>
2452        */
2453       public Builder setNameBytes(
2454           com.google.protobuf.ByteString value) {
2455         if (value == null) {
2456     throw new NullPointerException();
2457   }
2458   bitField0_ |= 0x00000002;
2459         name_ = value;
2460         onChanged();
2461         return this;
2462       }
2463
2464       // optional string string_value = 3;
2465       private java.lang.Object stringValue_ = "";
2466       /**
2467        * <code>optional string string_value = 3;</code>
2468        */
2469       public boolean hasStringValue() {
2470         return ((bitField0_ & 0x00000004) == 0x00000004);
2471       }
2472       /**
2473        * <code>optional string string_value = 3;</code>
2474        */
2475       public java.lang.String getStringValue() {
2476         java.lang.Object ref = stringValue_;
2477         if (!(ref instanceof java.lang.String)) {
2478           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2479               .toStringUtf8();
2480           stringValue_ = s;
2481           return s;
2482         } else {
2483           return (java.lang.String) ref;
2484         }
2485       }
2486       /**
2487        * <code>optional string string_value = 3;</code>
2488        */
2489       public com.google.protobuf.ByteString
2490           getStringValueBytes() {
2491         java.lang.Object ref = stringValue_;
2492         if (ref instanceof String) {
2493           com.google.protobuf.ByteString b =
2494               com.google.protobuf.ByteString.copyFromUtf8(
2495                   (java.lang.String) ref);
2496           stringValue_ = b;
2497           return b;
2498         } else {
2499           return (com.google.protobuf.ByteString) ref;
2500         }
2501       }
2502       /**
2503        * <code>optional string string_value = 3;</code>
2504        */
2505       public Builder setStringValue(
2506           java.lang.String value) {
2507         if (value == null) {
2508     throw new NullPointerException();
2509   }
2510   bitField0_ |= 0x00000004;
2511         stringValue_ = value;
2512         onChanged();
2513         return this;
2514       }
2515       /**
2516        * <code>optional string string_value = 3;</code>
2517        */
2518       public Builder clearStringValue() {
2519         bitField0_ = (bitField0_ & ~0x00000004);
2520         stringValue_ = getDefaultInstance().getStringValue();
2521         onChanged();
2522         return this;
2523       }
2524       /**
2525        * <code>optional string string_value = 3;</code>
2526        */
2527       public Builder setStringValueBytes(
2528           com.google.protobuf.ByteString value) {
2529         if (value == null) {
2530     throw new NullPointerException();
2531   }
2532   bitField0_ |= 0x00000004;
2533         stringValue_ = value;
2534         onChanged();
2535         return this;
2536       }
2537
2538       // optional double numeric_value = 4;
2539       private double numericValue_ ;
2540       /**
2541        * <code>optional double numeric_value = 4;</code>
2542        */
2543       public boolean hasNumericValue() {
2544         return ((bitField0_ & 0x00000008) == 0x00000008);
2545       }
2546       /**
2547        * <code>optional double numeric_value = 4;</code>
2548        */
2549       public double getNumericValue() {
2550         return numericValue_;
2551       }
2552       /**
2553        * <code>optional double numeric_value = 4;</code>
2554        */
2555       public Builder setNumericValue(double value) {
2556         bitField0_ |= 0x00000008;
2557         numericValue_ = value;
2558         onChanged();
2559         return this;
2560       }
2561       /**
2562        * <code>optional double numeric_value = 4;</code>
2563        */
2564       public Builder clearNumericValue() {
2565         bitField0_ = (bitField0_ & ~0x00000008);
2566         numericValue_ = 0D;
2567         onChanged();
2568         return this;
2569       }
2570
2571       // optional bool boolean_value = 5;
2572       private boolean booleanValue_ ;
2573       /**
2574        * <code>optional bool boolean_value = 5;</code>
2575        */
2576       public boolean hasBooleanValue() {
2577         return ((bitField0_ & 0x00000010) == 0x00000010);
2578       }
2579       /**
2580        * <code>optional bool boolean_value = 5;</code>
2581        */
2582       public boolean getBooleanValue() {
2583         return booleanValue_;
2584       }
2585       /**
2586        * <code>optional bool boolean_value = 5;</code>
2587        */
2588       public Builder setBooleanValue(boolean value) {
2589         bitField0_ |= 0x00000010;
2590         booleanValue_ = value;
2591         onChanged();
2592         return this;
2593       }
2594       /**
2595        * <code>optional bool boolean_value = 5;</code>
2596        */
2597       public Builder clearBooleanValue() {
2598         bitField0_ = (bitField0_ & ~0x00000010);
2599         booleanValue_ = false;
2600         onChanged();
2601         return this;
2602       }
2603
2604       // optional string string_event = 6;
2605       private java.lang.Object stringEvent_ = "";
2606       /**
2607        * <code>optional string string_event = 6;</code>
2608        */
2609       public boolean hasStringEvent() {
2610         return ((bitField0_ & 0x00000020) == 0x00000020);
2611       }
2612       /**
2613        * <code>optional string string_event = 6;</code>
2614        */
2615       public java.lang.String getStringEvent() {
2616         java.lang.Object ref = stringEvent_;
2617         if (!(ref instanceof java.lang.String)) {
2618           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2619               .toStringUtf8();
2620           stringEvent_ = s;
2621           return s;
2622         } else {
2623           return (java.lang.String) ref;
2624         }
2625       }
2626       /**
2627        * <code>optional string string_event = 6;</code>
2628        */
2629       public com.google.protobuf.ByteString
2630           getStringEventBytes() {
2631         java.lang.Object ref = stringEvent_;
2632         if (ref instanceof String) {
2633           com.google.protobuf.ByteString b =
2634               com.google.protobuf.ByteString.copyFromUtf8(
2635                   (java.lang.String) ref);
2636           stringEvent_ = b;
2637           return b;
2638         } else {
2639           return (com.google.protobuf.ByteString) ref;
2640         }
2641       }
2642       /**
2643        * <code>optional string string_event = 6;</code>
2644        */
2645       public Builder setStringEvent(
2646           java.lang.String value) {
2647         if (value == null) {
2648     throw new NullPointerException();
2649   }
2650   bitField0_ |= 0x00000020;
2651         stringEvent_ = value;
2652         onChanged();
2653         return this;
2654       }
2655       /**
2656        * <code>optional string string_event = 6;</code>
2657        */
2658       public Builder clearStringEvent() {
2659         bitField0_ = (bitField0_ & ~0x00000020);
2660         stringEvent_ = getDefaultInstance().getStringEvent();
2661         onChanged();
2662         return this;
2663       }
2664       /**
2665        * <code>optional string string_event = 6;</code>
2666        */
2667       public Builder setStringEventBytes(
2668           com.google.protobuf.ByteString value) {
2669         if (value == null) {
2670     throw new NullPointerException();
2671   }
2672   bitField0_ |= 0x00000020;
2673         stringEvent_ = value;
2674         onChanged();
2675         return this;
2676       }
2677
2678       // optional double numeric_event = 7;
2679       private double numericEvent_ ;
2680       /**
2681        * <code>optional double numeric_event = 7;</code>
2682        */
2683       public boolean hasNumericEvent() {
2684         return ((bitField0_ & 0x00000040) == 0x00000040);
2685       }
2686       /**
2687        * <code>optional double numeric_event = 7;</code>
2688        */
2689       public double getNumericEvent() {
2690         return numericEvent_;
2691       }
2692       /**
2693        * <code>optional double numeric_event = 7;</code>
2694        */
2695       public Builder setNumericEvent(double value) {
2696         bitField0_ |= 0x00000040;
2697         numericEvent_ = value;
2698         onChanged();
2699         return this;
2700       }
2701       /**
2702        * <code>optional double numeric_event = 7;</code>
2703        */
2704       public Builder clearNumericEvent() {
2705         bitField0_ = (bitField0_ & ~0x00000040);
2706         numericEvent_ = 0D;
2707         onChanged();
2708         return this;
2709       }
2710
2711       // optional bool boolean_event = 8;
2712       private boolean booleanEvent_ ;
2713       /**
2714        * <code>optional bool boolean_event = 8;</code>
2715        */
2716       public boolean hasBooleanEvent() {
2717         return ((bitField0_ & 0x00000080) == 0x00000080);
2718       }
2719       /**
2720        * <code>optional bool boolean_event = 8;</code>
2721        */
2722       public boolean getBooleanEvent() {
2723         return booleanEvent_;
2724       }
2725       /**
2726        * <code>optional bool boolean_event = 8;</code>
2727        */
2728       public Builder setBooleanEvent(boolean value) {
2729         bitField0_ |= 0x00000080;
2730         booleanEvent_ = value;
2731         onChanged();
2732         return this;
2733       }
2734       /**
2735        * <code>optional bool boolean_event = 8;</code>
2736        */
2737       public Builder clearBooleanEvent() {
2738         bitField0_ = (bitField0_ & ~0x00000080);
2739         booleanEvent_ = false;
2740         onChanged();
2741         return this;
2742       }
2743
2744       // @@protoc_insertion_point(builder_scope:openxc.TranslatedMessage)
2745     }
2746
2747     static {
2748       defaultInstance = new TranslatedMessage(true);
2749       defaultInstance.initFields();
2750     }
2751
2752     // @@protoc_insertion_point(class_scope:openxc.TranslatedMessage)
2753   }
2754
2755   private static com.google.protobuf.Descriptors.Descriptor
2756     internal_static_openxc_VehicleMessage_descriptor;
2757   private static
2758     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2759       internal_static_openxc_VehicleMessage_fieldAccessorTable;
2760   private static com.google.protobuf.Descriptors.Descriptor
2761     internal_static_openxc_RawMessage_descriptor;
2762   private static
2763     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2764       internal_static_openxc_RawMessage_fieldAccessorTable;
2765   private static com.google.protobuf.Descriptors.Descriptor
2766     internal_static_openxc_TranslatedMessage_descriptor;
2767   private static
2768     com.google.protobuf.GeneratedMessage.FieldAccessorTable
2769       internal_static_openxc_TranslatedMessage_fieldAccessorTable;
2770
2771   public static com.google.protobuf.Descriptors.FileDescriptor
2772       getDescriptor() {
2773     return descriptor;
2774   }
2775   private static com.google.protobuf.Descriptors.FileDescriptor
2776       descriptor;
2777   static {
2778     java.lang.String[] descriptorData = {
2779       "\n\014openxc.proto\022\006openxc\"\274\001\n\016VehicleMessag" +
2780       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
2781       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
2782       "ssage\0225\n\022translated_message\030\003 \001(\0132\031.open" +
2783       "xc.TranslatedMessage\"\037\n\004Type\022\007\n\003RAW\020\001\022\016\n" +
2784       "\nTRANSLATED\020\002\";\n\nRawMessage\022\013\n\003bus\030\001 \001(\005" +
2785       "\022\022\n\nmessage_id\030\002 \001(\r\022\014\n\004data\030\003 \001(\004\"\265\002\n\021T" +
2786       "ranslatedMessage\022,\n\004type\030\001 \001(\0162\036.openxc." +
2787       "TranslatedMessage.Type\022\014\n\004name\030\002 \001(\t\022\024\n\014" +
2788       "string_value\030\003 \001(\t\022\025\n\rnumeric_value\030\004 \001(",
2789       "\001\022\025\n\rboolean_value\030\005 \001(\010\022\024\n\014string_event" +
2790       "\030\006 \001(\t\022\025\n\rnumeric_event\030\007 \001(\001\022\025\n\rboolean" +
2791       "_event\030\010 \001(\010\"\\\n\004Type\022\n\n\006STRING\020\001\022\007\n\003NUM\020" +
2792       "\002\022\010\n\004BOOL\020\003\022\022\n\016EVENTED_STRING\020\004\022\017\n\013EVENT" +
2793       "ED_NUM\020\005\022\020\n\014EVENTED_BOOL\020\006B\034\n\ncom.openxc" +
2794       "B\016BinaryMessages"
2795     };
2796     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
2797       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
2798         public com.google.protobuf.ExtensionRegistry assignDescriptors(
2799             com.google.protobuf.Descriptors.FileDescriptor root) {
2800           descriptor = root;
2801           internal_static_openxc_VehicleMessage_descriptor =
2802             getDescriptor().getMessageTypes().get(0);
2803           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
2804             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2805               internal_static_openxc_VehicleMessage_descriptor,
2806               new java.lang.String[] { "Type", "RawMessage", "TranslatedMessage", });
2807           internal_static_openxc_RawMessage_descriptor =
2808             getDescriptor().getMessageTypes().get(1);
2809           internal_static_openxc_RawMessage_fieldAccessorTable = new
2810             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2811               internal_static_openxc_RawMessage_descriptor,
2812               new java.lang.String[] { "Bus", "MessageId", "Data", });
2813           internal_static_openxc_TranslatedMessage_descriptor =
2814             getDescriptor().getMessageTypes().get(2);
2815           internal_static_openxc_TranslatedMessage_fieldAccessorTable = new
2816             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
2817               internal_static_openxc_TranslatedMessage_descriptor,
2818               new java.lang.String[] { "Type", "Name", "StringValue", "NumericValue", "BooleanValue", "StringEvent", "NumericEvent", "BooleanEvent", });
2819           return null;
2820         }
2821       };
2822     com.google.protobuf.Descriptors.FileDescriptor
2823       .internalBuildGeneratedFileFrom(descriptorData,
2824         new com.google.protobuf.Descriptors.FileDescriptor[] {
2825         }, assigner);
2826   }
2827
2828   // @@protoc_insertion_point(outer_class_scope)
2829 }