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.StringMessage string_message = 3;
  39     /**
  40      * <code>optional .openxc.StringMessage string_message = 3;</code>
  41      */
  42     boolean hasStringMessage();
  43     /**
  44      * <code>optional .openxc.StringMessage string_message = 3;</code>
  45      */
  46     com.openxc.BinaryMessages.StringMessage getStringMessage();
  47     /**
  48      * <code>optional .openxc.StringMessage string_message = 3;</code>
  49      */
  50     com.openxc.BinaryMessages.StringMessageOrBuilder getStringMessageOrBuilder();
  51
  52     // optional .openxc.NumericMessage numeric_message = 4;
  53     /**
  54      * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
  55      */
  56     boolean hasNumericMessage();
  57     /**
  58      * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
  59      */
  60     com.openxc.BinaryMessages.NumericMessage getNumericMessage();
  61     /**
  62      * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
  63      */
  64     com.openxc.BinaryMessages.NumericMessageOrBuilder getNumericMessageOrBuilder();
  65
  66     // optional .openxc.BooleanMessage boolean_message = 5;
  67     /**
  68      * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
  69      */
  70     boolean hasBooleanMessage();
  71     /**
  72      * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
  73      */
  74     com.openxc.BinaryMessages.BooleanMessage getBooleanMessage();
  75     /**
  76      * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
  77      */
  78     com.openxc.BinaryMessages.BooleanMessageOrBuilder getBooleanMessageOrBuilder();
  79
  80     // optional .openxc.EventedStringMessage evented_string_message = 6;
  81     /**
  82      * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
  83      */
  84     boolean hasEventedStringMessage();
  85     /**
  86      * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
  87      */
  88     com.openxc.BinaryMessages.EventedStringMessage getEventedStringMessage();
  89     /**
  90      * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
  91      */
  92     com.openxc.BinaryMessages.EventedStringMessageOrBuilder getEventedStringMessageOrBuilder();
  93
  94     // optional .openxc.EventedBooleanMessage evented_boolean_message = 7;
  95     /**
  96      * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
  97      */
  98     boolean hasEventedBooleanMessage();
  99     /**
 100      * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
 101      */
 102     com.openxc.BinaryMessages.EventedBooleanMessage getEventedBooleanMessage();
 103     /**
 104      * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
 105      */
 106     com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder getEventedBooleanMessageOrBuilder();
 107
 108     // optional .openxc.EventedNumericMessage evented_numeric_message = 8;
 109     /**
 110      * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
 111      */
 112     boolean hasEventedNumericMessage();
 113     /**
 114      * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
 115      */
 116     com.openxc.BinaryMessages.EventedNumericMessage getEventedNumericMessage();
 117     /**
 118      * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
 119      */
 120     com.openxc.BinaryMessages.EventedNumericMessageOrBuilder getEventedNumericMessageOrBuilder();
 121   }
 122   /**
 123    * Protobuf type {@code openxc.VehicleMessage}
 124    */
 125   public static final class VehicleMessage extends
 126       com.google.protobuf.GeneratedMessage
 127       implements VehicleMessageOrBuilder {
 128     // Use VehicleMessage.newBuilder() to construct.
 129     private VehicleMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
 130       super(builder);
 131       this.unknownFields = builder.getUnknownFields();
 132     }
 133     private VehicleMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
 134
 135     private static final VehicleMessage defaultInstance;
 136     public static VehicleMessage getDefaultInstance() {
 137       return defaultInstance;
 138     }
 139
 140     public VehicleMessage getDefaultInstanceForType() {
 141       return defaultInstance;
 142     }
 143
 144     private final com.google.protobuf.UnknownFieldSet unknownFields;
 145     @java.lang.Override
 146     public final com.google.protobuf.UnknownFieldSet
 147         getUnknownFields() {
 148       return this.unknownFields;
 149     }
 150     private VehicleMessage(
 151         com.google.protobuf.CodedInputStream input,
 152         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 153         throws com.google.protobuf.InvalidProtocolBufferException {
 154       initFields();
 155       int mutable_bitField0_ = 0;
 156       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
 157           com.google.protobuf.UnknownFieldSet.newBuilder();
 158       try {
 159         boolean done = false;
 160         while (!done) {
 161           int tag = input.readTag();
 162           switch (tag) {
 163             case 0:
 164               done = true;
 165               break;
 166             default: {
 167               if (!parseUnknownField(input, unknownFields,
 168                                      extensionRegistry, tag)) {
 169                 done = true;
 170               }
 171               break;
 172             }
 173             case 8: {
 174               int rawValue = input.readEnum();
 175               com.openxc.BinaryMessages.VehicleMessage.Type value = com.openxc.BinaryMessages.VehicleMessage.Type.valueOf(rawValue);
 176               if (value == null) {
 177                 unknownFields.mergeVarintField(1, rawValue);
 178               } else {
 179                 bitField0_ |= 0x00000001;
 180                 type_ = value;
 181               }
 182               break;
 183             }
 184             case 18: {
 185               com.openxc.BinaryMessages.RawMessage.Builder subBuilder = null;
 186               if (((bitField0_ & 0x00000002) == 0x00000002)) {
 187                 subBuilder = rawMessage_.toBuilder();
 188               }
 189               rawMessage_ = input.readMessage(com.openxc.BinaryMessages.RawMessage.PARSER, extensionRegistry);
 190               if (subBuilder != null) {
 191                 subBuilder.mergeFrom(rawMessage_);
 192                 rawMessage_ = subBuilder.buildPartial();
 193               }
 194               bitField0_ |= 0x00000002;
 195               break;
 196             }
 197             case 26: {
 198               com.openxc.BinaryMessages.StringMessage.Builder subBuilder = null;
 199               if (((bitField0_ & 0x00000004) == 0x00000004)) {
 200                 subBuilder = stringMessage_.toBuilder();
 201               }
 202               stringMessage_ = input.readMessage(com.openxc.BinaryMessages.StringMessage.PARSER, extensionRegistry);
 203               if (subBuilder != null) {
 204                 subBuilder.mergeFrom(stringMessage_);
 205                 stringMessage_ = subBuilder.buildPartial();
 206               }
 207               bitField0_ |= 0x00000004;
 208               break;
 209             }
 210             case 34: {
 211               com.openxc.BinaryMessages.NumericMessage.Builder subBuilder = null;
 212               if (((bitField0_ & 0x00000008) == 0x00000008)) {
 213                 subBuilder = numericMessage_.toBuilder();
 214               }
 215               numericMessage_ = input.readMessage(com.openxc.BinaryMessages.NumericMessage.PARSER, extensionRegistry);
 216               if (subBuilder != null) {
 217                 subBuilder.mergeFrom(numericMessage_);
 218                 numericMessage_ = subBuilder.buildPartial();
 219               }
 220               bitField0_ |= 0x00000008;
 221               break;
 222             }
 223             case 42: {
 224               com.openxc.BinaryMessages.BooleanMessage.Builder subBuilder = null;
 225               if (((bitField0_ & 0x00000010) == 0x00000010)) {
 226                 subBuilder = booleanMessage_.toBuilder();
 227               }
 228               booleanMessage_ = input.readMessage(com.openxc.BinaryMessages.BooleanMessage.PARSER, extensionRegistry);
 229               if (subBuilder != null) {
 230                 subBuilder.mergeFrom(booleanMessage_);
 231                 booleanMessage_ = subBuilder.buildPartial();
 232               }
 233               bitField0_ |= 0x00000010;
 234               break;
 235             }
 236             case 50: {
 237               com.openxc.BinaryMessages.EventedStringMessage.Builder subBuilder = null;
 238               if (((bitField0_ & 0x00000020) == 0x00000020)) {
 239                 subBuilder = eventedStringMessage_.toBuilder();
 240               }
 241               eventedStringMessage_ = input.readMessage(com.openxc.BinaryMessages.EventedStringMessage.PARSER, extensionRegistry);
 242               if (subBuilder != null) {
 243                 subBuilder.mergeFrom(eventedStringMessage_);
 244                 eventedStringMessage_ = subBuilder.buildPartial();
 245               }
 246               bitField0_ |= 0x00000020;
 247               break;
 248             }
 249             case 58: {
 250               com.openxc.BinaryMessages.EventedBooleanMessage.Builder subBuilder = null;
 251               if (((bitField0_ & 0x00000040) == 0x00000040)) {
 252                 subBuilder = eventedBooleanMessage_.toBuilder();
 253               }
 254               eventedBooleanMessage_ = input.readMessage(com.openxc.BinaryMessages.EventedBooleanMessage.PARSER, extensionRegistry);
 255               if (subBuilder != null) {
 256                 subBuilder.mergeFrom(eventedBooleanMessage_);
 257                 eventedBooleanMessage_ = subBuilder.buildPartial();
 258               }
 259               bitField0_ |= 0x00000040;
 260               break;
 261             }
 262             case 66: {
 263               com.openxc.BinaryMessages.EventedNumericMessage.Builder subBuilder = null;
 264               if (((bitField0_ & 0x00000080) == 0x00000080)) {
 265                 subBuilder = eventedNumericMessage_.toBuilder();
 266               }
 267               eventedNumericMessage_ = input.readMessage(com.openxc.BinaryMessages.EventedNumericMessage.PARSER, extensionRegistry);
 268               if (subBuilder != null) {
 269                 subBuilder.mergeFrom(eventedNumericMessage_);
 270                 eventedNumericMessage_ = subBuilder.buildPartial();
 271               }
 272               bitField0_ |= 0x00000080;
 273               break;
 274             }
 275           }
 276         }
 277       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
 278         throw e.setUnfinishedMessage(this);
 279       } catch (java.io.IOException e) {
 280         throw new com.google.protobuf.InvalidProtocolBufferException(
 281             e.getMessage()).setUnfinishedMessage(this);
 282       } finally {
 283         this.unknownFields = unknownFields.build();
 284         makeExtensionsImmutable();
 285       }
 286     }
 287     public static final com.google.protobuf.Descriptors.Descriptor
 288         getDescriptor() {
 289       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 290     }
 291
 292     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 293         internalGetFieldAccessorTable() {
 294       return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 295           .ensureFieldAccessorsInitialized(
 296               com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 297     }
 298
 299     public static com.google.protobuf.Parser<VehicleMessage> PARSER =
 300         new com.google.protobuf.AbstractParser<VehicleMessage>() {
 301       public VehicleMessage parsePartialFrom(
 302           com.google.protobuf.CodedInputStream input,
 303           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 304           throws com.google.protobuf.InvalidProtocolBufferException {
 305         return new VehicleMessage(input, extensionRegistry);
 306       }
 307     };
 308
 309     @java.lang.Override
 310     public com.google.protobuf.Parser<VehicleMessage> getParserForType() {
 311       return PARSER;
 312     }
 313
 314     /**
 315      * Protobuf enum {@code openxc.VehicleMessage.Type}
 316      */
 317     public enum Type
 318         implements com.google.protobuf.ProtocolMessageEnum {
 319       /**
 320        * <code>RAW = 1;</code>
 321        */
 322       RAW(0, 1),
 323       /**
 324        * <code>STRING = 2;</code>
 325        */
 326       STRING(1, 2),
 327       /**
 328        * <code>BOOL = 3;</code>
 329        */
 330       BOOL(2, 3),
 331       /**
 332        * <code>NUM = 4;</code>
 333        */
 334       NUM(3, 4),
 335       /**
 336        * <code>EVENTED_NUM = 5;</code>
 337        */
 338       EVENTED_NUM(4, 5),
 339       /**
 340        * <code>EVENTED_STRING = 6;</code>
 341        */
 342       EVENTED_STRING(5, 6),
 343       /**
 344        * <code>EVENTED_BOOL = 7;</code>
 345        */
 346       EVENTED_BOOL(6, 7),
 347       ;
 348
 349       /**
 350        * <code>RAW = 1;</code>
 351        */
 352       public static final int RAW_VALUE = 1;
 353       /**
 354        * <code>STRING = 2;</code>
 355        */
 356       public static final int STRING_VALUE = 2;
 357       /**
 358        * <code>BOOL = 3;</code>
 359        */
 360       public static final int BOOL_VALUE = 3;
 361       /**
 362        * <code>NUM = 4;</code>
 363        */
 364       public static final int NUM_VALUE = 4;
 365       /**
 366        * <code>EVENTED_NUM = 5;</code>
 367        */
 368       public static final int EVENTED_NUM_VALUE = 5;
 369       /**
 370        * <code>EVENTED_STRING = 6;</code>
 371        */
 372       public static final int EVENTED_STRING_VALUE = 6;
 373       /**
 374        * <code>EVENTED_BOOL = 7;</code>
 375        */
 376       public static final int EVENTED_BOOL_VALUE = 7;
 377
 378
 379       public final int getNumber() { return value; }
 380
 381       public static Type valueOf(int value) {
 382         switch (value) {
 383           case 1: return RAW;
 384           case 2: return STRING;
 385           case 3: return BOOL;
 386           case 4: return NUM;
 387           case 5: return EVENTED_NUM;
 388           case 6: return EVENTED_STRING;
 389           case 7: return EVENTED_BOOL;
 390           default: return null;
 391         }
 392       }
 393
 394       public static com.google.protobuf.Internal.EnumLiteMap<Type>
 395           internalGetValueMap() {
 396         return internalValueMap;
 397       }
 398       private static com.google.protobuf.Internal.EnumLiteMap<Type>
 399           internalValueMap =
 400             new com.google.protobuf.Internal.EnumLiteMap<Type>() {
 401               public Type findValueByNumber(int number) {
 402                 return Type.valueOf(number);
 403               }
 404             };
 405
 406       public final com.google.protobuf.Descriptors.EnumValueDescriptor
 407           getValueDescriptor() {
 408         return getDescriptor().getValues().get(index);
 409       }
 410       public final com.google.protobuf.Descriptors.EnumDescriptor
 411           getDescriptorForType() {
 412         return getDescriptor();
 413       }
 414       public static final com.google.protobuf.Descriptors.EnumDescriptor
 415           getDescriptor() {
 416         return com.openxc.BinaryMessages.VehicleMessage.getDescriptor().getEnumTypes().get(0);
 417       }
 418
 419       private static final Type[] VALUES = values();
 420
 421       public static Type valueOf(
 422           com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
 423         if (desc.getType() != getDescriptor()) {
 424           throw new java.lang.IllegalArgumentException(
 425             "EnumValueDescriptor is not for this type.");
 426         }
 427         return VALUES[desc.getIndex()];
 428       }
 429
 430       private final int index;
 431       private final int value;
 432
 433       private Type(int index, int value) {
 434         this.index = index;
 435         this.value = value;
 436       }
 437
 438       // @@protoc_insertion_point(enum_scope:openxc.VehicleMessage.Type)
 439     }
 440
 441     private int bitField0_;
 442     // optional .openxc.VehicleMessage.Type type = 1;
 443     public static final int TYPE_FIELD_NUMBER = 1;
 444     private com.openxc.BinaryMessages.VehicleMessage.Type type_;
 445     /**
 446      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 447      */
 448     public boolean hasType() {
 449       return ((bitField0_ & 0x00000001) == 0x00000001);
 450     }
 451     /**
 452      * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
 453      */
 454     public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
 455       return type_;
 456     }
 457
 458     // optional .openxc.RawMessage raw_message = 2;
 459     public static final int RAW_MESSAGE_FIELD_NUMBER = 2;
 460     private com.openxc.BinaryMessages.RawMessage rawMessage_;
 461     /**
 462      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 463      */
 464     public boolean hasRawMessage() {
 465       return ((bitField0_ & 0x00000002) == 0x00000002);
 466     }
 467     /**
 468      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 469      */
 470     public com.openxc.BinaryMessages.RawMessage getRawMessage() {
 471       return rawMessage_;
 472     }
 473     /**
 474      * <code>optional .openxc.RawMessage raw_message = 2;</code>
 475      */
 476     public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
 477       return rawMessage_;
 478     }
 479
 480     // optional .openxc.StringMessage string_message = 3;
 481     public static final int STRING_MESSAGE_FIELD_NUMBER = 3;
 482     private com.openxc.BinaryMessages.StringMessage stringMessage_;
 483     /**
 484      * <code>optional .openxc.StringMessage string_message = 3;</code>
 485      */
 486     public boolean hasStringMessage() {
 487       return ((bitField0_ & 0x00000004) == 0x00000004);
 488     }
 489     /**
 490      * <code>optional .openxc.StringMessage string_message = 3;</code>
 491      */
 492     public com.openxc.BinaryMessages.StringMessage getStringMessage() {
 493       return stringMessage_;
 494     }
 495     /**
 496      * <code>optional .openxc.StringMessage string_message = 3;</code>
 497      */
 498     public com.openxc.BinaryMessages.StringMessageOrBuilder getStringMessageOrBuilder() {
 499       return stringMessage_;
 500     }
 501
 502     // optional .openxc.NumericMessage numeric_message = 4;
 503     public static final int NUMERIC_MESSAGE_FIELD_NUMBER = 4;
 504     private com.openxc.BinaryMessages.NumericMessage numericMessage_;
 505     /**
 506      * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
 507      */
 508     public boolean hasNumericMessage() {
 509       return ((bitField0_ & 0x00000008) == 0x00000008);
 510     }
 511     /**
 512      * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
 513      */
 514     public com.openxc.BinaryMessages.NumericMessage getNumericMessage() {
 515       return numericMessage_;
 516     }
 517     /**
 518      * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
 519      */
 520     public com.openxc.BinaryMessages.NumericMessageOrBuilder getNumericMessageOrBuilder() {
 521       return numericMessage_;
 522     }
 523
 524     // optional .openxc.BooleanMessage boolean_message = 5;
 525     public static final int BOOLEAN_MESSAGE_FIELD_NUMBER = 5;
 526     private com.openxc.BinaryMessages.BooleanMessage booleanMessage_;
 527     /**
 528      * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
 529      */
 530     public boolean hasBooleanMessage() {
 531       return ((bitField0_ & 0x00000010) == 0x00000010);
 532     }
 533     /**
 534      * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
 535      */
 536     public com.openxc.BinaryMessages.BooleanMessage getBooleanMessage() {
 537       return booleanMessage_;
 538     }
 539     /**
 540      * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
 541      */
 542     public com.openxc.BinaryMessages.BooleanMessageOrBuilder getBooleanMessageOrBuilder() {
 543       return booleanMessage_;
 544     }
 545
 546     // optional .openxc.EventedStringMessage evented_string_message = 6;
 547     public static final int EVENTED_STRING_MESSAGE_FIELD_NUMBER = 6;
 548     private com.openxc.BinaryMessages.EventedStringMessage eventedStringMessage_;
 549     /**
 550      * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
 551      */
 552     public boolean hasEventedStringMessage() {
 553       return ((bitField0_ & 0x00000020) == 0x00000020);
 554     }
 555     /**
 556      * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
 557      */
 558     public com.openxc.BinaryMessages.EventedStringMessage getEventedStringMessage() {
 559       return eventedStringMessage_;
 560     }
 561     /**
 562      * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
 563      */
 564     public com.openxc.BinaryMessages.EventedStringMessageOrBuilder getEventedStringMessageOrBuilder() {
 565       return eventedStringMessage_;
 566     }
 567
 568     // optional .openxc.EventedBooleanMessage evented_boolean_message = 7;
 569     public static final int EVENTED_BOOLEAN_MESSAGE_FIELD_NUMBER = 7;
 570     private com.openxc.BinaryMessages.EventedBooleanMessage eventedBooleanMessage_;
 571     /**
 572      * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
 573      */
 574     public boolean hasEventedBooleanMessage() {
 575       return ((bitField0_ & 0x00000040) == 0x00000040);
 576     }
 577     /**
 578      * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
 579      */
 580     public com.openxc.BinaryMessages.EventedBooleanMessage getEventedBooleanMessage() {
 581       return eventedBooleanMessage_;
 582     }
 583     /**
 584      * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
 585      */
 586     public com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder getEventedBooleanMessageOrBuilder() {
 587       return eventedBooleanMessage_;
 588     }
 589
 590     // optional .openxc.EventedNumericMessage evented_numeric_message = 8;
 591     public static final int EVENTED_NUMERIC_MESSAGE_FIELD_NUMBER = 8;
 592     private com.openxc.BinaryMessages.EventedNumericMessage eventedNumericMessage_;
 593     /**
 594      * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
 595      */
 596     public boolean hasEventedNumericMessage() {
 597       return ((bitField0_ & 0x00000080) == 0x00000080);
 598     }
 599     /**
 600      * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
 601      */
 602     public com.openxc.BinaryMessages.EventedNumericMessage getEventedNumericMessage() {
 603       return eventedNumericMessage_;
 604     }
 605     /**
 606      * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
 607      */
 608     public com.openxc.BinaryMessages.EventedNumericMessageOrBuilder getEventedNumericMessageOrBuilder() {
 609       return eventedNumericMessage_;
 610     }
 611
 612     private void initFields() {
 613       type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 614       rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 615       stringMessage_ = com.openxc.BinaryMessages.StringMessage.getDefaultInstance();
 616       numericMessage_ = com.openxc.BinaryMessages.NumericMessage.getDefaultInstance();
 617       booleanMessage_ = com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance();
 618       eventedStringMessage_ = com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance();
 619       eventedBooleanMessage_ = com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance();
 620       eventedNumericMessage_ = com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance();
 621     }
 622     private byte memoizedIsInitialized = -1;
 623     public final boolean isInitialized() {
 624       byte isInitialized = memoizedIsInitialized;
 625       if (isInitialized != -1) return isInitialized == 1;
 626
 627       memoizedIsInitialized = 1;
 628       return true;
 629     }
 630
 631     public void writeTo(com.google.protobuf.CodedOutputStream output)
 632                         throws java.io.IOException {
 633       getSerializedSize();
 634       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 635         output.writeEnum(1, type_.getNumber());
 636       }
 637       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 638         output.writeMessage(2, rawMessage_);
 639       }
 640       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 641         output.writeMessage(3, stringMessage_);
 642       }
 643       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 644         output.writeMessage(4, numericMessage_);
 645       }
 646       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 647         output.writeMessage(5, booleanMessage_);
 648       }
 649       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 650         output.writeMessage(6, eventedStringMessage_);
 651       }
 652       if (((bitField0_ & 0x00000040) == 0x00000040)) {
 653         output.writeMessage(7, eventedBooleanMessage_);
 654       }
 655       if (((bitField0_ & 0x00000080) == 0x00000080)) {
 656         output.writeMessage(8, eventedNumericMessage_);
 657       }
 658       getUnknownFields().writeTo(output);
 659     }
 660
 661     private int memoizedSerializedSize = -1;
 662     public int getSerializedSize() {
 663       int size = memoizedSerializedSize;
 664       if (size != -1) return size;
 665
 666       size = 0;
 667       if (((bitField0_ & 0x00000001) == 0x00000001)) {
 668         size += com.google.protobuf.CodedOutputStream
 669           .computeEnumSize(1, type_.getNumber());
 670       }
 671       if (((bitField0_ & 0x00000002) == 0x00000002)) {
 672         size += com.google.protobuf.CodedOutputStream
 673           .computeMessageSize(2, rawMessage_);
 674       }
 675       if (((bitField0_ & 0x00000004) == 0x00000004)) {
 676         size += com.google.protobuf.CodedOutputStream
 677           .computeMessageSize(3, stringMessage_);
 678       }
 679       if (((bitField0_ & 0x00000008) == 0x00000008)) {
 680         size += com.google.protobuf.CodedOutputStream
 681           .computeMessageSize(4, numericMessage_);
 682       }
 683       if (((bitField0_ & 0x00000010) == 0x00000010)) {
 684         size += com.google.protobuf.CodedOutputStream
 685           .computeMessageSize(5, booleanMessage_);
 686       }
 687       if (((bitField0_ & 0x00000020) == 0x00000020)) {
 688         size += com.google.protobuf.CodedOutputStream
 689           .computeMessageSize(6, eventedStringMessage_);
 690       }
 691       if (((bitField0_ & 0x00000040) == 0x00000040)) {
 692         size += com.google.protobuf.CodedOutputStream
 693           .computeMessageSize(7, eventedBooleanMessage_);
 694       }
 695       if (((bitField0_ & 0x00000080) == 0x00000080)) {
 696         size += com.google.protobuf.CodedOutputStream
 697           .computeMessageSize(8, eventedNumericMessage_);
 698       }
 699       size += getUnknownFields().getSerializedSize();
 700       memoizedSerializedSize = size;
 701       return size;
 702     }
 703
 704     private static final long serialVersionUID = 0L;
 705     @java.lang.Override
 706     protected java.lang.Object writeReplace()
 707         throws java.io.ObjectStreamException {
 708       return super.writeReplace();
 709     }
 710
 711     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 712         com.google.protobuf.ByteString data)
 713         throws com.google.protobuf.InvalidProtocolBufferException {
 714       return PARSER.parseFrom(data);
 715     }
 716     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 717         com.google.protobuf.ByteString data,
 718         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 719         throws com.google.protobuf.InvalidProtocolBufferException {
 720       return PARSER.parseFrom(data, extensionRegistry);
 721     }
 722     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(byte[] data)
 723         throws com.google.protobuf.InvalidProtocolBufferException {
 724       return PARSER.parseFrom(data);
 725     }
 726     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 727         byte[] data,
 728         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 729         throws com.google.protobuf.InvalidProtocolBufferException {
 730       return PARSER.parseFrom(data, extensionRegistry);
 731     }
 732     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(java.io.InputStream input)
 733         throws java.io.IOException {
 734       return PARSER.parseFrom(input);
 735     }
 736     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 737         java.io.InputStream input,
 738         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 739         throws java.io.IOException {
 740       return PARSER.parseFrom(input, extensionRegistry);
 741     }
 742     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(java.io.InputStream input)
 743         throws java.io.IOException {
 744       return PARSER.parseDelimitedFrom(input);
 745     }
 746     public static com.openxc.BinaryMessages.VehicleMessage parseDelimitedFrom(
 747         java.io.InputStream input,
 748         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 749         throws java.io.IOException {
 750       return PARSER.parseDelimitedFrom(input, extensionRegistry);
 751     }
 752     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 753         com.google.protobuf.CodedInputStream input)
 754         throws java.io.IOException {
 755       return PARSER.parseFrom(input);
 756     }
 757     public static com.openxc.BinaryMessages.VehicleMessage parseFrom(
 758         com.google.protobuf.CodedInputStream input,
 759         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
 760         throws java.io.IOException {
 761       return PARSER.parseFrom(input, extensionRegistry);
 762     }
 763
 764     public static Builder newBuilder() { return Builder.create(); }
 765     public Builder newBuilderForType() { return newBuilder(); }
 766     public static Builder newBuilder(com.openxc.BinaryMessages.VehicleMessage prototype) {
 767       return newBuilder().mergeFrom(prototype);
 768     }
 769     public Builder toBuilder() { return newBuilder(this); }
 770
 771     @java.lang.Override
 772     protected Builder newBuilderForType(
 773         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 774       Builder builder = new Builder(parent);
 775       return builder;
 776     }
 777     /**
 778      * Protobuf type {@code openxc.VehicleMessage}
 779      */
 780     public static final class Builder extends
 781         com.google.protobuf.GeneratedMessage.Builder<Builder>
 782        implements com.openxc.BinaryMessages.VehicleMessageOrBuilder {
 783       public static final com.google.protobuf.Descriptors.Descriptor
 784           getDescriptor() {
 785         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 786       }
 787
 788       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
 789           internalGetFieldAccessorTable() {
 790         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_fieldAccessorTable
 791             .ensureFieldAccessorsInitialized(
 792                 com.openxc.BinaryMessages.VehicleMessage.class, com.openxc.BinaryMessages.VehicleMessage.Builder.class);
 793       }
 794
 795       // Construct using com.openxc.BinaryMessages.VehicleMessage.newBuilder()
 796       private Builder() {
 797         maybeForceBuilderInitialization();
 798       }
 799
 800       private Builder(
 801           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
 802         super(parent);
 803         maybeForceBuilderInitialization();
 804       }
 805       private void maybeForceBuilderInitialization() {
 806         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
 807           getRawMessageFieldBuilder();
 808           getStringMessageFieldBuilder();
 809           getNumericMessageFieldBuilder();
 810           getBooleanMessageFieldBuilder();
 811           getEventedStringMessageFieldBuilder();
 812           getEventedBooleanMessageFieldBuilder();
 813           getEventedNumericMessageFieldBuilder();
 814         }
 815       }
 816       private static Builder create() {
 817         return new Builder();
 818       }
 819
 820       public Builder clear() {
 821         super.clear();
 822         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
 823         bitField0_ = (bitField0_ & ~0x00000001);
 824         if (rawMessageBuilder_ == null) {
 825           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
 826         } else {
 827           rawMessageBuilder_.clear();
 828         }
 829         bitField0_ = (bitField0_ & ~0x00000002);
 830         if (stringMessageBuilder_ == null) {
 831           stringMessage_ = com.openxc.BinaryMessages.StringMessage.getDefaultInstance();
 832         } else {
 833           stringMessageBuilder_.clear();
 834         }
 835         bitField0_ = (bitField0_ & ~0x00000004);
 836         if (numericMessageBuilder_ == null) {
 837           numericMessage_ = com.openxc.BinaryMessages.NumericMessage.getDefaultInstance();
 838         } else {
 839           numericMessageBuilder_.clear();
 840         }
 841         bitField0_ = (bitField0_ & ~0x00000008);
 842         if (booleanMessageBuilder_ == null) {
 843           booleanMessage_ = com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance();
 844         } else {
 845           booleanMessageBuilder_.clear();
 846         }
 847         bitField0_ = (bitField0_ & ~0x00000010);
 848         if (eventedStringMessageBuilder_ == null) {
 849           eventedStringMessage_ = com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance();
 850         } else {
 851           eventedStringMessageBuilder_.clear();
 852         }
 853         bitField0_ = (bitField0_ & ~0x00000020);
 854         if (eventedBooleanMessageBuilder_ == null) {
 855           eventedBooleanMessage_ = com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance();
 856         } else {
 857           eventedBooleanMessageBuilder_.clear();
 858         }
 859         bitField0_ = (bitField0_ & ~0x00000040);
 860         if (eventedNumericMessageBuilder_ == null) {
 861           eventedNumericMessage_ = com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance();
 862         } else {
 863           eventedNumericMessageBuilder_.clear();
 864         }
 865         bitField0_ = (bitField0_ & ~0x00000080);
 866         return this;
 867       }
 868
 869       public Builder clone() {
 870         return create().mergeFrom(buildPartial());
 871       }
 872
 873       public com.google.protobuf.Descriptors.Descriptor
 874           getDescriptorForType() {
 875         return com.openxc.BinaryMessages.internal_static_openxc_VehicleMessage_descriptor;
 876       }
 877
 878       public com.openxc.BinaryMessages.VehicleMessage getDefaultInstanceForType() {
 879         return com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance();
 880       }
 881
 882       public com.openxc.BinaryMessages.VehicleMessage build() {
 883         com.openxc.BinaryMessages.VehicleMessage result = buildPartial();
 884         if (!result.isInitialized()) {
 885           throw newUninitializedMessageException(result);
 886         }
 887         return result;
 888       }
 889
 890       public com.openxc.BinaryMessages.VehicleMessage buildPartial() {
 891         com.openxc.BinaryMessages.VehicleMessage result = new com.openxc.BinaryMessages.VehicleMessage(this);
 892         int from_bitField0_ = bitField0_;
 893         int to_bitField0_ = 0;
 894         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
 895           to_bitField0_ |= 0x00000001;
 896         }
 897         result.type_ = type_;
 898         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
 899           to_bitField0_ |= 0x00000002;
 900         }
 901         if (rawMessageBuilder_ == null) {
 902           result.rawMessage_ = rawMessage_;
 903         } else {
 904           result.rawMessage_ = rawMessageBuilder_.build();
 905         }
 906         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
 907           to_bitField0_ |= 0x00000004;
 908         }
 909         if (stringMessageBuilder_ == null) {
 910           result.stringMessage_ = stringMessage_;
 911         } else {
 912           result.stringMessage_ = stringMessageBuilder_.build();
 913         }
 914         if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
 915           to_bitField0_ |= 0x00000008;
 916         }
 917         if (numericMessageBuilder_ == null) {
 918           result.numericMessage_ = numericMessage_;
 919         } else {
 920           result.numericMessage_ = numericMessageBuilder_.build();
 921         }
 922         if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
 923           to_bitField0_ |= 0x00000010;
 924         }
 925         if (booleanMessageBuilder_ == null) {
 926           result.booleanMessage_ = booleanMessage_;
 927         } else {
 928           result.booleanMessage_ = booleanMessageBuilder_.build();
 929         }
 930         if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
 931           to_bitField0_ |= 0x00000020;
 932         }
 933         if (eventedStringMessageBuilder_ == null) {
 934           result.eventedStringMessage_ = eventedStringMessage_;
 935         } else {
 936           result.eventedStringMessage_ = eventedStringMessageBuilder_.build();
 937         }
 938         if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
 939           to_bitField0_ |= 0x00000040;
 940         }
 941         if (eventedBooleanMessageBuilder_ == null) {
 942           result.eventedBooleanMessage_ = eventedBooleanMessage_;
 943         } else {
 944           result.eventedBooleanMessage_ = eventedBooleanMessageBuilder_.build();
 945         }
 946         if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
 947           to_bitField0_ |= 0x00000080;
 948         }
 949         if (eventedNumericMessageBuilder_ == null) {
 950           result.eventedNumericMessage_ = eventedNumericMessage_;
 951         } else {
 952           result.eventedNumericMessage_ = eventedNumericMessageBuilder_.build();
 953         }
 954         result.bitField0_ = to_bitField0_;
 955         onBuilt();
 956         return result;
 957       }
 958
 959       public Builder mergeFrom(com.google.protobuf.Message other) {
 960         if (other instanceof com.openxc.BinaryMessages.VehicleMessage) {
 961           return mergeFrom((com.openxc.BinaryMessages.VehicleMessage)other);
 962         } else {
 963           super.mergeFrom(other);
 964           return this;
 965         }
 966       }
 967
 968       public Builder mergeFrom(com.openxc.BinaryMessages.VehicleMessage other) {
 969         if (other == com.openxc.BinaryMessages.VehicleMessage.getDefaultInstance()) return this;
 970         if (other.hasType()) {
 971           setType(other.getType());
 972         }
 973         if (other.hasRawMessage()) {
 974           mergeRawMessage(other.getRawMessage());
 975         }
 976         if (other.hasStringMessage()) {
 977           mergeStringMessage(other.getStringMessage());
 978         }
 979         if (other.hasNumericMessage()) {
 980           mergeNumericMessage(other.getNumericMessage());
 981         }
 982         if (other.hasBooleanMessage()) {
 983           mergeBooleanMessage(other.getBooleanMessage());
 984         }
 985         if (other.hasEventedStringMessage()) {
 986           mergeEventedStringMessage(other.getEventedStringMessage());
 987         }
 988         if (other.hasEventedBooleanMessage()) {
 989           mergeEventedBooleanMessage(other.getEventedBooleanMessage());
 990         }
 991         if (other.hasEventedNumericMessage()) {
 992           mergeEventedNumericMessage(other.getEventedNumericMessage());
 993         }
 994         this.mergeUnknownFields(other.getUnknownFields());
 995         return this;
 996       }
 997
 998       public final boolean isInitialized() {
 999         return true;
1000       }
1001
1002       public Builder mergeFrom(
1003           com.google.protobuf.CodedInputStream input,
1004           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1005           throws java.io.IOException {
1006         com.openxc.BinaryMessages.VehicleMessage parsedMessage = null;
1007         try {
1008           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
1009         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1010           parsedMessage = (com.openxc.BinaryMessages.VehicleMessage) e.getUnfinishedMessage();
1011           throw e;
1012         } finally {
1013           if (parsedMessage != null) {
1014             mergeFrom(parsedMessage);
1015           }
1016         }
1017         return this;
1018       }
1019       private int bitField0_;
1020
1021       // optional .openxc.VehicleMessage.Type type = 1;
1022       private com.openxc.BinaryMessages.VehicleMessage.Type type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
1023       /**
1024        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
1025        */
1026       public boolean hasType() {
1027         return ((bitField0_ & 0x00000001) == 0x00000001);
1028       }
1029       /**
1030        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
1031        */
1032       public com.openxc.BinaryMessages.VehicleMessage.Type getType() {
1033         return type_;
1034       }
1035       /**
1036        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
1037        */
1038       public Builder setType(com.openxc.BinaryMessages.VehicleMessage.Type value) {
1039         if (value == null) {
1040           throw new NullPointerException();
1041         }
1042         bitField0_ |= 0x00000001;
1043         type_ = value;
1044         onChanged();
1045         return this;
1046       }
1047       /**
1048        * <code>optional .openxc.VehicleMessage.Type type = 1;</code>
1049        */
1050       public Builder clearType() {
1051         bitField0_ = (bitField0_ & ~0x00000001);
1052         type_ = com.openxc.BinaryMessages.VehicleMessage.Type.RAW;
1053         onChanged();
1054         return this;
1055       }
1056
1057       // optional .openxc.RawMessage raw_message = 2;
1058       private com.openxc.BinaryMessages.RawMessage rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1059       private com.google.protobuf.SingleFieldBuilder<
1060           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder> rawMessageBuilder_;
1061       /**
1062        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1063        */
1064       public boolean hasRawMessage() {
1065         return ((bitField0_ & 0x00000002) == 0x00000002);
1066       }
1067       /**
1068        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1069        */
1070       public com.openxc.BinaryMessages.RawMessage getRawMessage() {
1071         if (rawMessageBuilder_ == null) {
1072           return rawMessage_;
1073         } else {
1074           return rawMessageBuilder_.getMessage();
1075         }
1076       }
1077       /**
1078        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1079        */
1080       public Builder setRawMessage(com.openxc.BinaryMessages.RawMessage value) {
1081         if (rawMessageBuilder_ == null) {
1082           if (value == null) {
1083             throw new NullPointerException();
1084           }
1085           rawMessage_ = value;
1086           onChanged();
1087         } else {
1088           rawMessageBuilder_.setMessage(value);
1089         }
1090         bitField0_ |= 0x00000002;
1091         return this;
1092       }
1093       /**
1094        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1095        */
1096       public Builder setRawMessage(
1097           com.openxc.BinaryMessages.RawMessage.Builder builderForValue) {
1098         if (rawMessageBuilder_ == null) {
1099           rawMessage_ = builderForValue.build();
1100           onChanged();
1101         } else {
1102           rawMessageBuilder_.setMessage(builderForValue.build());
1103         }
1104         bitField0_ |= 0x00000002;
1105         return this;
1106       }
1107       /**
1108        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1109        */
1110       public Builder mergeRawMessage(com.openxc.BinaryMessages.RawMessage value) {
1111         if (rawMessageBuilder_ == null) {
1112           if (((bitField0_ & 0x00000002) == 0x00000002) &&
1113               rawMessage_ != com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) {
1114             rawMessage_ =
1115               com.openxc.BinaryMessages.RawMessage.newBuilder(rawMessage_).mergeFrom(value).buildPartial();
1116           } else {
1117             rawMessage_ = value;
1118           }
1119           onChanged();
1120         } else {
1121           rawMessageBuilder_.mergeFrom(value);
1122         }
1123         bitField0_ |= 0x00000002;
1124         return this;
1125       }
1126       /**
1127        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1128        */
1129       public Builder clearRawMessage() {
1130         if (rawMessageBuilder_ == null) {
1131           rawMessage_ = com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
1132           onChanged();
1133         } else {
1134           rawMessageBuilder_.clear();
1135         }
1136         bitField0_ = (bitField0_ & ~0x00000002);
1137         return this;
1138       }
1139       /**
1140        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1141        */
1142       public com.openxc.BinaryMessages.RawMessage.Builder getRawMessageBuilder() {
1143         bitField0_ |= 0x00000002;
1144         onChanged();
1145         return getRawMessageFieldBuilder().getBuilder();
1146       }
1147       /**
1148        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1149        */
1150       public com.openxc.BinaryMessages.RawMessageOrBuilder getRawMessageOrBuilder() {
1151         if (rawMessageBuilder_ != null) {
1152           return rawMessageBuilder_.getMessageOrBuilder();
1153         } else {
1154           return rawMessage_;
1155         }
1156       }
1157       /**
1158        * <code>optional .openxc.RawMessage raw_message = 2;</code>
1159        */
1160       private com.google.protobuf.SingleFieldBuilder<
1161           com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>
1162           getRawMessageFieldBuilder() {
1163         if (rawMessageBuilder_ == null) {
1164           rawMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1165               com.openxc.BinaryMessages.RawMessage, com.openxc.BinaryMessages.RawMessage.Builder, com.openxc.BinaryMessages.RawMessageOrBuilder>(
1166                   rawMessage_,
1167                   getParentForChildren(),
1168                   isClean());
1169           rawMessage_ = null;
1170         }
1171         return rawMessageBuilder_;
1172       }
1173
1174       // optional .openxc.StringMessage string_message = 3;
1175       private com.openxc.BinaryMessages.StringMessage stringMessage_ = com.openxc.BinaryMessages.StringMessage.getDefaultInstance();
1176       private com.google.protobuf.SingleFieldBuilder<
1177           com.openxc.BinaryMessages.StringMessage, com.openxc.BinaryMessages.StringMessage.Builder, com.openxc.BinaryMessages.StringMessageOrBuilder> stringMessageBuilder_;
1178       /**
1179        * <code>optional .openxc.StringMessage string_message = 3;</code>
1180        */
1181       public boolean hasStringMessage() {
1182         return ((bitField0_ & 0x00000004) == 0x00000004);
1183       }
1184       /**
1185        * <code>optional .openxc.StringMessage string_message = 3;</code>
1186        */
1187       public com.openxc.BinaryMessages.StringMessage getStringMessage() {
1188         if (stringMessageBuilder_ == null) {
1189           return stringMessage_;
1190         } else {
1191           return stringMessageBuilder_.getMessage();
1192         }
1193       }
1194       /**
1195        * <code>optional .openxc.StringMessage string_message = 3;</code>
1196        */
1197       public Builder setStringMessage(com.openxc.BinaryMessages.StringMessage value) {
1198         if (stringMessageBuilder_ == null) {
1199           if (value == null) {
1200             throw new NullPointerException();
1201           }
1202           stringMessage_ = value;
1203           onChanged();
1204         } else {
1205           stringMessageBuilder_.setMessage(value);
1206         }
1207         bitField0_ |= 0x00000004;
1208         return this;
1209       }
1210       /**
1211        * <code>optional .openxc.StringMessage string_message = 3;</code>
1212        */
1213       public Builder setStringMessage(
1214           com.openxc.BinaryMessages.StringMessage.Builder builderForValue) {
1215         if (stringMessageBuilder_ == null) {
1216           stringMessage_ = builderForValue.build();
1217           onChanged();
1218         } else {
1219           stringMessageBuilder_.setMessage(builderForValue.build());
1220         }
1221         bitField0_ |= 0x00000004;
1222         return this;
1223       }
1224       /**
1225        * <code>optional .openxc.StringMessage string_message = 3;</code>
1226        */
1227       public Builder mergeStringMessage(com.openxc.BinaryMessages.StringMessage value) {
1228         if (stringMessageBuilder_ == null) {
1229           if (((bitField0_ & 0x00000004) == 0x00000004) &&
1230               stringMessage_ != com.openxc.BinaryMessages.StringMessage.getDefaultInstance()) {
1231             stringMessage_ =
1232               com.openxc.BinaryMessages.StringMessage.newBuilder(stringMessage_).mergeFrom(value).buildPartial();
1233           } else {
1234             stringMessage_ = value;
1235           }
1236           onChanged();
1237         } else {
1238           stringMessageBuilder_.mergeFrom(value);
1239         }
1240         bitField0_ |= 0x00000004;
1241         return this;
1242       }
1243       /**
1244        * <code>optional .openxc.StringMessage string_message = 3;</code>
1245        */
1246       public Builder clearStringMessage() {
1247         if (stringMessageBuilder_ == null) {
1248           stringMessage_ = com.openxc.BinaryMessages.StringMessage.getDefaultInstance();
1249           onChanged();
1250         } else {
1251           stringMessageBuilder_.clear();
1252         }
1253         bitField0_ = (bitField0_ & ~0x00000004);
1254         return this;
1255       }
1256       /**
1257        * <code>optional .openxc.StringMessage string_message = 3;</code>
1258        */
1259       public com.openxc.BinaryMessages.StringMessage.Builder getStringMessageBuilder() {
1260         bitField0_ |= 0x00000004;
1261         onChanged();
1262         return getStringMessageFieldBuilder().getBuilder();
1263       }
1264       /**
1265        * <code>optional .openxc.StringMessage string_message = 3;</code>
1266        */
1267       public com.openxc.BinaryMessages.StringMessageOrBuilder getStringMessageOrBuilder() {
1268         if (stringMessageBuilder_ != null) {
1269           return stringMessageBuilder_.getMessageOrBuilder();
1270         } else {
1271           return stringMessage_;
1272         }
1273       }
1274       /**
1275        * <code>optional .openxc.StringMessage string_message = 3;</code>
1276        */
1277       private com.google.protobuf.SingleFieldBuilder<
1278           com.openxc.BinaryMessages.StringMessage, com.openxc.BinaryMessages.StringMessage.Builder, com.openxc.BinaryMessages.StringMessageOrBuilder>
1279           getStringMessageFieldBuilder() {
1280         if (stringMessageBuilder_ == null) {
1281           stringMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1282               com.openxc.BinaryMessages.StringMessage, com.openxc.BinaryMessages.StringMessage.Builder, com.openxc.BinaryMessages.StringMessageOrBuilder>(
1283                   stringMessage_,
1284                   getParentForChildren(),
1285                   isClean());
1286           stringMessage_ = null;
1287         }
1288         return stringMessageBuilder_;
1289       }
1290
1291       // optional .openxc.NumericMessage numeric_message = 4;
1292       private com.openxc.BinaryMessages.NumericMessage numericMessage_ = com.openxc.BinaryMessages.NumericMessage.getDefaultInstance();
1293       private com.google.protobuf.SingleFieldBuilder<
1294           com.openxc.BinaryMessages.NumericMessage, com.openxc.BinaryMessages.NumericMessage.Builder, com.openxc.BinaryMessages.NumericMessageOrBuilder> numericMessageBuilder_;
1295       /**
1296        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1297        */
1298       public boolean hasNumericMessage() {
1299         return ((bitField0_ & 0x00000008) == 0x00000008);
1300       }
1301       /**
1302        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1303        */
1304       public com.openxc.BinaryMessages.NumericMessage getNumericMessage() {
1305         if (numericMessageBuilder_ == null) {
1306           return numericMessage_;
1307         } else {
1308           return numericMessageBuilder_.getMessage();
1309         }
1310       }
1311       /**
1312        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1313        */
1314       public Builder setNumericMessage(com.openxc.BinaryMessages.NumericMessage value) {
1315         if (numericMessageBuilder_ == null) {
1316           if (value == null) {
1317             throw new NullPointerException();
1318           }
1319           numericMessage_ = value;
1320           onChanged();
1321         } else {
1322           numericMessageBuilder_.setMessage(value);
1323         }
1324         bitField0_ |= 0x00000008;
1325         return this;
1326       }
1327       /**
1328        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1329        */
1330       public Builder setNumericMessage(
1331           com.openxc.BinaryMessages.NumericMessage.Builder builderForValue) {
1332         if (numericMessageBuilder_ == null) {
1333           numericMessage_ = builderForValue.build();
1334           onChanged();
1335         } else {
1336           numericMessageBuilder_.setMessage(builderForValue.build());
1337         }
1338         bitField0_ |= 0x00000008;
1339         return this;
1340       }
1341       /**
1342        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1343        */
1344       public Builder mergeNumericMessage(com.openxc.BinaryMessages.NumericMessage value) {
1345         if (numericMessageBuilder_ == null) {
1346           if (((bitField0_ & 0x00000008) == 0x00000008) &&
1347               numericMessage_ != com.openxc.BinaryMessages.NumericMessage.getDefaultInstance()) {
1348             numericMessage_ =
1349               com.openxc.BinaryMessages.NumericMessage.newBuilder(numericMessage_).mergeFrom(value).buildPartial();
1350           } else {
1351             numericMessage_ = value;
1352           }
1353           onChanged();
1354         } else {
1355           numericMessageBuilder_.mergeFrom(value);
1356         }
1357         bitField0_ |= 0x00000008;
1358         return this;
1359       }
1360       /**
1361        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1362        */
1363       public Builder clearNumericMessage() {
1364         if (numericMessageBuilder_ == null) {
1365           numericMessage_ = com.openxc.BinaryMessages.NumericMessage.getDefaultInstance();
1366           onChanged();
1367         } else {
1368           numericMessageBuilder_.clear();
1369         }
1370         bitField0_ = (bitField0_ & ~0x00000008);
1371         return this;
1372       }
1373       /**
1374        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1375        */
1376       public com.openxc.BinaryMessages.NumericMessage.Builder getNumericMessageBuilder() {
1377         bitField0_ |= 0x00000008;
1378         onChanged();
1379         return getNumericMessageFieldBuilder().getBuilder();
1380       }
1381       /**
1382        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1383        */
1384       public com.openxc.BinaryMessages.NumericMessageOrBuilder getNumericMessageOrBuilder() {
1385         if (numericMessageBuilder_ != null) {
1386           return numericMessageBuilder_.getMessageOrBuilder();
1387         } else {
1388           return numericMessage_;
1389         }
1390       }
1391       /**
1392        * <code>optional .openxc.NumericMessage numeric_message = 4;</code>
1393        */
1394       private com.google.protobuf.SingleFieldBuilder<
1395           com.openxc.BinaryMessages.NumericMessage, com.openxc.BinaryMessages.NumericMessage.Builder, com.openxc.BinaryMessages.NumericMessageOrBuilder>
1396           getNumericMessageFieldBuilder() {
1397         if (numericMessageBuilder_ == null) {
1398           numericMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1399               com.openxc.BinaryMessages.NumericMessage, com.openxc.BinaryMessages.NumericMessage.Builder, com.openxc.BinaryMessages.NumericMessageOrBuilder>(
1400                   numericMessage_,
1401                   getParentForChildren(),
1402                   isClean());
1403           numericMessage_ = null;
1404         }
1405         return numericMessageBuilder_;
1406       }
1407
1408       // optional .openxc.BooleanMessage boolean_message = 5;
1409       private com.openxc.BinaryMessages.BooleanMessage booleanMessage_ = com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance();
1410       private com.google.protobuf.SingleFieldBuilder<
1411           com.openxc.BinaryMessages.BooleanMessage, com.openxc.BinaryMessages.BooleanMessage.Builder, com.openxc.BinaryMessages.BooleanMessageOrBuilder> booleanMessageBuilder_;
1412       /**
1413        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1414        */
1415       public boolean hasBooleanMessage() {
1416         return ((bitField0_ & 0x00000010) == 0x00000010);
1417       }
1418       /**
1419        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1420        */
1421       public com.openxc.BinaryMessages.BooleanMessage getBooleanMessage() {
1422         if (booleanMessageBuilder_ == null) {
1423           return booleanMessage_;
1424         } else {
1425           return booleanMessageBuilder_.getMessage();
1426         }
1427       }
1428       /**
1429        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1430        */
1431       public Builder setBooleanMessage(com.openxc.BinaryMessages.BooleanMessage value) {
1432         if (booleanMessageBuilder_ == null) {
1433           if (value == null) {
1434             throw new NullPointerException();
1435           }
1436           booleanMessage_ = value;
1437           onChanged();
1438         } else {
1439           booleanMessageBuilder_.setMessage(value);
1440         }
1441         bitField0_ |= 0x00000010;
1442         return this;
1443       }
1444       /**
1445        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1446        */
1447       public Builder setBooleanMessage(
1448           com.openxc.BinaryMessages.BooleanMessage.Builder builderForValue) {
1449         if (booleanMessageBuilder_ == null) {
1450           booleanMessage_ = builderForValue.build();
1451           onChanged();
1452         } else {
1453           booleanMessageBuilder_.setMessage(builderForValue.build());
1454         }
1455         bitField0_ |= 0x00000010;
1456         return this;
1457       }
1458       /**
1459        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1460        */
1461       public Builder mergeBooleanMessage(com.openxc.BinaryMessages.BooleanMessage value) {
1462         if (booleanMessageBuilder_ == null) {
1463           if (((bitField0_ & 0x00000010) == 0x00000010) &&
1464               booleanMessage_ != com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance()) {
1465             booleanMessage_ =
1466               com.openxc.BinaryMessages.BooleanMessage.newBuilder(booleanMessage_).mergeFrom(value).buildPartial();
1467           } else {
1468             booleanMessage_ = value;
1469           }
1470           onChanged();
1471         } else {
1472           booleanMessageBuilder_.mergeFrom(value);
1473         }
1474         bitField0_ |= 0x00000010;
1475         return this;
1476       }
1477       /**
1478        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1479        */
1480       public Builder clearBooleanMessage() {
1481         if (booleanMessageBuilder_ == null) {
1482           booleanMessage_ = com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance();
1483           onChanged();
1484         } else {
1485           booleanMessageBuilder_.clear();
1486         }
1487         bitField0_ = (bitField0_ & ~0x00000010);
1488         return this;
1489       }
1490       /**
1491        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1492        */
1493       public com.openxc.BinaryMessages.BooleanMessage.Builder getBooleanMessageBuilder() {
1494         bitField0_ |= 0x00000010;
1495         onChanged();
1496         return getBooleanMessageFieldBuilder().getBuilder();
1497       }
1498       /**
1499        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1500        */
1501       public com.openxc.BinaryMessages.BooleanMessageOrBuilder getBooleanMessageOrBuilder() {
1502         if (booleanMessageBuilder_ != null) {
1503           return booleanMessageBuilder_.getMessageOrBuilder();
1504         } else {
1505           return booleanMessage_;
1506         }
1507       }
1508       /**
1509        * <code>optional .openxc.BooleanMessage boolean_message = 5;</code>
1510        */
1511       private com.google.protobuf.SingleFieldBuilder<
1512           com.openxc.BinaryMessages.BooleanMessage, com.openxc.BinaryMessages.BooleanMessage.Builder, com.openxc.BinaryMessages.BooleanMessageOrBuilder>
1513           getBooleanMessageFieldBuilder() {
1514         if (booleanMessageBuilder_ == null) {
1515           booleanMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1516               com.openxc.BinaryMessages.BooleanMessage, com.openxc.BinaryMessages.BooleanMessage.Builder, com.openxc.BinaryMessages.BooleanMessageOrBuilder>(
1517                   booleanMessage_,
1518                   getParentForChildren(),
1519                   isClean());
1520           booleanMessage_ = null;
1521         }
1522         return booleanMessageBuilder_;
1523       }
1524
1525       // optional .openxc.EventedStringMessage evented_string_message = 6;
1526       private com.openxc.BinaryMessages.EventedStringMessage eventedStringMessage_ = com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance();
1527       private com.google.protobuf.SingleFieldBuilder<
1528           com.openxc.BinaryMessages.EventedStringMessage, com.openxc.BinaryMessages.EventedStringMessage.Builder, com.openxc.BinaryMessages.EventedStringMessageOrBuilder> eventedStringMessageBuilder_;
1529       /**
1530        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1531        */
1532       public boolean hasEventedStringMessage() {
1533         return ((bitField0_ & 0x00000020) == 0x00000020);
1534       }
1535       /**
1536        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1537        */
1538       public com.openxc.BinaryMessages.EventedStringMessage getEventedStringMessage() {
1539         if (eventedStringMessageBuilder_ == null) {
1540           return eventedStringMessage_;
1541         } else {
1542           return eventedStringMessageBuilder_.getMessage();
1543         }
1544       }
1545       /**
1546        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1547        */
1548       public Builder setEventedStringMessage(com.openxc.BinaryMessages.EventedStringMessage value) {
1549         if (eventedStringMessageBuilder_ == null) {
1550           if (value == null) {
1551             throw new NullPointerException();
1552           }
1553           eventedStringMessage_ = value;
1554           onChanged();
1555         } else {
1556           eventedStringMessageBuilder_.setMessage(value);
1557         }
1558         bitField0_ |= 0x00000020;
1559         return this;
1560       }
1561       /**
1562        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1563        */
1564       public Builder setEventedStringMessage(
1565           com.openxc.BinaryMessages.EventedStringMessage.Builder builderForValue) {
1566         if (eventedStringMessageBuilder_ == null) {
1567           eventedStringMessage_ = builderForValue.build();
1568           onChanged();
1569         } else {
1570           eventedStringMessageBuilder_.setMessage(builderForValue.build());
1571         }
1572         bitField0_ |= 0x00000020;
1573         return this;
1574       }
1575       /**
1576        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1577        */
1578       public Builder mergeEventedStringMessage(com.openxc.BinaryMessages.EventedStringMessage value) {
1579         if (eventedStringMessageBuilder_ == null) {
1580           if (((bitField0_ & 0x00000020) == 0x00000020) &&
1581               eventedStringMessage_ != com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance()) {
1582             eventedStringMessage_ =
1583               com.openxc.BinaryMessages.EventedStringMessage.newBuilder(eventedStringMessage_).mergeFrom(value).buildPartial();
1584           } else {
1585             eventedStringMessage_ = value;
1586           }
1587           onChanged();
1588         } else {
1589           eventedStringMessageBuilder_.mergeFrom(value);
1590         }
1591         bitField0_ |= 0x00000020;
1592         return this;
1593       }
1594       /**
1595        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1596        */
1597       public Builder clearEventedStringMessage() {
1598         if (eventedStringMessageBuilder_ == null) {
1599           eventedStringMessage_ = com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance();
1600           onChanged();
1601         } else {
1602           eventedStringMessageBuilder_.clear();
1603         }
1604         bitField0_ = (bitField0_ & ~0x00000020);
1605         return this;
1606       }
1607       /**
1608        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1609        */
1610       public com.openxc.BinaryMessages.EventedStringMessage.Builder getEventedStringMessageBuilder() {
1611         bitField0_ |= 0x00000020;
1612         onChanged();
1613         return getEventedStringMessageFieldBuilder().getBuilder();
1614       }
1615       /**
1616        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1617        */
1618       public com.openxc.BinaryMessages.EventedStringMessageOrBuilder getEventedStringMessageOrBuilder() {
1619         if (eventedStringMessageBuilder_ != null) {
1620           return eventedStringMessageBuilder_.getMessageOrBuilder();
1621         } else {
1622           return eventedStringMessage_;
1623         }
1624       }
1625       /**
1626        * <code>optional .openxc.EventedStringMessage evented_string_message = 6;</code>
1627        */
1628       private com.google.protobuf.SingleFieldBuilder<
1629           com.openxc.BinaryMessages.EventedStringMessage, com.openxc.BinaryMessages.EventedStringMessage.Builder, com.openxc.BinaryMessages.EventedStringMessageOrBuilder>
1630           getEventedStringMessageFieldBuilder() {
1631         if (eventedStringMessageBuilder_ == null) {
1632           eventedStringMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1633               com.openxc.BinaryMessages.EventedStringMessage, com.openxc.BinaryMessages.EventedStringMessage.Builder, com.openxc.BinaryMessages.EventedStringMessageOrBuilder>(
1634                   eventedStringMessage_,
1635                   getParentForChildren(),
1636                   isClean());
1637           eventedStringMessage_ = null;
1638         }
1639         return eventedStringMessageBuilder_;
1640       }
1641
1642       // optional .openxc.EventedBooleanMessage evented_boolean_message = 7;
1643       private com.openxc.BinaryMessages.EventedBooleanMessage eventedBooleanMessage_ = com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance();
1644       private com.google.protobuf.SingleFieldBuilder<
1645           com.openxc.BinaryMessages.EventedBooleanMessage, com.openxc.BinaryMessages.EventedBooleanMessage.Builder, com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder> eventedBooleanMessageBuilder_;
1646       /**
1647        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1648        */
1649       public boolean hasEventedBooleanMessage() {
1650         return ((bitField0_ & 0x00000040) == 0x00000040);
1651       }
1652       /**
1653        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1654        */
1655       public com.openxc.BinaryMessages.EventedBooleanMessage getEventedBooleanMessage() {
1656         if (eventedBooleanMessageBuilder_ == null) {
1657           return eventedBooleanMessage_;
1658         } else {
1659           return eventedBooleanMessageBuilder_.getMessage();
1660         }
1661       }
1662       /**
1663        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1664        */
1665       public Builder setEventedBooleanMessage(com.openxc.BinaryMessages.EventedBooleanMessage value) {
1666         if (eventedBooleanMessageBuilder_ == null) {
1667           if (value == null) {
1668             throw new NullPointerException();
1669           }
1670           eventedBooleanMessage_ = value;
1671           onChanged();
1672         } else {
1673           eventedBooleanMessageBuilder_.setMessage(value);
1674         }
1675         bitField0_ |= 0x00000040;
1676         return this;
1677       }
1678       /**
1679        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1680        */
1681       public Builder setEventedBooleanMessage(
1682           com.openxc.BinaryMessages.EventedBooleanMessage.Builder builderForValue) {
1683         if (eventedBooleanMessageBuilder_ == null) {
1684           eventedBooleanMessage_ = builderForValue.build();
1685           onChanged();
1686         } else {
1687           eventedBooleanMessageBuilder_.setMessage(builderForValue.build());
1688         }
1689         bitField0_ |= 0x00000040;
1690         return this;
1691       }
1692       /**
1693        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1694        */
1695       public Builder mergeEventedBooleanMessage(com.openxc.BinaryMessages.EventedBooleanMessage value) {
1696         if (eventedBooleanMessageBuilder_ == null) {
1697           if (((bitField0_ & 0x00000040) == 0x00000040) &&
1698               eventedBooleanMessage_ != com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance()) {
1699             eventedBooleanMessage_ =
1700               com.openxc.BinaryMessages.EventedBooleanMessage.newBuilder(eventedBooleanMessage_).mergeFrom(value).buildPartial();
1701           } else {
1702             eventedBooleanMessage_ = value;
1703           }
1704           onChanged();
1705         } else {
1706           eventedBooleanMessageBuilder_.mergeFrom(value);
1707         }
1708         bitField0_ |= 0x00000040;
1709         return this;
1710       }
1711       /**
1712        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1713        */
1714       public Builder clearEventedBooleanMessage() {
1715         if (eventedBooleanMessageBuilder_ == null) {
1716           eventedBooleanMessage_ = com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance();
1717           onChanged();
1718         } else {
1719           eventedBooleanMessageBuilder_.clear();
1720         }
1721         bitField0_ = (bitField0_ & ~0x00000040);
1722         return this;
1723       }
1724       /**
1725        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1726        */
1727       public com.openxc.BinaryMessages.EventedBooleanMessage.Builder getEventedBooleanMessageBuilder() {
1728         bitField0_ |= 0x00000040;
1729         onChanged();
1730         return getEventedBooleanMessageFieldBuilder().getBuilder();
1731       }
1732       /**
1733        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1734        */
1735       public com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder getEventedBooleanMessageOrBuilder() {
1736         if (eventedBooleanMessageBuilder_ != null) {
1737           return eventedBooleanMessageBuilder_.getMessageOrBuilder();
1738         } else {
1739           return eventedBooleanMessage_;
1740         }
1741       }
1742       /**
1743        * <code>optional .openxc.EventedBooleanMessage evented_boolean_message = 7;</code>
1744        */
1745       private com.google.protobuf.SingleFieldBuilder<
1746           com.openxc.BinaryMessages.EventedBooleanMessage, com.openxc.BinaryMessages.EventedBooleanMessage.Builder, com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder>
1747           getEventedBooleanMessageFieldBuilder() {
1748         if (eventedBooleanMessageBuilder_ == null) {
1749           eventedBooleanMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1750               com.openxc.BinaryMessages.EventedBooleanMessage, com.openxc.BinaryMessages.EventedBooleanMessage.Builder, com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder>(
1751                   eventedBooleanMessage_,
1752                   getParentForChildren(),
1753                   isClean());
1754           eventedBooleanMessage_ = null;
1755         }
1756         return eventedBooleanMessageBuilder_;
1757       }
1758
1759       // optional .openxc.EventedNumericMessage evented_numeric_message = 8;
1760       private com.openxc.BinaryMessages.EventedNumericMessage eventedNumericMessage_ = com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance();
1761       private com.google.protobuf.SingleFieldBuilder<
1762           com.openxc.BinaryMessages.EventedNumericMessage, com.openxc.BinaryMessages.EventedNumericMessage.Builder, com.openxc.BinaryMessages.EventedNumericMessageOrBuilder> eventedNumericMessageBuilder_;
1763       /**
1764        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1765        */
1766       public boolean hasEventedNumericMessage() {
1767         return ((bitField0_ & 0x00000080) == 0x00000080);
1768       }
1769       /**
1770        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1771        */
1772       public com.openxc.BinaryMessages.EventedNumericMessage getEventedNumericMessage() {
1773         if (eventedNumericMessageBuilder_ == null) {
1774           return eventedNumericMessage_;
1775         } else {
1776           return eventedNumericMessageBuilder_.getMessage();
1777         }
1778       }
1779       /**
1780        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1781        */
1782       public Builder setEventedNumericMessage(com.openxc.BinaryMessages.EventedNumericMessage value) {
1783         if (eventedNumericMessageBuilder_ == null) {
1784           if (value == null) {
1785             throw new NullPointerException();
1786           }
1787           eventedNumericMessage_ = value;
1788           onChanged();
1789         } else {
1790           eventedNumericMessageBuilder_.setMessage(value);
1791         }
1792         bitField0_ |= 0x00000080;
1793         return this;
1794       }
1795       /**
1796        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1797        */
1798       public Builder setEventedNumericMessage(
1799           com.openxc.BinaryMessages.EventedNumericMessage.Builder builderForValue) {
1800         if (eventedNumericMessageBuilder_ == null) {
1801           eventedNumericMessage_ = builderForValue.build();
1802           onChanged();
1803         } else {
1804           eventedNumericMessageBuilder_.setMessage(builderForValue.build());
1805         }
1806         bitField0_ |= 0x00000080;
1807         return this;
1808       }
1809       /**
1810        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1811        */
1812       public Builder mergeEventedNumericMessage(com.openxc.BinaryMessages.EventedNumericMessage value) {
1813         if (eventedNumericMessageBuilder_ == null) {
1814           if (((bitField0_ & 0x00000080) == 0x00000080) &&
1815               eventedNumericMessage_ != com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance()) {
1816             eventedNumericMessage_ =
1817               com.openxc.BinaryMessages.EventedNumericMessage.newBuilder(eventedNumericMessage_).mergeFrom(value).buildPartial();
1818           } else {
1819             eventedNumericMessage_ = value;
1820           }
1821           onChanged();
1822         } else {
1823           eventedNumericMessageBuilder_.mergeFrom(value);
1824         }
1825         bitField0_ |= 0x00000080;
1826         return this;
1827       }
1828       /**
1829        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1830        */
1831       public Builder clearEventedNumericMessage() {
1832         if (eventedNumericMessageBuilder_ == null) {
1833           eventedNumericMessage_ = com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance();
1834           onChanged();
1835         } else {
1836           eventedNumericMessageBuilder_.clear();
1837         }
1838         bitField0_ = (bitField0_ & ~0x00000080);
1839         return this;
1840       }
1841       /**
1842        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1843        */
1844       public com.openxc.BinaryMessages.EventedNumericMessage.Builder getEventedNumericMessageBuilder() {
1845         bitField0_ |= 0x00000080;
1846         onChanged();
1847         return getEventedNumericMessageFieldBuilder().getBuilder();
1848       }
1849       /**
1850        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1851        */
1852       public com.openxc.BinaryMessages.EventedNumericMessageOrBuilder getEventedNumericMessageOrBuilder() {
1853         if (eventedNumericMessageBuilder_ != null) {
1854           return eventedNumericMessageBuilder_.getMessageOrBuilder();
1855         } else {
1856           return eventedNumericMessage_;
1857         }
1858       }
1859       /**
1860        * <code>optional .openxc.EventedNumericMessage evented_numeric_message = 8;</code>
1861        */
1862       private com.google.protobuf.SingleFieldBuilder<
1863           com.openxc.BinaryMessages.EventedNumericMessage, com.openxc.BinaryMessages.EventedNumericMessage.Builder, com.openxc.BinaryMessages.EventedNumericMessageOrBuilder>
1864           getEventedNumericMessageFieldBuilder() {
1865         if (eventedNumericMessageBuilder_ == null) {
1866           eventedNumericMessageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
1867               com.openxc.BinaryMessages.EventedNumericMessage, com.openxc.BinaryMessages.EventedNumericMessage.Builder, com.openxc.BinaryMessages.EventedNumericMessageOrBuilder>(
1868                   eventedNumericMessage_,
1869                   getParentForChildren(),
1870                   isClean());
1871           eventedNumericMessage_ = null;
1872         }
1873         return eventedNumericMessageBuilder_;
1874       }
1875
1876       // @@protoc_insertion_point(builder_scope:openxc.VehicleMessage)
1877     }
1878
1879     static {
1880       defaultInstance = new VehicleMessage(true);
1881       defaultInstance.initFields();
1882     }
1883
1884     // @@protoc_insertion_point(class_scope:openxc.VehicleMessage)
1885   }
1886
1887   public interface RawMessageOrBuilder
1888       extends com.google.protobuf.MessageOrBuilder {
1889
1890     // optional int32 bus = 1;
1891     /**
1892      * <code>optional int32 bus = 1;</code>
1893      */
1894     boolean hasBus();
1895     /**
1896      * <code>optional int32 bus = 1;</code>
1897      */
1898     int getBus();
1899
1900     // optional uint32 message_id = 2;
1901     /**
1902      * <code>optional uint32 message_id = 2;</code>
1903      */
1904     boolean hasMessageId();
1905     /**
1906      * <code>optional uint32 message_id = 2;</code>
1907      */
1908     int getMessageId();
1909
1910     // optional uint64 data = 3;
1911     /**
1912      * <code>optional uint64 data = 3;</code>
1913      */
1914     boolean hasData();
1915     /**
1916      * <code>optional uint64 data = 3;</code>
1917      */
1918     long getData();
1919   }
1920   /**
1921    * Protobuf type {@code openxc.RawMessage}
1922    */
1923   public static final class RawMessage extends
1924       com.google.protobuf.GeneratedMessage
1925       implements RawMessageOrBuilder {
1926     // Use RawMessage.newBuilder() to construct.
1927     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1928       super(builder);
1929       this.unknownFields = builder.getUnknownFields();
1930     }
1931     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1932
1933     private static final RawMessage defaultInstance;
1934     public static RawMessage getDefaultInstance() {
1935       return defaultInstance;
1936     }
1937
1938     public RawMessage getDefaultInstanceForType() {
1939       return defaultInstance;
1940     }
1941
1942     private final com.google.protobuf.UnknownFieldSet unknownFields;
1943     @java.lang.Override
1944     public final com.google.protobuf.UnknownFieldSet
1945         getUnknownFields() {
1946       return this.unknownFields;
1947     }
1948     private RawMessage(
1949         com.google.protobuf.CodedInputStream input,
1950         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1951         throws com.google.protobuf.InvalidProtocolBufferException {
1952       initFields();
1953       int mutable_bitField0_ = 0;
1954       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1955           com.google.protobuf.UnknownFieldSet.newBuilder();
1956       try {
1957         boolean done = false;
1958         while (!done) {
1959           int tag = input.readTag();
1960           switch (tag) {
1961             case 0:
1962               done = true;
1963               break;
1964             default: {
1965               if (!parseUnknownField(input, unknownFields,
1966                                      extensionRegistry, tag)) {
1967                 done = true;
1968               }
1969               break;
1970             }
1971             case 8: {
1972               bitField0_ |= 0x00000001;
1973               bus_ = input.readInt32();
1974               break;
1975             }
1976             case 16: {
1977               bitField0_ |= 0x00000002;
1978               messageId_ = input.readUInt32();
1979               break;
1980             }
1981             case 24: {
1982               bitField0_ |= 0x00000004;
1983               data_ = input.readUInt64();
1984               break;
1985             }
1986           }
1987         }
1988       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1989         throw e.setUnfinishedMessage(this);
1990       } catch (java.io.IOException e) {
1991         throw new com.google.protobuf.InvalidProtocolBufferException(
1992             e.getMessage()).setUnfinishedMessage(this);
1993       } finally {
1994         this.unknownFields = unknownFields.build();
1995         makeExtensionsImmutable();
1996       }
1997     }
1998     public static final com.google.protobuf.Descriptors.Descriptor
1999         getDescriptor() {
2000       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
2001     }
2002
2003     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2004         internalGetFieldAccessorTable() {
2005       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
2006           .ensureFieldAccessorsInitialized(
2007               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
2008     }
2009
2010     public static com.google.protobuf.Parser<RawMessage> PARSER =
2011         new com.google.protobuf.AbstractParser<RawMessage>() {
2012       public RawMessage parsePartialFrom(
2013           com.google.protobuf.CodedInputStream input,
2014           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2015           throws com.google.protobuf.InvalidProtocolBufferException {
2016         return new RawMessage(input, extensionRegistry);
2017       }
2018     };
2019
2020     @java.lang.Override
2021     public com.google.protobuf.Parser<RawMessage> getParserForType() {
2022       return PARSER;
2023     }
2024
2025     private int bitField0_;
2026     // optional int32 bus = 1;
2027     public static final int BUS_FIELD_NUMBER = 1;
2028     private int bus_;
2029     /**
2030      * <code>optional int32 bus = 1;</code>
2031      */
2032     public boolean hasBus() {
2033       return ((bitField0_ & 0x00000001) == 0x00000001);
2034     }
2035     /**
2036      * <code>optional int32 bus = 1;</code>
2037      */
2038     public int getBus() {
2039       return bus_;
2040     }
2041
2042     // optional uint32 message_id = 2;
2043     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
2044     private int messageId_;
2045     /**
2046      * <code>optional uint32 message_id = 2;</code>
2047      */
2048     public boolean hasMessageId() {
2049       return ((bitField0_ & 0x00000002) == 0x00000002);
2050     }
2051     /**
2052      * <code>optional uint32 message_id = 2;</code>
2053      */
2054     public int getMessageId() {
2055       return messageId_;
2056     }
2057
2058     // optional uint64 data = 3;
2059     public static final int DATA_FIELD_NUMBER = 3;
2060     private long data_;
2061     /**
2062      * <code>optional uint64 data = 3;</code>
2063      */
2064     public boolean hasData() {
2065       return ((bitField0_ & 0x00000004) == 0x00000004);
2066     }
2067     /**
2068      * <code>optional uint64 data = 3;</code>
2069      */
2070     public long getData() {
2071       return data_;
2072     }
2073
2074     private void initFields() {
2075       bus_ = 0;
2076       messageId_ = 0;
2077       data_ = 0L;
2078     }
2079     private byte memoizedIsInitialized = -1;
2080     public final boolean isInitialized() {
2081       byte isInitialized = memoizedIsInitialized;
2082       if (isInitialized != -1) return isInitialized == 1;
2083
2084       memoizedIsInitialized = 1;
2085       return true;
2086     }
2087
2088     public void writeTo(com.google.protobuf.CodedOutputStream output)
2089                         throws java.io.IOException {
2090       getSerializedSize();
2091       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2092         output.writeInt32(1, bus_);
2093       }
2094       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2095         output.writeUInt32(2, messageId_);
2096       }
2097       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2098         output.writeUInt64(3, data_);
2099       }
2100       getUnknownFields().writeTo(output);
2101     }
2102
2103     private int memoizedSerializedSize = -1;
2104     public int getSerializedSize() {
2105       int size = memoizedSerializedSize;
2106       if (size != -1) return size;
2107
2108       size = 0;
2109       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2110         size += com.google.protobuf.CodedOutputStream
2111           .computeInt32Size(1, bus_);
2112       }
2113       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2114         size += com.google.protobuf.CodedOutputStream
2115           .computeUInt32Size(2, messageId_);
2116       }
2117       if (((bitField0_ & 0x00000004) == 0x00000004)) {
2118         size += com.google.protobuf.CodedOutputStream
2119           .computeUInt64Size(3, data_);
2120       }
2121       size += getUnknownFields().getSerializedSize();
2122       memoizedSerializedSize = size;
2123       return size;
2124     }
2125
2126     private static final long serialVersionUID = 0L;
2127     @java.lang.Override
2128     protected java.lang.Object writeReplace()
2129         throws java.io.ObjectStreamException {
2130       return super.writeReplace();
2131     }
2132
2133     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2134         com.google.protobuf.ByteString data)
2135         throws com.google.protobuf.InvalidProtocolBufferException {
2136       return PARSER.parseFrom(data);
2137     }
2138     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2139         com.google.protobuf.ByteString data,
2140         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2141         throws com.google.protobuf.InvalidProtocolBufferException {
2142       return PARSER.parseFrom(data, extensionRegistry);
2143     }
2144     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
2145         throws com.google.protobuf.InvalidProtocolBufferException {
2146       return PARSER.parseFrom(data);
2147     }
2148     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2149         byte[] data,
2150         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2151         throws com.google.protobuf.InvalidProtocolBufferException {
2152       return PARSER.parseFrom(data, extensionRegistry);
2153     }
2154     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
2155         throws java.io.IOException {
2156       return PARSER.parseFrom(input);
2157     }
2158     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2159         java.io.InputStream input,
2160         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2161         throws java.io.IOException {
2162       return PARSER.parseFrom(input, extensionRegistry);
2163     }
2164     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
2165         throws java.io.IOException {
2166       return PARSER.parseDelimitedFrom(input);
2167     }
2168     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
2169         java.io.InputStream input,
2170         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2171         throws java.io.IOException {
2172       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2173     }
2174     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2175         com.google.protobuf.CodedInputStream input)
2176         throws java.io.IOException {
2177       return PARSER.parseFrom(input);
2178     }
2179     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2180         com.google.protobuf.CodedInputStream input,
2181         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2182         throws java.io.IOException {
2183       return PARSER.parseFrom(input, extensionRegistry);
2184     }
2185
2186     public static Builder newBuilder() { return Builder.create(); }
2187     public Builder newBuilderForType() { return newBuilder(); }
2188     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
2189       return newBuilder().mergeFrom(prototype);
2190     }
2191     public Builder toBuilder() { return newBuilder(this); }
2192
2193     @java.lang.Override
2194     protected Builder newBuilderForType(
2195         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2196       Builder builder = new Builder(parent);
2197       return builder;
2198     }
2199     /**
2200      * Protobuf type {@code openxc.RawMessage}
2201      */
2202     public static final class Builder extends
2203         com.google.protobuf.GeneratedMessage.Builder<Builder>
2204        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
2205       public static final com.google.protobuf.Descriptors.Descriptor
2206           getDescriptor() {
2207         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
2208       }
2209
2210       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2211           internalGetFieldAccessorTable() {
2212         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
2213             .ensureFieldAccessorsInitialized(
2214                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
2215       }
2216
2217       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
2218       private Builder() {
2219         maybeForceBuilderInitialization();
2220       }
2221
2222       private Builder(
2223           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2224         super(parent);
2225         maybeForceBuilderInitialization();
2226       }
2227       private void maybeForceBuilderInitialization() {
2228         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2229         }
2230       }
2231       private static Builder create() {
2232         return new Builder();
2233       }
2234
2235       public Builder clear() {
2236         super.clear();
2237         bus_ = 0;
2238         bitField0_ = (bitField0_ & ~0x00000001);
2239         messageId_ = 0;
2240         bitField0_ = (bitField0_ & ~0x00000002);
2241         data_ = 0L;
2242         bitField0_ = (bitField0_ & ~0x00000004);
2243         return this;
2244       }
2245
2246       public Builder clone() {
2247         return create().mergeFrom(buildPartial());
2248       }
2249
2250       public com.google.protobuf.Descriptors.Descriptor
2251           getDescriptorForType() {
2252         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
2253       }
2254
2255       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
2256         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
2257       }
2258
2259       public com.openxc.BinaryMessages.RawMessage build() {
2260         com.openxc.BinaryMessages.RawMessage result = buildPartial();
2261         if (!result.isInitialized()) {
2262           throw newUninitializedMessageException(result);
2263         }
2264         return result;
2265       }
2266
2267       public com.openxc.BinaryMessages.RawMessage buildPartial() {
2268         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
2269         int from_bitField0_ = bitField0_;
2270         int to_bitField0_ = 0;
2271         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2272           to_bitField0_ |= 0x00000001;
2273         }
2274         result.bus_ = bus_;
2275         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2276           to_bitField0_ |= 0x00000002;
2277         }
2278         result.messageId_ = messageId_;
2279         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2280           to_bitField0_ |= 0x00000004;
2281         }
2282         result.data_ = data_;
2283         result.bitField0_ = to_bitField0_;
2284         onBuilt();
2285         return result;
2286       }
2287
2288       public Builder mergeFrom(com.google.protobuf.Message other) {
2289         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
2290           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
2291         } else {
2292           super.mergeFrom(other);
2293           return this;
2294         }
2295       }
2296
2297       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
2298         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
2299         if (other.hasBus()) {
2300           setBus(other.getBus());
2301         }
2302         if (other.hasMessageId()) {
2303           setMessageId(other.getMessageId());
2304         }
2305         if (other.hasData()) {
2306           setData(other.getData());
2307         }
2308         this.mergeUnknownFields(other.getUnknownFields());
2309         return this;
2310       }
2311
2312       public final boolean isInitialized() {
2313         return true;
2314       }
2315
2316       public Builder mergeFrom(
2317           com.google.protobuf.CodedInputStream input,
2318           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2319           throws java.io.IOException {
2320         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
2321         try {
2322           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2323         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2324           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
2325           throw e;
2326         } finally {
2327           if (parsedMessage != null) {
2328             mergeFrom(parsedMessage);
2329           }
2330         }
2331         return this;
2332       }
2333       private int bitField0_;
2334
2335       // optional int32 bus = 1;
2336       private int bus_ ;
2337       /**
2338        * <code>optional int32 bus = 1;</code>
2339        */
2340       public boolean hasBus() {
2341         return ((bitField0_ & 0x00000001) == 0x00000001);
2342       }
2343       /**
2344        * <code>optional int32 bus = 1;</code>
2345        */
2346       public int getBus() {
2347         return bus_;
2348       }
2349       /**
2350        * <code>optional int32 bus = 1;</code>
2351        */
2352       public Builder setBus(int value) {
2353         bitField0_ |= 0x00000001;
2354         bus_ = value;
2355         onChanged();
2356         return this;
2357       }
2358       /**
2359        * <code>optional int32 bus = 1;</code>
2360        */
2361       public Builder clearBus() {
2362         bitField0_ = (bitField0_ & ~0x00000001);
2363         bus_ = 0;
2364         onChanged();
2365         return this;
2366       }
2367
2368       // optional uint32 message_id = 2;
2369       private int messageId_ ;
2370       /**
2371        * <code>optional uint32 message_id = 2;</code>
2372        */
2373       public boolean hasMessageId() {
2374         return ((bitField0_ & 0x00000002) == 0x00000002);
2375       }
2376       /**
2377        * <code>optional uint32 message_id = 2;</code>
2378        */
2379       public int getMessageId() {
2380         return messageId_;
2381       }
2382       /**
2383        * <code>optional uint32 message_id = 2;</code>
2384        */
2385       public Builder setMessageId(int value) {
2386         bitField0_ |= 0x00000002;
2387         messageId_ = value;
2388         onChanged();
2389         return this;
2390       }
2391       /**
2392        * <code>optional uint32 message_id = 2;</code>
2393        */
2394       public Builder clearMessageId() {
2395         bitField0_ = (bitField0_ & ~0x00000002);
2396         messageId_ = 0;
2397         onChanged();
2398         return this;
2399       }
2400
2401       // optional uint64 data = 3;
2402       private long data_ ;
2403       /**
2404        * <code>optional uint64 data = 3;</code>
2405        */
2406       public boolean hasData() {
2407         return ((bitField0_ & 0x00000004) == 0x00000004);
2408       }
2409       /**
2410        * <code>optional uint64 data = 3;</code>
2411        */
2412       public long getData() {
2413         return data_;
2414       }
2415       /**
2416        * <code>optional uint64 data = 3;</code>
2417        */
2418       public Builder setData(long value) {
2419         bitField0_ |= 0x00000004;
2420         data_ = value;
2421         onChanged();
2422         return this;
2423       }
2424       /**
2425        * <code>optional uint64 data = 3;</code>
2426        */
2427       public Builder clearData() {
2428         bitField0_ = (bitField0_ & ~0x00000004);
2429         data_ = 0L;
2430         onChanged();
2431         return this;
2432       }
2433
2434       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
2435     }
2436
2437     static {
2438       defaultInstance = new RawMessage(true);
2439       defaultInstance.initFields();
2440     }
2441
2442     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
2443   }
2444
2445   public interface StringMessageOrBuilder
2446       extends com.google.protobuf.MessageOrBuilder {
2447
2448     // optional string name = 1;
2449     /**
2450      * <code>optional string name = 1;</code>
2451      */
2452     boolean hasName();
2453     /**
2454      * <code>optional string name = 1;</code>
2455      */
2456     java.lang.String getName();
2457     /**
2458      * <code>optional string name = 1;</code>
2459      */
2460     com.google.protobuf.ByteString
2461         getNameBytes();
2462
2463     // optional string value = 2;
2464     /**
2465      * <code>optional string value = 2;</code>
2466      */
2467     boolean hasValue();
2468     /**
2469      * <code>optional string value = 2;</code>
2470      */
2471     java.lang.String getValue();
2472     /**
2473      * <code>optional string value = 2;</code>
2474      */
2475     com.google.protobuf.ByteString
2476         getValueBytes();
2477   }
2478   /**
2479    * Protobuf type {@code openxc.StringMessage}
2480    */
2481   public static final class StringMessage extends
2482       com.google.protobuf.GeneratedMessage
2483       implements StringMessageOrBuilder {
2484     // Use StringMessage.newBuilder() to construct.
2485     private StringMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2486       super(builder);
2487       this.unknownFields = builder.getUnknownFields();
2488     }
2489     private StringMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2490
2491     private static final StringMessage defaultInstance;
2492     public static StringMessage getDefaultInstance() {
2493       return defaultInstance;
2494     }
2495
2496     public StringMessage getDefaultInstanceForType() {
2497       return defaultInstance;
2498     }
2499
2500     private final com.google.protobuf.UnknownFieldSet unknownFields;
2501     @java.lang.Override
2502     public final com.google.protobuf.UnknownFieldSet
2503         getUnknownFields() {
2504       return this.unknownFields;
2505     }
2506     private StringMessage(
2507         com.google.protobuf.CodedInputStream input,
2508         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2509         throws com.google.protobuf.InvalidProtocolBufferException {
2510       initFields();
2511       int mutable_bitField0_ = 0;
2512       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2513           com.google.protobuf.UnknownFieldSet.newBuilder();
2514       try {
2515         boolean done = false;
2516         while (!done) {
2517           int tag = input.readTag();
2518           switch (tag) {
2519             case 0:
2520               done = true;
2521               break;
2522             default: {
2523               if (!parseUnknownField(input, unknownFields,
2524                                      extensionRegistry, tag)) {
2525                 done = true;
2526               }
2527               break;
2528             }
2529             case 10: {
2530               bitField0_ |= 0x00000001;
2531               name_ = input.readBytes();
2532               break;
2533             }
2534             case 18: {
2535               bitField0_ |= 0x00000002;
2536               value_ = input.readBytes();
2537               break;
2538             }
2539           }
2540         }
2541       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2542         throw e.setUnfinishedMessage(this);
2543       } catch (java.io.IOException e) {
2544         throw new com.google.protobuf.InvalidProtocolBufferException(
2545             e.getMessage()).setUnfinishedMessage(this);
2546       } finally {
2547         this.unknownFields = unknownFields.build();
2548         makeExtensionsImmutable();
2549       }
2550     }
2551     public static final com.google.protobuf.Descriptors.Descriptor
2552         getDescriptor() {
2553       return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_descriptor;
2554     }
2555
2556     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2557         internalGetFieldAccessorTable() {
2558       return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_fieldAccessorTable
2559           .ensureFieldAccessorsInitialized(
2560               com.openxc.BinaryMessages.StringMessage.class, com.openxc.BinaryMessages.StringMessage.Builder.class);
2561     }
2562
2563     public static com.google.protobuf.Parser<StringMessage> PARSER =
2564         new com.google.protobuf.AbstractParser<StringMessage>() {
2565       public StringMessage parsePartialFrom(
2566           com.google.protobuf.CodedInputStream input,
2567           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2568           throws com.google.protobuf.InvalidProtocolBufferException {
2569         return new StringMessage(input, extensionRegistry);
2570       }
2571     };
2572
2573     @java.lang.Override
2574     public com.google.protobuf.Parser<StringMessage> getParserForType() {
2575       return PARSER;
2576     }
2577
2578     private int bitField0_;
2579     // optional string name = 1;
2580     public static final int NAME_FIELD_NUMBER = 1;
2581     private java.lang.Object name_;
2582     /**
2583      * <code>optional string name = 1;</code>
2584      */
2585     public boolean hasName() {
2586       return ((bitField0_ & 0x00000001) == 0x00000001);
2587     }
2588     /**
2589      * <code>optional string name = 1;</code>
2590      */
2591     public java.lang.String getName() {
2592       java.lang.Object ref = name_;
2593       if (ref instanceof java.lang.String) {
2594         return (java.lang.String) ref;
2595       } else {
2596         com.google.protobuf.ByteString bs =
2597             (com.google.protobuf.ByteString) ref;
2598         java.lang.String s = bs.toStringUtf8();
2599         if (bs.isValidUtf8()) {
2600           name_ = s;
2601         }
2602         return s;
2603       }
2604     }
2605     /**
2606      * <code>optional string name = 1;</code>
2607      */
2608     public com.google.protobuf.ByteString
2609         getNameBytes() {
2610       java.lang.Object ref = name_;
2611       if (ref instanceof java.lang.String) {
2612         com.google.protobuf.ByteString b =
2613             com.google.protobuf.ByteString.copyFromUtf8(
2614                 (java.lang.String) ref);
2615         name_ = b;
2616         return b;
2617       } else {
2618         return (com.google.protobuf.ByteString) ref;
2619       }
2620     }
2621
2622     // optional string value = 2;
2623     public static final int VALUE_FIELD_NUMBER = 2;
2624     private java.lang.Object value_;
2625     /**
2626      * <code>optional string value = 2;</code>
2627      */
2628     public boolean hasValue() {
2629       return ((bitField0_ & 0x00000002) == 0x00000002);
2630     }
2631     /**
2632      * <code>optional string value = 2;</code>
2633      */
2634     public java.lang.String getValue() {
2635       java.lang.Object ref = value_;
2636       if (ref instanceof java.lang.String) {
2637         return (java.lang.String) ref;
2638       } else {
2639         com.google.protobuf.ByteString bs =
2640             (com.google.protobuf.ByteString) ref;
2641         java.lang.String s = bs.toStringUtf8();
2642         if (bs.isValidUtf8()) {
2643           value_ = s;
2644         }
2645         return s;
2646       }
2647     }
2648     /**
2649      * <code>optional string value = 2;</code>
2650      */
2651     public com.google.protobuf.ByteString
2652         getValueBytes() {
2653       java.lang.Object ref = value_;
2654       if (ref instanceof java.lang.String) {
2655         com.google.protobuf.ByteString b =
2656             com.google.protobuf.ByteString.copyFromUtf8(
2657                 (java.lang.String) ref);
2658         value_ = b;
2659         return b;
2660       } else {
2661         return (com.google.protobuf.ByteString) ref;
2662       }
2663     }
2664
2665     private void initFields() {
2666       name_ = "";
2667       value_ = "";
2668     }
2669     private byte memoizedIsInitialized = -1;
2670     public final boolean isInitialized() {
2671       byte isInitialized = memoizedIsInitialized;
2672       if (isInitialized != -1) return isInitialized == 1;
2673
2674       memoizedIsInitialized = 1;
2675       return true;
2676     }
2677
2678     public void writeTo(com.google.protobuf.CodedOutputStream output)
2679                         throws java.io.IOException {
2680       getSerializedSize();
2681       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2682         output.writeBytes(1, getNameBytes());
2683       }
2684       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2685         output.writeBytes(2, getValueBytes());
2686       }
2687       getUnknownFields().writeTo(output);
2688     }
2689
2690     private int memoizedSerializedSize = -1;
2691     public int getSerializedSize() {
2692       int size = memoizedSerializedSize;
2693       if (size != -1) return size;
2694
2695       size = 0;
2696       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2697         size += com.google.protobuf.CodedOutputStream
2698           .computeBytesSize(1, getNameBytes());
2699       }
2700       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2701         size += com.google.protobuf.CodedOutputStream
2702           .computeBytesSize(2, getValueBytes());
2703       }
2704       size += getUnknownFields().getSerializedSize();
2705       memoizedSerializedSize = size;
2706       return size;
2707     }
2708
2709     private static final long serialVersionUID = 0L;
2710     @java.lang.Override
2711     protected java.lang.Object writeReplace()
2712         throws java.io.ObjectStreamException {
2713       return super.writeReplace();
2714     }
2715
2716     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2717         com.google.protobuf.ByteString data)
2718         throws com.google.protobuf.InvalidProtocolBufferException {
2719       return PARSER.parseFrom(data);
2720     }
2721     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2722         com.google.protobuf.ByteString data,
2723         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2724         throws com.google.protobuf.InvalidProtocolBufferException {
2725       return PARSER.parseFrom(data, extensionRegistry);
2726     }
2727     public static com.openxc.BinaryMessages.StringMessage parseFrom(byte[] data)
2728         throws com.google.protobuf.InvalidProtocolBufferException {
2729       return PARSER.parseFrom(data);
2730     }
2731     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2732         byte[] data,
2733         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2734         throws com.google.protobuf.InvalidProtocolBufferException {
2735       return PARSER.parseFrom(data, extensionRegistry);
2736     }
2737     public static com.openxc.BinaryMessages.StringMessage parseFrom(java.io.InputStream input)
2738         throws java.io.IOException {
2739       return PARSER.parseFrom(input);
2740     }
2741     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2742         java.io.InputStream input,
2743         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2744         throws java.io.IOException {
2745       return PARSER.parseFrom(input, extensionRegistry);
2746     }
2747     public static com.openxc.BinaryMessages.StringMessage parseDelimitedFrom(java.io.InputStream input)
2748         throws java.io.IOException {
2749       return PARSER.parseDelimitedFrom(input);
2750     }
2751     public static com.openxc.BinaryMessages.StringMessage parseDelimitedFrom(
2752         java.io.InputStream input,
2753         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2754         throws java.io.IOException {
2755       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2756     }
2757     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2758         com.google.protobuf.CodedInputStream input)
2759         throws java.io.IOException {
2760       return PARSER.parseFrom(input);
2761     }
2762     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2763         com.google.protobuf.CodedInputStream input,
2764         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2765         throws java.io.IOException {
2766       return PARSER.parseFrom(input, extensionRegistry);
2767     }
2768
2769     public static Builder newBuilder() { return Builder.create(); }
2770     public Builder newBuilderForType() { return newBuilder(); }
2771     public static Builder newBuilder(com.openxc.BinaryMessages.StringMessage prototype) {
2772       return newBuilder().mergeFrom(prototype);
2773     }
2774     public Builder toBuilder() { return newBuilder(this); }
2775
2776     @java.lang.Override
2777     protected Builder newBuilderForType(
2778         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2779       Builder builder = new Builder(parent);
2780       return builder;
2781     }
2782     /**
2783      * Protobuf type {@code openxc.StringMessage}
2784      */
2785     public static final class Builder extends
2786         com.google.protobuf.GeneratedMessage.Builder<Builder>
2787        implements com.openxc.BinaryMessages.StringMessageOrBuilder {
2788       public static final com.google.protobuf.Descriptors.Descriptor
2789           getDescriptor() {
2790         return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_descriptor;
2791       }
2792
2793       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2794           internalGetFieldAccessorTable() {
2795         return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_fieldAccessorTable
2796             .ensureFieldAccessorsInitialized(
2797                 com.openxc.BinaryMessages.StringMessage.class, com.openxc.BinaryMessages.StringMessage.Builder.class);
2798       }
2799
2800       // Construct using com.openxc.BinaryMessages.StringMessage.newBuilder()
2801       private Builder() {
2802         maybeForceBuilderInitialization();
2803       }
2804
2805       private Builder(
2806           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2807         super(parent);
2808         maybeForceBuilderInitialization();
2809       }
2810       private void maybeForceBuilderInitialization() {
2811         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2812         }
2813       }
2814       private static Builder create() {
2815         return new Builder();
2816       }
2817
2818       public Builder clear() {
2819         super.clear();
2820         name_ = "";
2821         bitField0_ = (bitField0_ & ~0x00000001);
2822         value_ = "";
2823         bitField0_ = (bitField0_ & ~0x00000002);
2824         return this;
2825       }
2826
2827       public Builder clone() {
2828         return create().mergeFrom(buildPartial());
2829       }
2830
2831       public com.google.protobuf.Descriptors.Descriptor
2832           getDescriptorForType() {
2833         return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_descriptor;
2834       }
2835
2836       public com.openxc.BinaryMessages.StringMessage getDefaultInstanceForType() {
2837         return com.openxc.BinaryMessages.StringMessage.getDefaultInstance();
2838       }
2839
2840       public com.openxc.BinaryMessages.StringMessage build() {
2841         com.openxc.BinaryMessages.StringMessage result = buildPartial();
2842         if (!result.isInitialized()) {
2843           throw newUninitializedMessageException(result);
2844         }
2845         return result;
2846       }
2847
2848       public com.openxc.BinaryMessages.StringMessage buildPartial() {
2849         com.openxc.BinaryMessages.StringMessage result = new com.openxc.BinaryMessages.StringMessage(this);
2850         int from_bitField0_ = bitField0_;
2851         int to_bitField0_ = 0;
2852         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2853           to_bitField0_ |= 0x00000001;
2854         }
2855         result.name_ = name_;
2856         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2857           to_bitField0_ |= 0x00000002;
2858         }
2859         result.value_ = value_;
2860         result.bitField0_ = to_bitField0_;
2861         onBuilt();
2862         return result;
2863       }
2864
2865       public Builder mergeFrom(com.google.protobuf.Message other) {
2866         if (other instanceof com.openxc.BinaryMessages.StringMessage) {
2867           return mergeFrom((com.openxc.BinaryMessages.StringMessage)other);
2868         } else {
2869           super.mergeFrom(other);
2870           return this;
2871         }
2872       }
2873
2874       public Builder mergeFrom(com.openxc.BinaryMessages.StringMessage other) {
2875         if (other == com.openxc.BinaryMessages.StringMessage.getDefaultInstance()) return this;
2876         if (other.hasName()) {
2877           bitField0_ |= 0x00000001;
2878           name_ = other.name_;
2879           onChanged();
2880         }
2881         if (other.hasValue()) {
2882           bitField0_ |= 0x00000002;
2883           value_ = other.value_;
2884           onChanged();
2885         }
2886         this.mergeUnknownFields(other.getUnknownFields());
2887         return this;
2888       }
2889
2890       public final boolean isInitialized() {
2891         return true;
2892       }
2893
2894       public Builder mergeFrom(
2895           com.google.protobuf.CodedInputStream input,
2896           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2897           throws java.io.IOException {
2898         com.openxc.BinaryMessages.StringMessage parsedMessage = null;
2899         try {
2900           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2901         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2902           parsedMessage = (com.openxc.BinaryMessages.StringMessage) e.getUnfinishedMessage();
2903           throw e;
2904         } finally {
2905           if (parsedMessage != null) {
2906             mergeFrom(parsedMessage);
2907           }
2908         }
2909         return this;
2910       }
2911       private int bitField0_;
2912
2913       // optional string name = 1;
2914       private java.lang.Object name_ = "";
2915       /**
2916        * <code>optional string name = 1;</code>
2917        */
2918       public boolean hasName() {
2919         return ((bitField0_ & 0x00000001) == 0x00000001);
2920       }
2921       /**
2922        * <code>optional string name = 1;</code>
2923        */
2924       public java.lang.String getName() {
2925         java.lang.Object ref = name_;
2926         if (!(ref instanceof java.lang.String)) {
2927           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2928               .toStringUtf8();
2929           name_ = s;
2930           return s;
2931         } else {
2932           return (java.lang.String) ref;
2933         }
2934       }
2935       /**
2936        * <code>optional string name = 1;</code>
2937        */
2938       public com.google.protobuf.ByteString
2939           getNameBytes() {
2940         java.lang.Object ref = name_;
2941         if (ref instanceof String) {
2942           com.google.protobuf.ByteString b =
2943               com.google.protobuf.ByteString.copyFromUtf8(
2944                   (java.lang.String) ref);
2945           name_ = b;
2946           return b;
2947         } else {
2948           return (com.google.protobuf.ByteString) ref;
2949         }
2950       }
2951       /**
2952        * <code>optional string name = 1;</code>
2953        */
2954       public Builder setName(
2955           java.lang.String value) {
2956         if (value == null) {
2957     throw new NullPointerException();
2958   }
2959   bitField0_ |= 0x00000001;
2960         name_ = value;
2961         onChanged();
2962         return this;
2963       }
2964       /**
2965        * <code>optional string name = 1;</code>
2966        */
2967       public Builder clearName() {
2968         bitField0_ = (bitField0_ & ~0x00000001);
2969         name_ = getDefaultInstance().getName();
2970         onChanged();
2971         return this;
2972       }
2973       /**
2974        * <code>optional string name = 1;</code>
2975        */
2976       public Builder setNameBytes(
2977           com.google.protobuf.ByteString value) {
2978         if (value == null) {
2979     throw new NullPointerException();
2980   }
2981   bitField0_ |= 0x00000001;
2982         name_ = value;
2983         onChanged();
2984         return this;
2985       }
2986
2987       // optional string value = 2;
2988       private java.lang.Object value_ = "";
2989       /**
2990        * <code>optional string value = 2;</code>
2991        */
2992       public boolean hasValue() {
2993         return ((bitField0_ & 0x00000002) == 0x00000002);
2994       }
2995       /**
2996        * <code>optional string value = 2;</code>
2997        */
2998       public java.lang.String getValue() {
2999         java.lang.Object ref = value_;
3000         if (!(ref instanceof java.lang.String)) {
3001           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3002               .toStringUtf8();
3003           value_ = s;
3004           return s;
3005         } else {
3006           return (java.lang.String) ref;
3007         }
3008       }
3009       /**
3010        * <code>optional string value = 2;</code>
3011        */
3012       public com.google.protobuf.ByteString
3013           getValueBytes() {
3014         java.lang.Object ref = value_;
3015         if (ref instanceof String) {
3016           com.google.protobuf.ByteString b =
3017               com.google.protobuf.ByteString.copyFromUtf8(
3018                   (java.lang.String) ref);
3019           value_ = b;
3020           return b;
3021         } else {
3022           return (com.google.protobuf.ByteString) ref;
3023         }
3024       }
3025       /**
3026        * <code>optional string value = 2;</code>
3027        */
3028       public Builder setValue(
3029           java.lang.String value) {
3030         if (value == null) {
3031     throw new NullPointerException();
3032   }
3033   bitField0_ |= 0x00000002;
3034         value_ = value;
3035         onChanged();
3036         return this;
3037       }
3038       /**
3039        * <code>optional string value = 2;</code>
3040        */
3041       public Builder clearValue() {
3042         bitField0_ = (bitField0_ & ~0x00000002);
3043         value_ = getDefaultInstance().getValue();
3044         onChanged();
3045         return this;
3046       }
3047       /**
3048        * <code>optional string value = 2;</code>
3049        */
3050       public Builder setValueBytes(
3051           com.google.protobuf.ByteString value) {
3052         if (value == null) {
3053     throw new NullPointerException();
3054   }
3055   bitField0_ |= 0x00000002;
3056         value_ = value;
3057         onChanged();
3058         return this;
3059       }
3060
3061       // @@protoc_insertion_point(builder_scope:openxc.StringMessage)
3062     }
3063
3064     static {
3065       defaultInstance = new StringMessage(true);
3066       defaultInstance.initFields();
3067     }
3068
3069     // @@protoc_insertion_point(class_scope:openxc.StringMessage)
3070   }
3071
3072   public interface NumericMessageOrBuilder
3073       extends com.google.protobuf.MessageOrBuilder {
3074
3075     // optional string name = 1;
3076     /**
3077      * <code>optional string name = 1;</code>
3078      */
3079     boolean hasName();
3080     /**
3081      * <code>optional string name = 1;</code>
3082      */
3083     java.lang.String getName();
3084     /**
3085      * <code>optional string name = 1;</code>
3086      */
3087     com.google.protobuf.ByteString
3088         getNameBytes();
3089
3090     // optional double value = 2;
3091     /**
3092      * <code>optional double value = 2;</code>
3093      */
3094     boolean hasValue();
3095     /**
3096      * <code>optional double value = 2;</code>
3097      */
3098     double getValue();
3099   }
3100   /**
3101    * Protobuf type {@code openxc.NumericMessage}
3102    */
3103   public static final class NumericMessage extends
3104       com.google.protobuf.GeneratedMessage
3105       implements NumericMessageOrBuilder {
3106     // Use NumericMessage.newBuilder() to construct.
3107     private NumericMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3108       super(builder);
3109       this.unknownFields = builder.getUnknownFields();
3110     }
3111     private NumericMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3112
3113     private static final NumericMessage defaultInstance;
3114     public static NumericMessage getDefaultInstance() {
3115       return defaultInstance;
3116     }
3117
3118     public NumericMessage getDefaultInstanceForType() {
3119       return defaultInstance;
3120     }
3121
3122     private final com.google.protobuf.UnknownFieldSet unknownFields;
3123     @java.lang.Override
3124     public final com.google.protobuf.UnknownFieldSet
3125         getUnknownFields() {
3126       return this.unknownFields;
3127     }
3128     private NumericMessage(
3129         com.google.protobuf.CodedInputStream input,
3130         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3131         throws com.google.protobuf.InvalidProtocolBufferException {
3132       initFields();
3133       int mutable_bitField0_ = 0;
3134       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3135           com.google.protobuf.UnknownFieldSet.newBuilder();
3136       try {
3137         boolean done = false;
3138         while (!done) {
3139           int tag = input.readTag();
3140           switch (tag) {
3141             case 0:
3142               done = true;
3143               break;
3144             default: {
3145               if (!parseUnknownField(input, unknownFields,
3146                                      extensionRegistry, tag)) {
3147                 done = true;
3148               }
3149               break;
3150             }
3151             case 10: {
3152               bitField0_ |= 0x00000001;
3153               name_ = input.readBytes();
3154               break;
3155             }
3156             case 17: {
3157               bitField0_ |= 0x00000002;
3158               value_ = input.readDouble();
3159               break;
3160             }
3161           }
3162         }
3163       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3164         throw e.setUnfinishedMessage(this);
3165       } catch (java.io.IOException e) {
3166         throw new com.google.protobuf.InvalidProtocolBufferException(
3167             e.getMessage()).setUnfinishedMessage(this);
3168       } finally {
3169         this.unknownFields = unknownFields.build();
3170         makeExtensionsImmutable();
3171       }
3172     }
3173     public static final com.google.protobuf.Descriptors.Descriptor
3174         getDescriptor() {
3175       return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_descriptor;
3176     }
3177
3178     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3179         internalGetFieldAccessorTable() {
3180       return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_fieldAccessorTable
3181           .ensureFieldAccessorsInitialized(
3182               com.openxc.BinaryMessages.NumericMessage.class, com.openxc.BinaryMessages.NumericMessage.Builder.class);
3183     }
3184
3185     public static com.google.protobuf.Parser<NumericMessage> PARSER =
3186         new com.google.protobuf.AbstractParser<NumericMessage>() {
3187       public NumericMessage parsePartialFrom(
3188           com.google.protobuf.CodedInputStream input,
3189           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3190           throws com.google.protobuf.InvalidProtocolBufferException {
3191         return new NumericMessage(input, extensionRegistry);
3192       }
3193     };
3194
3195     @java.lang.Override
3196     public com.google.protobuf.Parser<NumericMessage> getParserForType() {
3197       return PARSER;
3198     }
3199
3200     private int bitField0_;
3201     // optional string name = 1;
3202     public static final int NAME_FIELD_NUMBER = 1;
3203     private java.lang.Object name_;
3204     /**
3205      * <code>optional string name = 1;</code>
3206      */
3207     public boolean hasName() {
3208       return ((bitField0_ & 0x00000001) == 0x00000001);
3209     }
3210     /**
3211      * <code>optional string name = 1;</code>
3212      */
3213     public java.lang.String getName() {
3214       java.lang.Object ref = name_;
3215       if (ref instanceof java.lang.String) {
3216         return (java.lang.String) ref;
3217       } else {
3218         com.google.protobuf.ByteString bs =
3219             (com.google.protobuf.ByteString) ref;
3220         java.lang.String s = bs.toStringUtf8();
3221         if (bs.isValidUtf8()) {
3222           name_ = s;
3223         }
3224         return s;
3225       }
3226     }
3227     /**
3228      * <code>optional string name = 1;</code>
3229      */
3230     public com.google.protobuf.ByteString
3231         getNameBytes() {
3232       java.lang.Object ref = name_;
3233       if (ref instanceof java.lang.String) {
3234         com.google.protobuf.ByteString b =
3235             com.google.protobuf.ByteString.copyFromUtf8(
3236                 (java.lang.String) ref);
3237         name_ = b;
3238         return b;
3239       } else {
3240         return (com.google.protobuf.ByteString) ref;
3241       }
3242     }
3243
3244     // optional double value = 2;
3245     public static final int VALUE_FIELD_NUMBER = 2;
3246     private double value_;
3247     /**
3248      * <code>optional double value = 2;</code>
3249      */
3250     public boolean hasValue() {
3251       return ((bitField0_ & 0x00000002) == 0x00000002);
3252     }
3253     /**
3254      * <code>optional double value = 2;</code>
3255      */
3256     public double getValue() {
3257       return value_;
3258     }
3259
3260     private void initFields() {
3261       name_ = "";
3262       value_ = 0D;
3263     }
3264     private byte memoizedIsInitialized = -1;
3265     public final boolean isInitialized() {
3266       byte isInitialized = memoizedIsInitialized;
3267       if (isInitialized != -1) return isInitialized == 1;
3268
3269       memoizedIsInitialized = 1;
3270       return true;
3271     }
3272
3273     public void writeTo(com.google.protobuf.CodedOutputStream output)
3274                         throws java.io.IOException {
3275       getSerializedSize();
3276       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3277         output.writeBytes(1, getNameBytes());
3278       }
3279       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3280         output.writeDouble(2, value_);
3281       }
3282       getUnknownFields().writeTo(output);
3283     }
3284
3285     private int memoizedSerializedSize = -1;
3286     public int getSerializedSize() {
3287       int size = memoizedSerializedSize;
3288       if (size != -1) return size;
3289
3290       size = 0;
3291       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3292         size += com.google.protobuf.CodedOutputStream
3293           .computeBytesSize(1, getNameBytes());
3294       }
3295       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3296         size += com.google.protobuf.CodedOutputStream
3297           .computeDoubleSize(2, value_);
3298       }
3299       size += getUnknownFields().getSerializedSize();
3300       memoizedSerializedSize = size;
3301       return size;
3302     }
3303
3304     private static final long serialVersionUID = 0L;
3305     @java.lang.Override
3306     protected java.lang.Object writeReplace()
3307         throws java.io.ObjectStreamException {
3308       return super.writeReplace();
3309     }
3310
3311     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3312         com.google.protobuf.ByteString data)
3313         throws com.google.protobuf.InvalidProtocolBufferException {
3314       return PARSER.parseFrom(data);
3315     }
3316     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3317         com.google.protobuf.ByteString data,
3318         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3319         throws com.google.protobuf.InvalidProtocolBufferException {
3320       return PARSER.parseFrom(data, extensionRegistry);
3321     }
3322     public static com.openxc.BinaryMessages.NumericMessage parseFrom(byte[] data)
3323         throws com.google.protobuf.InvalidProtocolBufferException {
3324       return PARSER.parseFrom(data);
3325     }
3326     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3327         byte[] data,
3328         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3329         throws com.google.protobuf.InvalidProtocolBufferException {
3330       return PARSER.parseFrom(data, extensionRegistry);
3331     }
3332     public static com.openxc.BinaryMessages.NumericMessage parseFrom(java.io.InputStream input)
3333         throws java.io.IOException {
3334       return PARSER.parseFrom(input);
3335     }
3336     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3337         java.io.InputStream input,
3338         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3339         throws java.io.IOException {
3340       return PARSER.parseFrom(input, extensionRegistry);
3341     }
3342     public static com.openxc.BinaryMessages.NumericMessage parseDelimitedFrom(java.io.InputStream input)
3343         throws java.io.IOException {
3344       return PARSER.parseDelimitedFrom(input);
3345     }
3346     public static com.openxc.BinaryMessages.NumericMessage parseDelimitedFrom(
3347         java.io.InputStream input,
3348         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3349         throws java.io.IOException {
3350       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3351     }
3352     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3353         com.google.protobuf.CodedInputStream input)
3354         throws java.io.IOException {
3355       return PARSER.parseFrom(input);
3356     }
3357     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3358         com.google.protobuf.CodedInputStream input,
3359         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3360         throws java.io.IOException {
3361       return PARSER.parseFrom(input, extensionRegistry);
3362     }
3363
3364     public static Builder newBuilder() { return Builder.create(); }
3365     public Builder newBuilderForType() { return newBuilder(); }
3366     public static Builder newBuilder(com.openxc.BinaryMessages.NumericMessage prototype) {
3367       return newBuilder().mergeFrom(prototype);
3368     }
3369     public Builder toBuilder() { return newBuilder(this); }
3370
3371     @java.lang.Override
3372     protected Builder newBuilderForType(
3373         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3374       Builder builder = new Builder(parent);
3375       return builder;
3376     }
3377     /**
3378      * Protobuf type {@code openxc.NumericMessage}
3379      */
3380     public static final class Builder extends
3381         com.google.protobuf.GeneratedMessage.Builder<Builder>
3382        implements com.openxc.BinaryMessages.NumericMessageOrBuilder {
3383       public static final com.google.protobuf.Descriptors.Descriptor
3384           getDescriptor() {
3385         return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_descriptor;
3386       }
3387
3388       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3389           internalGetFieldAccessorTable() {
3390         return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_fieldAccessorTable
3391             .ensureFieldAccessorsInitialized(
3392                 com.openxc.BinaryMessages.NumericMessage.class, com.openxc.BinaryMessages.NumericMessage.Builder.class);
3393       }
3394
3395       // Construct using com.openxc.BinaryMessages.NumericMessage.newBuilder()
3396       private Builder() {
3397         maybeForceBuilderInitialization();
3398       }
3399
3400       private Builder(
3401           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3402         super(parent);
3403         maybeForceBuilderInitialization();
3404       }
3405       private void maybeForceBuilderInitialization() {
3406         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3407         }
3408       }
3409       private static Builder create() {
3410         return new Builder();
3411       }
3412
3413       public Builder clear() {
3414         super.clear();
3415         name_ = "";
3416         bitField0_ = (bitField0_ & ~0x00000001);
3417         value_ = 0D;
3418         bitField0_ = (bitField0_ & ~0x00000002);
3419         return this;
3420       }
3421
3422       public Builder clone() {
3423         return create().mergeFrom(buildPartial());
3424       }
3425
3426       public com.google.protobuf.Descriptors.Descriptor
3427           getDescriptorForType() {
3428         return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_descriptor;
3429       }
3430
3431       public com.openxc.BinaryMessages.NumericMessage getDefaultInstanceForType() {
3432         return com.openxc.BinaryMessages.NumericMessage.getDefaultInstance();
3433       }
3434
3435       public com.openxc.BinaryMessages.NumericMessage build() {
3436         com.openxc.BinaryMessages.NumericMessage result = buildPartial();
3437         if (!result.isInitialized()) {
3438           throw newUninitializedMessageException(result);
3439         }
3440         return result;
3441       }
3442
3443       public com.openxc.BinaryMessages.NumericMessage buildPartial() {
3444         com.openxc.BinaryMessages.NumericMessage result = new com.openxc.BinaryMessages.NumericMessage(this);
3445         int from_bitField0_ = bitField0_;
3446         int to_bitField0_ = 0;
3447         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3448           to_bitField0_ |= 0x00000001;
3449         }
3450         result.name_ = name_;
3451         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3452           to_bitField0_ |= 0x00000002;
3453         }
3454         result.value_ = value_;
3455         result.bitField0_ = to_bitField0_;
3456         onBuilt();
3457         return result;
3458       }
3459
3460       public Builder mergeFrom(com.google.protobuf.Message other) {
3461         if (other instanceof com.openxc.BinaryMessages.NumericMessage) {
3462           return mergeFrom((com.openxc.BinaryMessages.NumericMessage)other);
3463         } else {
3464           super.mergeFrom(other);
3465           return this;
3466         }
3467       }
3468
3469       public Builder mergeFrom(com.openxc.BinaryMessages.NumericMessage other) {
3470         if (other == com.openxc.BinaryMessages.NumericMessage.getDefaultInstance()) return this;
3471         if (other.hasName()) {
3472           bitField0_ |= 0x00000001;
3473           name_ = other.name_;
3474           onChanged();
3475         }
3476         if (other.hasValue()) {
3477           setValue(other.getValue());
3478         }
3479         this.mergeUnknownFields(other.getUnknownFields());
3480         return this;
3481       }
3482
3483       public final boolean isInitialized() {
3484         return true;
3485       }
3486
3487       public Builder mergeFrom(
3488           com.google.protobuf.CodedInputStream input,
3489           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3490           throws java.io.IOException {
3491         com.openxc.BinaryMessages.NumericMessage parsedMessage = null;
3492         try {
3493           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3494         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3495           parsedMessage = (com.openxc.BinaryMessages.NumericMessage) e.getUnfinishedMessage();
3496           throw e;
3497         } finally {
3498           if (parsedMessage != null) {
3499             mergeFrom(parsedMessage);
3500           }
3501         }
3502         return this;
3503       }
3504       private int bitField0_;
3505
3506       // optional string name = 1;
3507       private java.lang.Object name_ = "";
3508       /**
3509        * <code>optional string name = 1;</code>
3510        */
3511       public boolean hasName() {
3512         return ((bitField0_ & 0x00000001) == 0x00000001);
3513       }
3514       /**
3515        * <code>optional string name = 1;</code>
3516        */
3517       public java.lang.String getName() {
3518         java.lang.Object ref = name_;
3519         if (!(ref instanceof java.lang.String)) {
3520           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3521               .toStringUtf8();
3522           name_ = s;
3523           return s;
3524         } else {
3525           return (java.lang.String) ref;
3526         }
3527       }
3528       /**
3529        * <code>optional string name = 1;</code>
3530        */
3531       public com.google.protobuf.ByteString
3532           getNameBytes() {
3533         java.lang.Object ref = name_;
3534         if (ref instanceof String) {
3535           com.google.protobuf.ByteString b =
3536               com.google.protobuf.ByteString.copyFromUtf8(
3537                   (java.lang.String) ref);
3538           name_ = b;
3539           return b;
3540         } else {
3541           return (com.google.protobuf.ByteString) ref;
3542         }
3543       }
3544       /**
3545        * <code>optional string name = 1;</code>
3546        */
3547       public Builder setName(
3548           java.lang.String value) {
3549         if (value == null) {
3550     throw new NullPointerException();
3551   }
3552   bitField0_ |= 0x00000001;
3553         name_ = value;
3554         onChanged();
3555         return this;
3556       }
3557       /**
3558        * <code>optional string name = 1;</code>
3559        */
3560       public Builder clearName() {
3561         bitField0_ = (bitField0_ & ~0x00000001);
3562         name_ = getDefaultInstance().getName();
3563         onChanged();
3564         return this;
3565       }
3566       /**
3567        * <code>optional string name = 1;</code>
3568        */
3569       public Builder setNameBytes(
3570           com.google.protobuf.ByteString value) {
3571         if (value == null) {
3572     throw new NullPointerException();
3573   }
3574   bitField0_ |= 0x00000001;
3575         name_ = value;
3576         onChanged();
3577         return this;
3578       }
3579
3580       // optional double value = 2;
3581       private double value_ ;
3582       /**
3583        * <code>optional double value = 2;</code>
3584        */
3585       public boolean hasValue() {
3586         return ((bitField0_ & 0x00000002) == 0x00000002);
3587       }
3588       /**
3589        * <code>optional double value = 2;</code>
3590        */
3591       public double getValue() {
3592         return value_;
3593       }
3594       /**
3595        * <code>optional double value = 2;</code>
3596        */
3597       public Builder setValue(double value) {
3598         bitField0_ |= 0x00000002;
3599         value_ = value;
3600         onChanged();
3601         return this;
3602       }
3603       /**
3604        * <code>optional double value = 2;</code>
3605        */
3606       public Builder clearValue() {
3607         bitField0_ = (bitField0_ & ~0x00000002);
3608         value_ = 0D;
3609         onChanged();
3610         return this;
3611       }
3612
3613       // @@protoc_insertion_point(builder_scope:openxc.NumericMessage)
3614     }
3615
3616     static {
3617       defaultInstance = new NumericMessage(true);
3618       defaultInstance.initFields();
3619     }
3620
3621     // @@protoc_insertion_point(class_scope:openxc.NumericMessage)
3622   }
3623
3624   public interface BooleanMessageOrBuilder
3625       extends com.google.protobuf.MessageOrBuilder {
3626
3627     // optional string name = 1;
3628     /**
3629      * <code>optional string name = 1;</code>
3630      */
3631     boolean hasName();
3632     /**
3633      * <code>optional string name = 1;</code>
3634      */
3635     java.lang.String getName();
3636     /**
3637      * <code>optional string name = 1;</code>
3638      */
3639     com.google.protobuf.ByteString
3640         getNameBytes();
3641
3642     // optional bool value = 2;
3643     /**
3644      * <code>optional bool value = 2;</code>
3645      */
3646     boolean hasValue();
3647     /**
3648      * <code>optional bool value = 2;</code>
3649      */
3650     boolean getValue();
3651   }
3652   /**
3653    * Protobuf type {@code openxc.BooleanMessage}
3654    */
3655   public static final class BooleanMessage extends
3656       com.google.protobuf.GeneratedMessage
3657       implements BooleanMessageOrBuilder {
3658     // Use BooleanMessage.newBuilder() to construct.
3659     private BooleanMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3660       super(builder);
3661       this.unknownFields = builder.getUnknownFields();
3662     }
3663     private BooleanMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3664
3665     private static final BooleanMessage defaultInstance;
3666     public static BooleanMessage getDefaultInstance() {
3667       return defaultInstance;
3668     }
3669
3670     public BooleanMessage getDefaultInstanceForType() {
3671       return defaultInstance;
3672     }
3673
3674     private final com.google.protobuf.UnknownFieldSet unknownFields;
3675     @java.lang.Override
3676     public final com.google.protobuf.UnknownFieldSet
3677         getUnknownFields() {
3678       return this.unknownFields;
3679     }
3680     private BooleanMessage(
3681         com.google.protobuf.CodedInputStream input,
3682         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3683         throws com.google.protobuf.InvalidProtocolBufferException {
3684       initFields();
3685       int mutable_bitField0_ = 0;
3686       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3687           com.google.protobuf.UnknownFieldSet.newBuilder();
3688       try {
3689         boolean done = false;
3690         while (!done) {
3691           int tag = input.readTag();
3692           switch (tag) {
3693             case 0:
3694               done = true;
3695               break;
3696             default: {
3697               if (!parseUnknownField(input, unknownFields,
3698                                      extensionRegistry, tag)) {
3699                 done = true;
3700               }
3701               break;
3702             }
3703             case 10: {
3704               bitField0_ |= 0x00000001;
3705               name_ = input.readBytes();
3706               break;
3707             }
3708             case 16: {
3709               bitField0_ |= 0x00000002;
3710               value_ = input.readBool();
3711               break;
3712             }
3713           }
3714         }
3715       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3716         throw e.setUnfinishedMessage(this);
3717       } catch (java.io.IOException e) {
3718         throw new com.google.protobuf.InvalidProtocolBufferException(
3719             e.getMessage()).setUnfinishedMessage(this);
3720       } finally {
3721         this.unknownFields = unknownFields.build();
3722         makeExtensionsImmutable();
3723       }
3724     }
3725     public static final com.google.protobuf.Descriptors.Descriptor
3726         getDescriptor() {
3727       return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_descriptor;
3728     }
3729
3730     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3731         internalGetFieldAccessorTable() {
3732       return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_fieldAccessorTable
3733           .ensureFieldAccessorsInitialized(
3734               com.openxc.BinaryMessages.BooleanMessage.class, com.openxc.BinaryMessages.BooleanMessage.Builder.class);
3735     }
3736
3737     public static com.google.protobuf.Parser<BooleanMessage> PARSER =
3738         new com.google.protobuf.AbstractParser<BooleanMessage>() {
3739       public BooleanMessage parsePartialFrom(
3740           com.google.protobuf.CodedInputStream input,
3741           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3742           throws com.google.protobuf.InvalidProtocolBufferException {
3743         return new BooleanMessage(input, extensionRegistry);
3744       }
3745     };
3746
3747     @java.lang.Override
3748     public com.google.protobuf.Parser<BooleanMessage> getParserForType() {
3749       return PARSER;
3750     }
3751
3752     private int bitField0_;
3753     // optional string name = 1;
3754     public static final int NAME_FIELD_NUMBER = 1;
3755     private java.lang.Object name_;
3756     /**
3757      * <code>optional string name = 1;</code>
3758      */
3759     public boolean hasName() {
3760       return ((bitField0_ & 0x00000001) == 0x00000001);
3761     }
3762     /**
3763      * <code>optional string name = 1;</code>
3764      */
3765     public java.lang.String getName() {
3766       java.lang.Object ref = name_;
3767       if (ref instanceof java.lang.String) {
3768         return (java.lang.String) ref;
3769       } else {
3770         com.google.protobuf.ByteString bs =
3771             (com.google.protobuf.ByteString) ref;
3772         java.lang.String s = bs.toStringUtf8();
3773         if (bs.isValidUtf8()) {
3774           name_ = s;
3775         }
3776         return s;
3777       }
3778     }
3779     /**
3780      * <code>optional string name = 1;</code>
3781      */
3782     public com.google.protobuf.ByteString
3783         getNameBytes() {
3784       java.lang.Object ref = name_;
3785       if (ref instanceof java.lang.String) {
3786         com.google.protobuf.ByteString b =
3787             com.google.protobuf.ByteString.copyFromUtf8(
3788                 (java.lang.String) ref);
3789         name_ = b;
3790         return b;
3791       } else {
3792         return (com.google.protobuf.ByteString) ref;
3793       }
3794     }
3795
3796     // optional bool value = 2;
3797     public static final int VALUE_FIELD_NUMBER = 2;
3798     private boolean value_;
3799     /**
3800      * <code>optional bool value = 2;</code>
3801      */
3802     public boolean hasValue() {
3803       return ((bitField0_ & 0x00000002) == 0x00000002);
3804     }
3805     /**
3806      * <code>optional bool value = 2;</code>
3807      */
3808     public boolean getValue() {
3809       return value_;
3810     }
3811
3812     private void initFields() {
3813       name_ = "";
3814       value_ = false;
3815     }
3816     private byte memoizedIsInitialized = -1;
3817     public final boolean isInitialized() {
3818       byte isInitialized = memoizedIsInitialized;
3819       if (isInitialized != -1) return isInitialized == 1;
3820
3821       memoizedIsInitialized = 1;
3822       return true;
3823     }
3824
3825     public void writeTo(com.google.protobuf.CodedOutputStream output)
3826                         throws java.io.IOException {
3827       getSerializedSize();
3828       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3829         output.writeBytes(1, getNameBytes());
3830       }
3831       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3832         output.writeBool(2, value_);
3833       }
3834       getUnknownFields().writeTo(output);
3835     }
3836
3837     private int memoizedSerializedSize = -1;
3838     public int getSerializedSize() {
3839       int size = memoizedSerializedSize;
3840       if (size != -1) return size;
3841
3842       size = 0;
3843       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3844         size += com.google.protobuf.CodedOutputStream
3845           .computeBytesSize(1, getNameBytes());
3846       }
3847       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3848         size += com.google.protobuf.CodedOutputStream
3849           .computeBoolSize(2, value_);
3850       }
3851       size += getUnknownFields().getSerializedSize();
3852       memoizedSerializedSize = size;
3853       return size;
3854     }
3855
3856     private static final long serialVersionUID = 0L;
3857     @java.lang.Override
3858     protected java.lang.Object writeReplace()
3859         throws java.io.ObjectStreamException {
3860       return super.writeReplace();
3861     }
3862
3863     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3864         com.google.protobuf.ByteString data)
3865         throws com.google.protobuf.InvalidProtocolBufferException {
3866       return PARSER.parseFrom(data);
3867     }
3868     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3869         com.google.protobuf.ByteString data,
3870         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3871         throws com.google.protobuf.InvalidProtocolBufferException {
3872       return PARSER.parseFrom(data, extensionRegistry);
3873     }
3874     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(byte[] data)
3875         throws com.google.protobuf.InvalidProtocolBufferException {
3876       return PARSER.parseFrom(data);
3877     }
3878     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3879         byte[] data,
3880         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3881         throws com.google.protobuf.InvalidProtocolBufferException {
3882       return PARSER.parseFrom(data, extensionRegistry);
3883     }
3884     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(java.io.InputStream input)
3885         throws java.io.IOException {
3886       return PARSER.parseFrom(input);
3887     }
3888     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3889         java.io.InputStream input,
3890         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3891         throws java.io.IOException {
3892       return PARSER.parseFrom(input, extensionRegistry);
3893     }
3894     public static com.openxc.BinaryMessages.BooleanMessage parseDelimitedFrom(java.io.InputStream input)
3895         throws java.io.IOException {
3896       return PARSER.parseDelimitedFrom(input);
3897     }
3898     public static com.openxc.BinaryMessages.BooleanMessage parseDelimitedFrom(
3899         java.io.InputStream input,
3900         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3901         throws java.io.IOException {
3902       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3903     }
3904     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3905         com.google.protobuf.CodedInputStream input)
3906         throws java.io.IOException {
3907       return PARSER.parseFrom(input);
3908     }
3909     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3910         com.google.protobuf.CodedInputStream input,
3911         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3912         throws java.io.IOException {
3913       return PARSER.parseFrom(input, extensionRegistry);
3914     }
3915
3916     public static Builder newBuilder() { return Builder.create(); }
3917     public Builder newBuilderForType() { return newBuilder(); }
3918     public static Builder newBuilder(com.openxc.BinaryMessages.BooleanMessage prototype) {
3919       return newBuilder().mergeFrom(prototype);
3920     }
3921     public Builder toBuilder() { return newBuilder(this); }
3922
3923     @java.lang.Override
3924     protected Builder newBuilderForType(
3925         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3926       Builder builder = new Builder(parent);
3927       return builder;
3928     }
3929     /**
3930      * Protobuf type {@code openxc.BooleanMessage}
3931      */
3932     public static final class Builder extends
3933         com.google.protobuf.GeneratedMessage.Builder<Builder>
3934        implements com.openxc.BinaryMessages.BooleanMessageOrBuilder {
3935       public static final com.google.protobuf.Descriptors.Descriptor
3936           getDescriptor() {
3937         return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_descriptor;
3938       }
3939
3940       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3941           internalGetFieldAccessorTable() {
3942         return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_fieldAccessorTable
3943             .ensureFieldAccessorsInitialized(
3944                 com.openxc.BinaryMessages.BooleanMessage.class, com.openxc.BinaryMessages.BooleanMessage.Builder.class);
3945       }
3946
3947       // Construct using com.openxc.BinaryMessages.BooleanMessage.newBuilder()
3948       private Builder() {
3949         maybeForceBuilderInitialization();
3950       }
3951
3952       private Builder(
3953           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3954         super(parent);
3955         maybeForceBuilderInitialization();
3956       }
3957       private void maybeForceBuilderInitialization() {
3958         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3959         }
3960       }
3961       private static Builder create() {
3962         return new Builder();
3963       }
3964
3965       public Builder clear() {
3966         super.clear();
3967         name_ = "";
3968         bitField0_ = (bitField0_ & ~0x00000001);
3969         value_ = false;
3970         bitField0_ = (bitField0_ & ~0x00000002);
3971         return this;
3972       }
3973
3974       public Builder clone() {
3975         return create().mergeFrom(buildPartial());
3976       }
3977
3978       public com.google.protobuf.Descriptors.Descriptor
3979           getDescriptorForType() {
3980         return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_descriptor;
3981       }
3982
3983       public com.openxc.BinaryMessages.BooleanMessage getDefaultInstanceForType() {
3984         return com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance();
3985       }
3986
3987       public com.openxc.BinaryMessages.BooleanMessage build() {
3988         com.openxc.BinaryMessages.BooleanMessage result = buildPartial();
3989         if (!result.isInitialized()) {
3990           throw newUninitializedMessageException(result);
3991         }
3992         return result;
3993       }
3994
3995       public com.openxc.BinaryMessages.BooleanMessage buildPartial() {
3996         com.openxc.BinaryMessages.BooleanMessage result = new com.openxc.BinaryMessages.BooleanMessage(this);
3997         int from_bitField0_ = bitField0_;
3998         int to_bitField0_ = 0;
3999         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4000           to_bitField0_ |= 0x00000001;
4001         }
4002         result.name_ = name_;
4003         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4004           to_bitField0_ |= 0x00000002;
4005         }
4006         result.value_ = value_;
4007         result.bitField0_ = to_bitField0_;
4008         onBuilt();
4009         return result;
4010       }
4011
4012       public Builder mergeFrom(com.google.protobuf.Message other) {
4013         if (other instanceof com.openxc.BinaryMessages.BooleanMessage) {
4014           return mergeFrom((com.openxc.BinaryMessages.BooleanMessage)other);
4015         } else {
4016           super.mergeFrom(other);
4017           return this;
4018         }
4019       }
4020
4021       public Builder mergeFrom(com.openxc.BinaryMessages.BooleanMessage other) {
4022         if (other == com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance()) return this;
4023         if (other.hasName()) {
4024           bitField0_ |= 0x00000001;
4025           name_ = other.name_;
4026           onChanged();
4027         }
4028         if (other.hasValue()) {
4029           setValue(other.getValue());
4030         }
4031         this.mergeUnknownFields(other.getUnknownFields());
4032         return this;
4033       }
4034
4035       public final boolean isInitialized() {
4036         return true;
4037       }
4038
4039       public Builder mergeFrom(
4040           com.google.protobuf.CodedInputStream input,
4041           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4042           throws java.io.IOException {
4043         com.openxc.BinaryMessages.BooleanMessage parsedMessage = null;
4044         try {
4045           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4046         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4047           parsedMessage = (com.openxc.BinaryMessages.BooleanMessage) e.getUnfinishedMessage();
4048           throw e;
4049         } finally {
4050           if (parsedMessage != null) {
4051             mergeFrom(parsedMessage);
4052           }
4053         }
4054         return this;
4055       }
4056       private int bitField0_;
4057
4058       // optional string name = 1;
4059       private java.lang.Object name_ = "";
4060       /**
4061        * <code>optional string name = 1;</code>
4062        */
4063       public boolean hasName() {
4064         return ((bitField0_ & 0x00000001) == 0x00000001);
4065       }
4066       /**
4067        * <code>optional string name = 1;</code>
4068        */
4069       public java.lang.String getName() {
4070         java.lang.Object ref = name_;
4071         if (!(ref instanceof java.lang.String)) {
4072           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4073               .toStringUtf8();
4074           name_ = s;
4075           return s;
4076         } else {
4077           return (java.lang.String) ref;
4078         }
4079       }
4080       /**
4081        * <code>optional string name = 1;</code>
4082        */
4083       public com.google.protobuf.ByteString
4084           getNameBytes() {
4085         java.lang.Object ref = name_;
4086         if (ref instanceof String) {
4087           com.google.protobuf.ByteString b =
4088               com.google.protobuf.ByteString.copyFromUtf8(
4089                   (java.lang.String) ref);
4090           name_ = b;
4091           return b;
4092         } else {
4093           return (com.google.protobuf.ByteString) ref;
4094         }
4095       }
4096       /**
4097        * <code>optional string name = 1;</code>
4098        */
4099       public Builder setName(
4100           java.lang.String value) {
4101         if (value == null) {
4102     throw new NullPointerException();
4103   }
4104   bitField0_ |= 0x00000001;
4105         name_ = value;
4106         onChanged();
4107         return this;
4108       }
4109       /**
4110        * <code>optional string name = 1;</code>
4111        */
4112       public Builder clearName() {
4113         bitField0_ = (bitField0_ & ~0x00000001);
4114         name_ = getDefaultInstance().getName();
4115         onChanged();
4116         return this;
4117       }
4118       /**
4119        * <code>optional string name = 1;</code>
4120        */
4121       public Builder setNameBytes(
4122           com.google.protobuf.ByteString value) {
4123         if (value == null) {
4124     throw new NullPointerException();
4125   }
4126   bitField0_ |= 0x00000001;
4127         name_ = value;
4128         onChanged();
4129         return this;
4130       }
4131
4132       // optional bool value = 2;
4133       private boolean value_ ;
4134       /**
4135        * <code>optional bool value = 2;</code>
4136        */
4137       public boolean hasValue() {
4138         return ((bitField0_ & 0x00000002) == 0x00000002);
4139       }
4140       /**
4141        * <code>optional bool value = 2;</code>
4142        */
4143       public boolean getValue() {
4144         return value_;
4145       }
4146       /**
4147        * <code>optional bool value = 2;</code>
4148        */
4149       public Builder setValue(boolean value) {
4150         bitField0_ |= 0x00000002;
4151         value_ = value;
4152         onChanged();
4153         return this;
4154       }
4155       /**
4156        * <code>optional bool value = 2;</code>
4157        */
4158       public Builder clearValue() {
4159         bitField0_ = (bitField0_ & ~0x00000002);
4160         value_ = false;
4161         onChanged();
4162         return this;
4163       }
4164
4165       // @@protoc_insertion_point(builder_scope:openxc.BooleanMessage)
4166     }
4167
4168     static {
4169       defaultInstance = new BooleanMessage(true);
4170       defaultInstance.initFields();
4171     }
4172
4173     // @@protoc_insertion_point(class_scope:openxc.BooleanMessage)
4174   }
4175
4176   public interface EventedStringMessageOrBuilder
4177       extends com.google.protobuf.MessageOrBuilder {
4178
4179     // optional string name = 1;
4180     /**
4181      * <code>optional string name = 1;</code>
4182      */
4183     boolean hasName();
4184     /**
4185      * <code>optional string name = 1;</code>
4186      */
4187     java.lang.String getName();
4188     /**
4189      * <code>optional string name = 1;</code>
4190      */
4191     com.google.protobuf.ByteString
4192         getNameBytes();
4193
4194     // optional string value = 2;
4195     /**
4196      * <code>optional string value = 2;</code>
4197      */
4198     boolean hasValue();
4199     /**
4200      * <code>optional string value = 2;</code>
4201      */
4202     java.lang.String getValue();
4203     /**
4204      * <code>optional string value = 2;</code>
4205      */
4206     com.google.protobuf.ByteString
4207         getValueBytes();
4208
4209     // optional string event = 3;
4210     /**
4211      * <code>optional string event = 3;</code>
4212      */
4213     boolean hasEvent();
4214     /**
4215      * <code>optional string event = 3;</code>
4216      */
4217     java.lang.String getEvent();
4218     /**
4219      * <code>optional string event = 3;</code>
4220      */
4221     com.google.protobuf.ByteString
4222         getEventBytes();
4223   }
4224   /**
4225    * Protobuf type {@code openxc.EventedStringMessage}
4226    */
4227   public static final class EventedStringMessage extends
4228       com.google.protobuf.GeneratedMessage
4229       implements EventedStringMessageOrBuilder {
4230     // Use EventedStringMessage.newBuilder() to construct.
4231     private EventedStringMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4232       super(builder);
4233       this.unknownFields = builder.getUnknownFields();
4234     }
4235     private EventedStringMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4236
4237     private static final EventedStringMessage defaultInstance;
4238     public static EventedStringMessage getDefaultInstance() {
4239       return defaultInstance;
4240     }
4241
4242     public EventedStringMessage getDefaultInstanceForType() {
4243       return defaultInstance;
4244     }
4245
4246     private final com.google.protobuf.UnknownFieldSet unknownFields;
4247     @java.lang.Override
4248     public final com.google.protobuf.UnknownFieldSet
4249         getUnknownFields() {
4250       return this.unknownFields;
4251     }
4252     private EventedStringMessage(
4253         com.google.protobuf.CodedInputStream input,
4254         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4255         throws com.google.protobuf.InvalidProtocolBufferException {
4256       initFields();
4257       int mutable_bitField0_ = 0;
4258       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4259           com.google.protobuf.UnknownFieldSet.newBuilder();
4260       try {
4261         boolean done = false;
4262         while (!done) {
4263           int tag = input.readTag();
4264           switch (tag) {
4265             case 0:
4266               done = true;
4267               break;
4268             default: {
4269               if (!parseUnknownField(input, unknownFields,
4270                                      extensionRegistry, tag)) {
4271                 done = true;
4272               }
4273               break;
4274             }
4275             case 10: {
4276               bitField0_ |= 0x00000001;
4277               name_ = input.readBytes();
4278               break;
4279             }
4280             case 18: {
4281               bitField0_ |= 0x00000002;
4282               value_ = input.readBytes();
4283               break;
4284             }
4285             case 26: {
4286               bitField0_ |= 0x00000004;
4287               event_ = input.readBytes();
4288               break;
4289             }
4290           }
4291         }
4292       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4293         throw e.setUnfinishedMessage(this);
4294       } catch (java.io.IOException e) {
4295         throw new com.google.protobuf.InvalidProtocolBufferException(
4296             e.getMessage()).setUnfinishedMessage(this);
4297       } finally {
4298         this.unknownFields = unknownFields.build();
4299         makeExtensionsImmutable();
4300       }
4301     }
4302     public static final com.google.protobuf.Descriptors.Descriptor
4303         getDescriptor() {
4304       return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_descriptor;
4305     }
4306
4307     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4308         internalGetFieldAccessorTable() {
4309       return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_fieldAccessorTable
4310           .ensureFieldAccessorsInitialized(
4311               com.openxc.BinaryMessages.EventedStringMessage.class, com.openxc.BinaryMessages.EventedStringMessage.Builder.class);
4312     }
4313
4314     public static com.google.protobuf.Parser<EventedStringMessage> PARSER =
4315         new com.google.protobuf.AbstractParser<EventedStringMessage>() {
4316       public EventedStringMessage parsePartialFrom(
4317           com.google.protobuf.CodedInputStream input,
4318           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4319           throws com.google.protobuf.InvalidProtocolBufferException {
4320         return new EventedStringMessage(input, extensionRegistry);
4321       }
4322     };
4323
4324     @java.lang.Override
4325     public com.google.protobuf.Parser<EventedStringMessage> getParserForType() {
4326       return PARSER;
4327     }
4328
4329     private int bitField0_;
4330     // optional string name = 1;
4331     public static final int NAME_FIELD_NUMBER = 1;
4332     private java.lang.Object name_;
4333     /**
4334      * <code>optional string name = 1;</code>
4335      */
4336     public boolean hasName() {
4337       return ((bitField0_ & 0x00000001) == 0x00000001);
4338     }
4339     /**
4340      * <code>optional string name = 1;</code>
4341      */
4342     public java.lang.String getName() {
4343       java.lang.Object ref = name_;
4344       if (ref instanceof java.lang.String) {
4345         return (java.lang.String) ref;
4346       } else {
4347         com.google.protobuf.ByteString bs =
4348             (com.google.protobuf.ByteString) ref;
4349         java.lang.String s = bs.toStringUtf8();
4350         if (bs.isValidUtf8()) {
4351           name_ = s;
4352         }
4353         return s;
4354       }
4355     }
4356     /**
4357      * <code>optional string name = 1;</code>
4358      */
4359     public com.google.protobuf.ByteString
4360         getNameBytes() {
4361       java.lang.Object ref = name_;
4362       if (ref instanceof java.lang.String) {
4363         com.google.protobuf.ByteString b =
4364             com.google.protobuf.ByteString.copyFromUtf8(
4365                 (java.lang.String) ref);
4366         name_ = b;
4367         return b;
4368       } else {
4369         return (com.google.protobuf.ByteString) ref;
4370       }
4371     }
4372
4373     // optional string value = 2;
4374     public static final int VALUE_FIELD_NUMBER = 2;
4375     private java.lang.Object value_;
4376     /**
4377      * <code>optional string value = 2;</code>
4378      */
4379     public boolean hasValue() {
4380       return ((bitField0_ & 0x00000002) == 0x00000002);
4381     }
4382     /**
4383      * <code>optional string value = 2;</code>
4384      */
4385     public java.lang.String getValue() {
4386       java.lang.Object ref = value_;
4387       if (ref instanceof java.lang.String) {
4388         return (java.lang.String) ref;
4389       } else {
4390         com.google.protobuf.ByteString bs =
4391             (com.google.protobuf.ByteString) ref;
4392         java.lang.String s = bs.toStringUtf8();
4393         if (bs.isValidUtf8()) {
4394           value_ = s;
4395         }
4396         return s;
4397       }
4398     }
4399     /**
4400      * <code>optional string value = 2;</code>
4401      */
4402     public com.google.protobuf.ByteString
4403         getValueBytes() {
4404       java.lang.Object ref = value_;
4405       if (ref instanceof java.lang.String) {
4406         com.google.protobuf.ByteString b =
4407             com.google.protobuf.ByteString.copyFromUtf8(
4408                 (java.lang.String) ref);
4409         value_ = b;
4410         return b;
4411       } else {
4412         return (com.google.protobuf.ByteString) ref;
4413       }
4414     }
4415
4416     // optional string event = 3;
4417     public static final int EVENT_FIELD_NUMBER = 3;
4418     private java.lang.Object event_;
4419     /**
4420      * <code>optional string event = 3;</code>
4421      */
4422     public boolean hasEvent() {
4423       return ((bitField0_ & 0x00000004) == 0x00000004);
4424     }
4425     /**
4426      * <code>optional string event = 3;</code>
4427      */
4428     public java.lang.String getEvent() {
4429       java.lang.Object ref = event_;
4430       if (ref instanceof java.lang.String) {
4431         return (java.lang.String) ref;
4432       } else {
4433         com.google.protobuf.ByteString bs =
4434             (com.google.protobuf.ByteString) ref;
4435         java.lang.String s = bs.toStringUtf8();
4436         if (bs.isValidUtf8()) {
4437           event_ = s;
4438         }
4439         return s;
4440       }
4441     }
4442     /**
4443      * <code>optional string event = 3;</code>
4444      */
4445     public com.google.protobuf.ByteString
4446         getEventBytes() {
4447       java.lang.Object ref = event_;
4448       if (ref instanceof java.lang.String) {
4449         com.google.protobuf.ByteString b =
4450             com.google.protobuf.ByteString.copyFromUtf8(
4451                 (java.lang.String) ref);
4452         event_ = b;
4453         return b;
4454       } else {
4455         return (com.google.protobuf.ByteString) ref;
4456       }
4457     }
4458
4459     private void initFields() {
4460       name_ = "";
4461       value_ = "";
4462       event_ = "";
4463     }
4464     private byte memoizedIsInitialized = -1;
4465     public final boolean isInitialized() {
4466       byte isInitialized = memoizedIsInitialized;
4467       if (isInitialized != -1) return isInitialized == 1;
4468
4469       memoizedIsInitialized = 1;
4470       return true;
4471     }
4472
4473     public void writeTo(com.google.protobuf.CodedOutputStream output)
4474                         throws java.io.IOException {
4475       getSerializedSize();
4476       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4477         output.writeBytes(1, getNameBytes());
4478       }
4479       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4480         output.writeBytes(2, getValueBytes());
4481       }
4482       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4483         output.writeBytes(3, getEventBytes());
4484       }
4485       getUnknownFields().writeTo(output);
4486     }
4487
4488     private int memoizedSerializedSize = -1;
4489     public int getSerializedSize() {
4490       int size = memoizedSerializedSize;
4491       if (size != -1) return size;
4492
4493       size = 0;
4494       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4495         size += com.google.protobuf.CodedOutputStream
4496           .computeBytesSize(1, getNameBytes());
4497       }
4498       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4499         size += com.google.protobuf.CodedOutputStream
4500           .computeBytesSize(2, getValueBytes());
4501       }
4502       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4503         size += com.google.protobuf.CodedOutputStream
4504           .computeBytesSize(3, getEventBytes());
4505       }
4506       size += getUnknownFields().getSerializedSize();
4507       memoizedSerializedSize = size;
4508       return size;
4509     }
4510
4511     private static final long serialVersionUID = 0L;
4512     @java.lang.Override
4513     protected java.lang.Object writeReplace()
4514         throws java.io.ObjectStreamException {
4515       return super.writeReplace();
4516     }
4517
4518     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4519         com.google.protobuf.ByteString data)
4520         throws com.google.protobuf.InvalidProtocolBufferException {
4521       return PARSER.parseFrom(data);
4522     }
4523     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4524         com.google.protobuf.ByteString data,
4525         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4526         throws com.google.protobuf.InvalidProtocolBufferException {
4527       return PARSER.parseFrom(data, extensionRegistry);
4528     }
4529     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(byte[] data)
4530         throws com.google.protobuf.InvalidProtocolBufferException {
4531       return PARSER.parseFrom(data);
4532     }
4533     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4534         byte[] data,
4535         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4536         throws com.google.protobuf.InvalidProtocolBufferException {
4537       return PARSER.parseFrom(data, extensionRegistry);
4538     }
4539     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(java.io.InputStream input)
4540         throws java.io.IOException {
4541       return PARSER.parseFrom(input);
4542     }
4543     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4544         java.io.InputStream input,
4545         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4546         throws java.io.IOException {
4547       return PARSER.parseFrom(input, extensionRegistry);
4548     }
4549     public static com.openxc.BinaryMessages.EventedStringMessage parseDelimitedFrom(java.io.InputStream input)
4550         throws java.io.IOException {
4551       return PARSER.parseDelimitedFrom(input);
4552     }
4553     public static com.openxc.BinaryMessages.EventedStringMessage parseDelimitedFrom(
4554         java.io.InputStream input,
4555         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4556         throws java.io.IOException {
4557       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4558     }
4559     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4560         com.google.protobuf.CodedInputStream input)
4561         throws java.io.IOException {
4562       return PARSER.parseFrom(input);
4563     }
4564     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4565         com.google.protobuf.CodedInputStream input,
4566         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4567         throws java.io.IOException {
4568       return PARSER.parseFrom(input, extensionRegistry);
4569     }
4570
4571     public static Builder newBuilder() { return Builder.create(); }
4572     public Builder newBuilderForType() { return newBuilder(); }
4573     public static Builder newBuilder(com.openxc.BinaryMessages.EventedStringMessage prototype) {
4574       return newBuilder().mergeFrom(prototype);
4575     }
4576     public Builder toBuilder() { return newBuilder(this); }
4577
4578     @java.lang.Override
4579     protected Builder newBuilderForType(
4580         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4581       Builder builder = new Builder(parent);
4582       return builder;
4583     }
4584     /**
4585      * Protobuf type {@code openxc.EventedStringMessage}
4586      */
4587     public static final class Builder extends
4588         com.google.protobuf.GeneratedMessage.Builder<Builder>
4589        implements com.openxc.BinaryMessages.EventedStringMessageOrBuilder {
4590       public static final com.google.protobuf.Descriptors.Descriptor
4591           getDescriptor() {
4592         return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_descriptor;
4593       }
4594
4595       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4596           internalGetFieldAccessorTable() {
4597         return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_fieldAccessorTable
4598             .ensureFieldAccessorsInitialized(
4599                 com.openxc.BinaryMessages.EventedStringMessage.class, com.openxc.BinaryMessages.EventedStringMessage.Builder.class);
4600       }
4601
4602       // Construct using com.openxc.BinaryMessages.EventedStringMessage.newBuilder()
4603       private Builder() {
4604         maybeForceBuilderInitialization();
4605       }
4606
4607       private Builder(
4608           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4609         super(parent);
4610         maybeForceBuilderInitialization();
4611       }
4612       private void maybeForceBuilderInitialization() {
4613         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4614         }
4615       }
4616       private static Builder create() {
4617         return new Builder();
4618       }
4619
4620       public Builder clear() {
4621         super.clear();
4622         name_ = "";
4623         bitField0_ = (bitField0_ & ~0x00000001);
4624         value_ = "";
4625         bitField0_ = (bitField0_ & ~0x00000002);
4626         event_ = "";
4627         bitField0_ = (bitField0_ & ~0x00000004);
4628         return this;
4629       }
4630
4631       public Builder clone() {
4632         return create().mergeFrom(buildPartial());
4633       }
4634
4635       public com.google.protobuf.Descriptors.Descriptor
4636           getDescriptorForType() {
4637         return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_descriptor;
4638       }
4639
4640       public com.openxc.BinaryMessages.EventedStringMessage getDefaultInstanceForType() {
4641         return com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance();
4642       }
4643
4644       public com.openxc.BinaryMessages.EventedStringMessage build() {
4645         com.openxc.BinaryMessages.EventedStringMessage result = buildPartial();
4646         if (!result.isInitialized()) {
4647           throw newUninitializedMessageException(result);
4648         }
4649         return result;
4650       }
4651
4652       public com.openxc.BinaryMessages.EventedStringMessage buildPartial() {
4653         com.openxc.BinaryMessages.EventedStringMessage result = new com.openxc.BinaryMessages.EventedStringMessage(this);
4654         int from_bitField0_ = bitField0_;
4655         int to_bitField0_ = 0;
4656         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4657           to_bitField0_ |= 0x00000001;
4658         }
4659         result.name_ = name_;
4660         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4661           to_bitField0_ |= 0x00000002;
4662         }
4663         result.value_ = value_;
4664         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4665           to_bitField0_ |= 0x00000004;
4666         }
4667         result.event_ = event_;
4668         result.bitField0_ = to_bitField0_;
4669         onBuilt();
4670         return result;
4671       }
4672
4673       public Builder mergeFrom(com.google.protobuf.Message other) {
4674         if (other instanceof com.openxc.BinaryMessages.EventedStringMessage) {
4675           return mergeFrom((com.openxc.BinaryMessages.EventedStringMessage)other);
4676         } else {
4677           super.mergeFrom(other);
4678           return this;
4679         }
4680       }
4681
4682       public Builder mergeFrom(com.openxc.BinaryMessages.EventedStringMessage other) {
4683         if (other == com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance()) return this;
4684         if (other.hasName()) {
4685           bitField0_ |= 0x00000001;
4686           name_ = other.name_;
4687           onChanged();
4688         }
4689         if (other.hasValue()) {
4690           bitField0_ |= 0x00000002;
4691           value_ = other.value_;
4692           onChanged();
4693         }
4694         if (other.hasEvent()) {
4695           bitField0_ |= 0x00000004;
4696           event_ = other.event_;
4697           onChanged();
4698         }
4699         this.mergeUnknownFields(other.getUnknownFields());
4700         return this;
4701       }
4702
4703       public final boolean isInitialized() {
4704         return true;
4705       }
4706
4707       public Builder mergeFrom(
4708           com.google.protobuf.CodedInputStream input,
4709           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4710           throws java.io.IOException {
4711         com.openxc.BinaryMessages.EventedStringMessage parsedMessage = null;
4712         try {
4713           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4714         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4715           parsedMessage = (com.openxc.BinaryMessages.EventedStringMessage) e.getUnfinishedMessage();
4716           throw e;
4717         } finally {
4718           if (parsedMessage != null) {
4719             mergeFrom(parsedMessage);
4720           }
4721         }
4722         return this;
4723       }
4724       private int bitField0_;
4725
4726       // optional string name = 1;
4727       private java.lang.Object name_ = "";
4728       /**
4729        * <code>optional string name = 1;</code>
4730        */
4731       public boolean hasName() {
4732         return ((bitField0_ & 0x00000001) == 0x00000001);
4733       }
4734       /**
4735        * <code>optional string name = 1;</code>
4736        */
4737       public java.lang.String getName() {
4738         java.lang.Object ref = name_;
4739         if (!(ref instanceof java.lang.String)) {
4740           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4741               .toStringUtf8();
4742           name_ = s;
4743           return s;
4744         } else {
4745           return (java.lang.String) ref;
4746         }
4747       }
4748       /**
4749        * <code>optional string name = 1;</code>
4750        */
4751       public com.google.protobuf.ByteString
4752           getNameBytes() {
4753         java.lang.Object ref = name_;
4754         if (ref instanceof String) {
4755           com.google.protobuf.ByteString b =
4756               com.google.protobuf.ByteString.copyFromUtf8(
4757                   (java.lang.String) ref);
4758           name_ = b;
4759           return b;
4760         } else {
4761           return (com.google.protobuf.ByteString) ref;
4762         }
4763       }
4764       /**
4765        * <code>optional string name = 1;</code>
4766        */
4767       public Builder setName(
4768           java.lang.String value) {
4769         if (value == null) {
4770     throw new NullPointerException();
4771   }
4772   bitField0_ |= 0x00000001;
4773         name_ = value;
4774         onChanged();
4775         return this;
4776       }
4777       /**
4778        * <code>optional string name = 1;</code>
4779        */
4780       public Builder clearName() {
4781         bitField0_ = (bitField0_ & ~0x00000001);
4782         name_ = getDefaultInstance().getName();
4783         onChanged();
4784         return this;
4785       }
4786       /**
4787        * <code>optional string name = 1;</code>
4788        */
4789       public Builder setNameBytes(
4790           com.google.protobuf.ByteString value) {
4791         if (value == null) {
4792     throw new NullPointerException();
4793   }
4794   bitField0_ |= 0x00000001;
4795         name_ = value;
4796         onChanged();
4797         return this;
4798       }
4799
4800       // optional string value = 2;
4801       private java.lang.Object value_ = "";
4802       /**
4803        * <code>optional string value = 2;</code>
4804        */
4805       public boolean hasValue() {
4806         return ((bitField0_ & 0x00000002) == 0x00000002);
4807       }
4808       /**
4809        * <code>optional string value = 2;</code>
4810        */
4811       public java.lang.String getValue() {
4812         java.lang.Object ref = value_;
4813         if (!(ref instanceof java.lang.String)) {
4814           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4815               .toStringUtf8();
4816           value_ = s;
4817           return s;
4818         } else {
4819           return (java.lang.String) ref;
4820         }
4821       }
4822       /**
4823        * <code>optional string value = 2;</code>
4824        */
4825       public com.google.protobuf.ByteString
4826           getValueBytes() {
4827         java.lang.Object ref = value_;
4828         if (ref instanceof String) {
4829           com.google.protobuf.ByteString b =
4830               com.google.protobuf.ByteString.copyFromUtf8(
4831                   (java.lang.String) ref);
4832           value_ = b;
4833           return b;
4834         } else {
4835           return (com.google.protobuf.ByteString) ref;
4836         }
4837       }
4838       /**
4839        * <code>optional string value = 2;</code>
4840        */
4841       public Builder setValue(
4842           java.lang.String value) {
4843         if (value == null) {
4844     throw new NullPointerException();
4845   }
4846   bitField0_ |= 0x00000002;
4847         value_ = value;
4848         onChanged();
4849         return this;
4850       }
4851       /**
4852        * <code>optional string value = 2;</code>
4853        */
4854       public Builder clearValue() {
4855         bitField0_ = (bitField0_ & ~0x00000002);
4856         value_ = getDefaultInstance().getValue();
4857         onChanged();
4858         return this;
4859       }
4860       /**
4861        * <code>optional string value = 2;</code>
4862        */
4863       public Builder setValueBytes(
4864           com.google.protobuf.ByteString value) {
4865         if (value == null) {
4866     throw new NullPointerException();
4867   }
4868   bitField0_ |= 0x00000002;
4869         value_ = value;
4870         onChanged();
4871         return this;
4872       }
4873
4874       // optional string event = 3;
4875       private java.lang.Object event_ = "";
4876       /**
4877        * <code>optional string event = 3;</code>
4878        */
4879       public boolean hasEvent() {
4880         return ((bitField0_ & 0x00000004) == 0x00000004);
4881       }
4882       /**
4883        * <code>optional string event = 3;</code>
4884        */
4885       public java.lang.String getEvent() {
4886         java.lang.Object ref = event_;
4887         if (!(ref instanceof java.lang.String)) {
4888           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4889               .toStringUtf8();
4890           event_ = s;
4891           return s;
4892         } else {
4893           return (java.lang.String) ref;
4894         }
4895       }
4896       /**
4897        * <code>optional string event = 3;</code>
4898        */
4899       public com.google.protobuf.ByteString
4900           getEventBytes() {
4901         java.lang.Object ref = event_;
4902         if (ref instanceof String) {
4903           com.google.protobuf.ByteString b =
4904               com.google.protobuf.ByteString.copyFromUtf8(
4905                   (java.lang.String) ref);
4906           event_ = b;
4907           return b;
4908         } else {
4909           return (com.google.protobuf.ByteString) ref;
4910         }
4911       }
4912       /**
4913        * <code>optional string event = 3;</code>
4914        */
4915       public Builder setEvent(
4916           java.lang.String value) {
4917         if (value == null) {
4918     throw new NullPointerException();
4919   }
4920   bitField0_ |= 0x00000004;
4921         event_ = value;
4922         onChanged();
4923         return this;
4924       }
4925       /**
4926        * <code>optional string event = 3;</code>
4927        */
4928       public Builder clearEvent() {
4929         bitField0_ = (bitField0_ & ~0x00000004);
4930         event_ = getDefaultInstance().getEvent();
4931         onChanged();
4932         return this;
4933       }
4934       /**
4935        * <code>optional string event = 3;</code>
4936        */
4937       public Builder setEventBytes(
4938           com.google.protobuf.ByteString value) {
4939         if (value == null) {
4940     throw new NullPointerException();
4941   }
4942   bitField0_ |= 0x00000004;
4943         event_ = value;
4944         onChanged();
4945         return this;
4946       }
4947
4948       // @@protoc_insertion_point(builder_scope:openxc.EventedStringMessage)
4949     }
4950
4951     static {
4952       defaultInstance = new EventedStringMessage(true);
4953       defaultInstance.initFields();
4954     }
4955
4956     // @@protoc_insertion_point(class_scope:openxc.EventedStringMessage)
4957   }
4958
4959   public interface EventedBooleanMessageOrBuilder
4960       extends com.google.protobuf.MessageOrBuilder {
4961
4962     // optional string name = 1;
4963     /**
4964      * <code>optional string name = 1;</code>
4965      */
4966     boolean hasName();
4967     /**
4968      * <code>optional string name = 1;</code>
4969      */
4970     java.lang.String getName();
4971     /**
4972      * <code>optional string name = 1;</code>
4973      */
4974     com.google.protobuf.ByteString
4975         getNameBytes();
4976
4977     // optional string value = 2;
4978     /**
4979      * <code>optional string value = 2;</code>
4980      */
4981     boolean hasValue();
4982     /**
4983      * <code>optional string value = 2;</code>
4984      */
4985     java.lang.String getValue();
4986     /**
4987      * <code>optional string value = 2;</code>
4988      */
4989     com.google.protobuf.ByteString
4990         getValueBytes();
4991
4992     // optional bool event = 3;
4993     /**
4994      * <code>optional bool event = 3;</code>
4995      */
4996     boolean hasEvent();
4997     /**
4998      * <code>optional bool event = 3;</code>
4999      */
5000     boolean getEvent();
5001   }
5002   /**
5003    * Protobuf type {@code openxc.EventedBooleanMessage}
5004    */
5005   public static final class EventedBooleanMessage extends
5006       com.google.protobuf.GeneratedMessage
5007       implements EventedBooleanMessageOrBuilder {
5008     // Use EventedBooleanMessage.newBuilder() to construct.
5009     private EventedBooleanMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5010       super(builder);
5011       this.unknownFields = builder.getUnknownFields();
5012     }
5013     private EventedBooleanMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5014
5015     private static final EventedBooleanMessage defaultInstance;
5016     public static EventedBooleanMessage getDefaultInstance() {
5017       return defaultInstance;
5018     }
5019
5020     public EventedBooleanMessage getDefaultInstanceForType() {
5021       return defaultInstance;
5022     }
5023
5024     private final com.google.protobuf.UnknownFieldSet unknownFields;
5025     @java.lang.Override
5026     public final com.google.protobuf.UnknownFieldSet
5027         getUnknownFields() {
5028       return this.unknownFields;
5029     }
5030     private EventedBooleanMessage(
5031         com.google.protobuf.CodedInputStream input,
5032         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5033         throws com.google.protobuf.InvalidProtocolBufferException {
5034       initFields();
5035       int mutable_bitField0_ = 0;
5036       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5037           com.google.protobuf.UnknownFieldSet.newBuilder();
5038       try {
5039         boolean done = false;
5040         while (!done) {
5041           int tag = input.readTag();
5042           switch (tag) {
5043             case 0:
5044               done = true;
5045               break;
5046             default: {
5047               if (!parseUnknownField(input, unknownFields,
5048                                      extensionRegistry, tag)) {
5049                 done = true;
5050               }
5051               break;
5052             }
5053             case 10: {
5054               bitField0_ |= 0x00000001;
5055               name_ = input.readBytes();
5056               break;
5057             }
5058             case 18: {
5059               bitField0_ |= 0x00000002;
5060               value_ = input.readBytes();
5061               break;
5062             }
5063             case 24: {
5064               bitField0_ |= 0x00000004;
5065               event_ = input.readBool();
5066               break;
5067             }
5068           }
5069         }
5070       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5071         throw e.setUnfinishedMessage(this);
5072       } catch (java.io.IOException e) {
5073         throw new com.google.protobuf.InvalidProtocolBufferException(
5074             e.getMessage()).setUnfinishedMessage(this);
5075       } finally {
5076         this.unknownFields = unknownFields.build();
5077         makeExtensionsImmutable();
5078       }
5079     }
5080     public static final com.google.protobuf.Descriptors.Descriptor
5081         getDescriptor() {
5082       return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_descriptor;
5083     }
5084
5085     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5086         internalGetFieldAccessorTable() {
5087       return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_fieldAccessorTable
5088           .ensureFieldAccessorsInitialized(
5089               com.openxc.BinaryMessages.EventedBooleanMessage.class, com.openxc.BinaryMessages.EventedBooleanMessage.Builder.class);
5090     }
5091
5092     public static com.google.protobuf.Parser<EventedBooleanMessage> PARSER =
5093         new com.google.protobuf.AbstractParser<EventedBooleanMessage>() {
5094       public EventedBooleanMessage parsePartialFrom(
5095           com.google.protobuf.CodedInputStream input,
5096           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5097           throws com.google.protobuf.InvalidProtocolBufferException {
5098         return new EventedBooleanMessage(input, extensionRegistry);
5099       }
5100     };
5101
5102     @java.lang.Override
5103     public com.google.protobuf.Parser<EventedBooleanMessage> getParserForType() {
5104       return PARSER;
5105     }
5106
5107     private int bitField0_;
5108     // optional string name = 1;
5109     public static final int NAME_FIELD_NUMBER = 1;
5110     private java.lang.Object name_;
5111     /**
5112      * <code>optional string name = 1;</code>
5113      */
5114     public boolean hasName() {
5115       return ((bitField0_ & 0x00000001) == 0x00000001);
5116     }
5117     /**
5118      * <code>optional string name = 1;</code>
5119      */
5120     public java.lang.String getName() {
5121       java.lang.Object ref = name_;
5122       if (ref instanceof java.lang.String) {
5123         return (java.lang.String) ref;
5124       } else {
5125         com.google.protobuf.ByteString bs =
5126             (com.google.protobuf.ByteString) ref;
5127         java.lang.String s = bs.toStringUtf8();
5128         if (bs.isValidUtf8()) {
5129           name_ = s;
5130         }
5131         return s;
5132       }
5133     }
5134     /**
5135      * <code>optional string name = 1;</code>
5136      */
5137     public com.google.protobuf.ByteString
5138         getNameBytes() {
5139       java.lang.Object ref = name_;
5140       if (ref instanceof java.lang.String) {
5141         com.google.protobuf.ByteString b =
5142             com.google.protobuf.ByteString.copyFromUtf8(
5143                 (java.lang.String) ref);
5144         name_ = b;
5145         return b;
5146       } else {
5147         return (com.google.protobuf.ByteString) ref;
5148       }
5149     }
5150
5151     // optional string value = 2;
5152     public static final int VALUE_FIELD_NUMBER = 2;
5153     private java.lang.Object value_;
5154     /**
5155      * <code>optional string value = 2;</code>
5156      */
5157     public boolean hasValue() {
5158       return ((bitField0_ & 0x00000002) == 0x00000002);
5159     }
5160     /**
5161      * <code>optional string value = 2;</code>
5162      */
5163     public java.lang.String getValue() {
5164       java.lang.Object ref = value_;
5165       if (ref instanceof java.lang.String) {
5166         return (java.lang.String) ref;
5167       } else {
5168         com.google.protobuf.ByteString bs =
5169             (com.google.protobuf.ByteString) ref;
5170         java.lang.String s = bs.toStringUtf8();
5171         if (bs.isValidUtf8()) {
5172           value_ = s;
5173         }
5174         return s;
5175       }
5176     }
5177     /**
5178      * <code>optional string value = 2;</code>
5179      */
5180     public com.google.protobuf.ByteString
5181         getValueBytes() {
5182       java.lang.Object ref = value_;
5183       if (ref instanceof java.lang.String) {
5184         com.google.protobuf.ByteString b =
5185             com.google.protobuf.ByteString.copyFromUtf8(
5186                 (java.lang.String) ref);
5187         value_ = b;
5188         return b;
5189       } else {
5190         return (com.google.protobuf.ByteString) ref;
5191       }
5192     }
5193
5194     // optional bool event = 3;
5195     public static final int EVENT_FIELD_NUMBER = 3;
5196     private boolean event_;
5197     /**
5198      * <code>optional bool event = 3;</code>
5199      */
5200     public boolean hasEvent() {
5201       return ((bitField0_ & 0x00000004) == 0x00000004);
5202     }
5203     /**
5204      * <code>optional bool event = 3;</code>
5205      */
5206     public boolean getEvent() {
5207       return event_;
5208     }
5209
5210     private void initFields() {
5211       name_ = "";
5212       value_ = "";
5213       event_ = false;
5214     }
5215     private byte memoizedIsInitialized = -1;
5216     public final boolean isInitialized() {
5217       byte isInitialized = memoizedIsInitialized;
5218       if (isInitialized != -1) return isInitialized == 1;
5219
5220       memoizedIsInitialized = 1;
5221       return true;
5222     }
5223
5224     public void writeTo(com.google.protobuf.CodedOutputStream output)
5225                         throws java.io.IOException {
5226       getSerializedSize();
5227       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5228         output.writeBytes(1, getNameBytes());
5229       }
5230       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5231         output.writeBytes(2, getValueBytes());
5232       }
5233       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5234         output.writeBool(3, event_);
5235       }
5236       getUnknownFields().writeTo(output);
5237     }
5238
5239     private int memoizedSerializedSize = -1;
5240     public int getSerializedSize() {
5241       int size = memoizedSerializedSize;
5242       if (size != -1) return size;
5243
5244       size = 0;
5245       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5246         size += com.google.protobuf.CodedOutputStream
5247           .computeBytesSize(1, getNameBytes());
5248       }
5249       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5250         size += com.google.protobuf.CodedOutputStream
5251           .computeBytesSize(2, getValueBytes());
5252       }
5253       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5254         size += com.google.protobuf.CodedOutputStream
5255           .computeBoolSize(3, event_);
5256       }
5257       size += getUnknownFields().getSerializedSize();
5258       memoizedSerializedSize = size;
5259       return size;
5260     }
5261
5262     private static final long serialVersionUID = 0L;
5263     @java.lang.Override
5264     protected java.lang.Object writeReplace()
5265         throws java.io.ObjectStreamException {
5266       return super.writeReplace();
5267     }
5268
5269     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5270         com.google.protobuf.ByteString data)
5271         throws com.google.protobuf.InvalidProtocolBufferException {
5272       return PARSER.parseFrom(data);
5273     }
5274     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5275         com.google.protobuf.ByteString data,
5276         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5277         throws com.google.protobuf.InvalidProtocolBufferException {
5278       return PARSER.parseFrom(data, extensionRegistry);
5279     }
5280     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(byte[] data)
5281         throws com.google.protobuf.InvalidProtocolBufferException {
5282       return PARSER.parseFrom(data);
5283     }
5284     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5285         byte[] data,
5286         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5287         throws com.google.protobuf.InvalidProtocolBufferException {
5288       return PARSER.parseFrom(data, extensionRegistry);
5289     }
5290     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(java.io.InputStream input)
5291         throws java.io.IOException {
5292       return PARSER.parseFrom(input);
5293     }
5294     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5295         java.io.InputStream input,
5296         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5297         throws java.io.IOException {
5298       return PARSER.parseFrom(input, extensionRegistry);
5299     }
5300     public static com.openxc.BinaryMessages.EventedBooleanMessage parseDelimitedFrom(java.io.InputStream input)
5301         throws java.io.IOException {
5302       return PARSER.parseDelimitedFrom(input);
5303     }
5304     public static com.openxc.BinaryMessages.EventedBooleanMessage parseDelimitedFrom(
5305         java.io.InputStream input,
5306         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5307         throws java.io.IOException {
5308       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5309     }
5310     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5311         com.google.protobuf.CodedInputStream input)
5312         throws java.io.IOException {
5313       return PARSER.parseFrom(input);
5314     }
5315     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5316         com.google.protobuf.CodedInputStream input,
5317         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5318         throws java.io.IOException {
5319       return PARSER.parseFrom(input, extensionRegistry);
5320     }
5321
5322     public static Builder newBuilder() { return Builder.create(); }
5323     public Builder newBuilderForType() { return newBuilder(); }
5324     public static Builder newBuilder(com.openxc.BinaryMessages.EventedBooleanMessage prototype) {
5325       return newBuilder().mergeFrom(prototype);
5326     }
5327     public Builder toBuilder() { return newBuilder(this); }
5328
5329     @java.lang.Override
5330     protected Builder newBuilderForType(
5331         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5332       Builder builder = new Builder(parent);
5333       return builder;
5334     }
5335     /**
5336      * Protobuf type {@code openxc.EventedBooleanMessage}
5337      */
5338     public static final class Builder extends
5339         com.google.protobuf.GeneratedMessage.Builder<Builder>
5340        implements com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder {
5341       public static final com.google.protobuf.Descriptors.Descriptor
5342           getDescriptor() {
5343         return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_descriptor;
5344       }
5345
5346       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5347           internalGetFieldAccessorTable() {
5348         return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_fieldAccessorTable
5349             .ensureFieldAccessorsInitialized(
5350                 com.openxc.BinaryMessages.EventedBooleanMessage.class, com.openxc.BinaryMessages.EventedBooleanMessage.Builder.class);
5351       }
5352
5353       // Construct using com.openxc.BinaryMessages.EventedBooleanMessage.newBuilder()
5354       private Builder() {
5355         maybeForceBuilderInitialization();
5356       }
5357
5358       private Builder(
5359           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5360         super(parent);
5361         maybeForceBuilderInitialization();
5362       }
5363       private void maybeForceBuilderInitialization() {
5364         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5365         }
5366       }
5367       private static Builder create() {
5368         return new Builder();
5369       }
5370
5371       public Builder clear() {
5372         super.clear();
5373         name_ = "";
5374         bitField0_ = (bitField0_ & ~0x00000001);
5375         value_ = "";
5376         bitField0_ = (bitField0_ & ~0x00000002);
5377         event_ = false;
5378         bitField0_ = (bitField0_ & ~0x00000004);
5379         return this;
5380       }
5381
5382       public Builder clone() {
5383         return create().mergeFrom(buildPartial());
5384       }
5385
5386       public com.google.protobuf.Descriptors.Descriptor
5387           getDescriptorForType() {
5388         return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_descriptor;
5389       }
5390
5391       public com.openxc.BinaryMessages.EventedBooleanMessage getDefaultInstanceForType() {
5392         return com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance();
5393       }
5394
5395       public com.openxc.BinaryMessages.EventedBooleanMessage build() {
5396         com.openxc.BinaryMessages.EventedBooleanMessage result = buildPartial();
5397         if (!result.isInitialized()) {
5398           throw newUninitializedMessageException(result);
5399         }
5400         return result;
5401       }
5402
5403       public com.openxc.BinaryMessages.EventedBooleanMessage buildPartial() {
5404         com.openxc.BinaryMessages.EventedBooleanMessage result = new com.openxc.BinaryMessages.EventedBooleanMessage(this);
5405         int from_bitField0_ = bitField0_;
5406         int to_bitField0_ = 0;
5407         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5408           to_bitField0_ |= 0x00000001;
5409         }
5410         result.name_ = name_;
5411         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5412           to_bitField0_ |= 0x00000002;
5413         }
5414         result.value_ = value_;
5415         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5416           to_bitField0_ |= 0x00000004;
5417         }
5418         result.event_ = event_;
5419         result.bitField0_ = to_bitField0_;
5420         onBuilt();
5421         return result;
5422       }
5423
5424       public Builder mergeFrom(com.google.protobuf.Message other) {
5425         if (other instanceof com.openxc.BinaryMessages.EventedBooleanMessage) {
5426           return mergeFrom((com.openxc.BinaryMessages.EventedBooleanMessage)other);
5427         } else {
5428           super.mergeFrom(other);
5429           return this;
5430         }
5431       }
5432
5433       public Builder mergeFrom(com.openxc.BinaryMessages.EventedBooleanMessage other) {
5434         if (other == com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance()) return this;
5435         if (other.hasName()) {
5436           bitField0_ |= 0x00000001;
5437           name_ = other.name_;
5438           onChanged();
5439         }
5440         if (other.hasValue()) {
5441           bitField0_ |= 0x00000002;
5442           value_ = other.value_;
5443           onChanged();
5444         }
5445         if (other.hasEvent()) {
5446           setEvent(other.getEvent());
5447         }
5448         this.mergeUnknownFields(other.getUnknownFields());
5449         return this;
5450       }
5451
5452       public final boolean isInitialized() {
5453         return true;
5454       }
5455
5456       public Builder mergeFrom(
5457           com.google.protobuf.CodedInputStream input,
5458           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5459           throws java.io.IOException {
5460         com.openxc.BinaryMessages.EventedBooleanMessage parsedMessage = null;
5461         try {
5462           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5463         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5464           parsedMessage = (com.openxc.BinaryMessages.EventedBooleanMessage) e.getUnfinishedMessage();
5465           throw e;
5466         } finally {
5467           if (parsedMessage != null) {
5468             mergeFrom(parsedMessage);
5469           }
5470         }
5471         return this;
5472       }
5473       private int bitField0_;
5474
5475       // optional string name = 1;
5476       private java.lang.Object name_ = "";
5477       /**
5478        * <code>optional string name = 1;</code>
5479        */
5480       public boolean hasName() {
5481         return ((bitField0_ & 0x00000001) == 0x00000001);
5482       }
5483       /**
5484        * <code>optional string name = 1;</code>
5485        */
5486       public java.lang.String getName() {
5487         java.lang.Object ref = name_;
5488         if (!(ref instanceof java.lang.String)) {
5489           java.lang.String s = ((com.google.protobuf.ByteString) ref)
5490               .toStringUtf8();
5491           name_ = s;
5492           return s;
5493         } else {
5494           return (java.lang.String) ref;
5495         }
5496       }
5497       /**
5498        * <code>optional string name = 1;</code>
5499        */
5500       public com.google.protobuf.ByteString
5501           getNameBytes() {
5502         java.lang.Object ref = name_;
5503         if (ref instanceof String) {
5504           com.google.protobuf.ByteString b =
5505               com.google.protobuf.ByteString.copyFromUtf8(
5506                   (java.lang.String) ref);
5507           name_ = b;
5508           return b;
5509         } else {
5510           return (com.google.protobuf.ByteString) ref;
5511         }
5512       }
5513       /**
5514        * <code>optional string name = 1;</code>
5515        */
5516       public Builder setName(
5517           java.lang.String value) {
5518         if (value == null) {
5519     throw new NullPointerException();
5520   }
5521   bitField0_ |= 0x00000001;
5522         name_ = value;
5523         onChanged();
5524         return this;
5525       }
5526       /**
5527        * <code>optional string name = 1;</code>
5528        */
5529       public Builder clearName() {
5530         bitField0_ = (bitField0_ & ~0x00000001);
5531         name_ = getDefaultInstance().getName();
5532         onChanged();
5533         return this;
5534       }
5535       /**
5536        * <code>optional string name = 1;</code>
5537        */
5538       public Builder setNameBytes(
5539           com.google.protobuf.ByteString value) {
5540         if (value == null) {
5541     throw new NullPointerException();
5542   }
5543   bitField0_ |= 0x00000001;
5544         name_ = value;
5545         onChanged();
5546         return this;
5547       }
5548
5549       // optional string value = 2;
5550       private java.lang.Object value_ = "";
5551       /**
5552        * <code>optional string value = 2;</code>
5553        */
5554       public boolean hasValue() {
5555         return ((bitField0_ & 0x00000002) == 0x00000002);
5556       }
5557       /**
5558        * <code>optional string value = 2;</code>
5559        */
5560       public java.lang.String getValue() {
5561         java.lang.Object ref = value_;
5562         if (!(ref instanceof java.lang.String)) {
5563           java.lang.String s = ((com.google.protobuf.ByteString) ref)
5564               .toStringUtf8();
5565           value_ = s;
5566           return s;
5567         } else {
5568           return (java.lang.String) ref;
5569         }
5570       }
5571       /**
5572        * <code>optional string value = 2;</code>
5573        */
5574       public com.google.protobuf.ByteString
5575           getValueBytes() {
5576         java.lang.Object ref = value_;
5577         if (ref instanceof String) {
5578           com.google.protobuf.ByteString b =
5579               com.google.protobuf.ByteString.copyFromUtf8(
5580                   (java.lang.String) ref);
5581           value_ = b;
5582           return b;
5583         } else {
5584           return (com.google.protobuf.ByteString) ref;
5585         }
5586       }
5587       /**
5588        * <code>optional string value = 2;</code>
5589        */
5590       public Builder setValue(
5591           java.lang.String value) {
5592         if (value == null) {
5593     throw new NullPointerException();
5594   }
5595   bitField0_ |= 0x00000002;
5596         value_ = value;
5597         onChanged();
5598         return this;
5599       }
5600       /**
5601        * <code>optional string value = 2;</code>
5602        */
5603       public Builder clearValue() {
5604         bitField0_ = (bitField0_ & ~0x00000002);
5605         value_ = getDefaultInstance().getValue();
5606         onChanged();
5607         return this;
5608       }
5609       /**
5610        * <code>optional string value = 2;</code>
5611        */
5612       public Builder setValueBytes(
5613           com.google.protobuf.ByteString value) {
5614         if (value == null) {
5615     throw new NullPointerException();
5616   }
5617   bitField0_ |= 0x00000002;
5618         value_ = value;
5619         onChanged();
5620         return this;
5621       }
5622
5623       // optional bool event = 3;
5624       private boolean event_ ;
5625       /**
5626        * <code>optional bool event = 3;</code>
5627        */
5628       public boolean hasEvent() {
5629         return ((bitField0_ & 0x00000004) == 0x00000004);
5630       }
5631       /**
5632        * <code>optional bool event = 3;</code>
5633        */
5634       public boolean getEvent() {
5635         return event_;
5636       }
5637       /**
5638        * <code>optional bool event = 3;</code>
5639        */
5640       public Builder setEvent(boolean value) {
5641         bitField0_ |= 0x00000004;
5642         event_ = value;
5643         onChanged();
5644         return this;
5645       }
5646       /**
5647        * <code>optional bool event = 3;</code>
5648        */
5649       public Builder clearEvent() {
5650         bitField0_ = (bitField0_ & ~0x00000004);
5651         event_ = false;
5652         onChanged();
5653         return this;
5654       }
5655
5656       // @@protoc_insertion_point(builder_scope:openxc.EventedBooleanMessage)
5657     }
5658
5659     static {
5660       defaultInstance = new EventedBooleanMessage(true);
5661       defaultInstance.initFields();
5662     }
5663
5664     // @@protoc_insertion_point(class_scope:openxc.EventedBooleanMessage)
5665   }
5666
5667   public interface EventedNumericMessageOrBuilder
5668       extends com.google.protobuf.MessageOrBuilder {
5669
5670     // optional string name = 1;
5671     /**
5672      * <code>optional string name = 1;</code>
5673      */
5674     boolean hasName();
5675     /**
5676      * <code>optional string name = 1;</code>
5677      */
5678     java.lang.String getName();
5679     /**
5680      * <code>optional string name = 1;</code>
5681      */
5682     com.google.protobuf.ByteString
5683         getNameBytes();
5684
5685     // optional string value = 2;
5686     /**
5687      * <code>optional string value = 2;</code>
5688      */
5689     boolean hasValue();
5690     /**
5691      * <code>optional string value = 2;</code>
5692      */
5693     java.lang.String getValue();
5694     /**
5695      * <code>optional string value = 2;</code>
5696      */
5697     com.google.protobuf.ByteString
5698         getValueBytes();
5699
5700     // optional double event = 3;
5701     /**
5702      * <code>optional double event = 3;</code>
5703      */
5704     boolean hasEvent();
5705     /**
5706      * <code>optional double event = 3;</code>
5707      */
5708     double getEvent();
5709   }
5710   /**
5711    * Protobuf type {@code openxc.EventedNumericMessage}
5712    */
5713   public static final class EventedNumericMessage extends
5714       com.google.protobuf.GeneratedMessage
5715       implements EventedNumericMessageOrBuilder {
5716     // Use EventedNumericMessage.newBuilder() to construct.
5717     private EventedNumericMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5718       super(builder);
5719       this.unknownFields = builder.getUnknownFields();
5720     }
5721     private EventedNumericMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5722
5723     private static final EventedNumericMessage defaultInstance;
5724     public static EventedNumericMessage getDefaultInstance() {
5725       return defaultInstance;
5726     }
5727
5728     public EventedNumericMessage getDefaultInstanceForType() {
5729       return defaultInstance;
5730     }
5731
5732     private final com.google.protobuf.UnknownFieldSet unknownFields;
5733     @java.lang.Override
5734     public final com.google.protobuf.UnknownFieldSet
5735         getUnknownFields() {
5736       return this.unknownFields;
5737     }
5738     private EventedNumericMessage(
5739         com.google.protobuf.CodedInputStream input,
5740         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5741         throws com.google.protobuf.InvalidProtocolBufferException {
5742       initFields();
5743       int mutable_bitField0_ = 0;
5744       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5745           com.google.protobuf.UnknownFieldSet.newBuilder();
5746       try {
5747         boolean done = false;
5748         while (!done) {
5749           int tag = input.readTag();
5750           switch (tag) {
5751             case 0:
5752               done = true;
5753               break;
5754             default: {
5755               if (!parseUnknownField(input, unknownFields,
5756                                      extensionRegistry, tag)) {
5757                 done = true;
5758               }
5759               break;
5760             }
5761             case 10: {
5762               bitField0_ |= 0x00000001;
5763               name_ = input.readBytes();
5764               break;
5765             }
5766             case 18: {
5767               bitField0_ |= 0x00000002;
5768               value_ = input.readBytes();
5769               break;
5770             }
5771             case 25: {
5772               bitField0_ |= 0x00000004;
5773               event_ = input.readDouble();
5774               break;
5775             }
5776           }
5777         }
5778       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5779         throw e.setUnfinishedMessage(this);
5780       } catch (java.io.IOException e) {
5781         throw new com.google.protobuf.InvalidProtocolBufferException(
5782             e.getMessage()).setUnfinishedMessage(this);
5783       } finally {
5784         this.unknownFields = unknownFields.build();
5785         makeExtensionsImmutable();
5786       }
5787     }
5788     public static final com.google.protobuf.Descriptors.Descriptor
5789         getDescriptor() {
5790       return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_descriptor;
5791     }
5792
5793     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5794         internalGetFieldAccessorTable() {
5795       return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_fieldAccessorTable
5796           .ensureFieldAccessorsInitialized(
5797               com.openxc.BinaryMessages.EventedNumericMessage.class, com.openxc.BinaryMessages.EventedNumericMessage.Builder.class);
5798     }
5799
5800     public static com.google.protobuf.Parser<EventedNumericMessage> PARSER =
5801         new com.google.protobuf.AbstractParser<EventedNumericMessage>() {
5802       public EventedNumericMessage parsePartialFrom(
5803           com.google.protobuf.CodedInputStream input,
5804           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5805           throws com.google.protobuf.InvalidProtocolBufferException {
5806         return new EventedNumericMessage(input, extensionRegistry);
5807       }
5808     };
5809
5810     @java.lang.Override
5811     public com.google.protobuf.Parser<EventedNumericMessage> getParserForType() {
5812       return PARSER;
5813     }
5814
5815     private int bitField0_;
5816     // optional string name = 1;
5817     public static final int NAME_FIELD_NUMBER = 1;
5818     private java.lang.Object name_;
5819     /**
5820      * <code>optional string name = 1;</code>
5821      */
5822     public boolean hasName() {
5823       return ((bitField0_ & 0x00000001) == 0x00000001);
5824     }
5825     /**
5826      * <code>optional string name = 1;</code>
5827      */
5828     public java.lang.String getName() {
5829       java.lang.Object ref = name_;
5830       if (ref instanceof java.lang.String) {
5831         return (java.lang.String) ref;
5832       } else {
5833         com.google.protobuf.ByteString bs =
5834             (com.google.protobuf.ByteString) ref;
5835         java.lang.String s = bs.toStringUtf8();
5836         if (bs.isValidUtf8()) {
5837           name_ = s;
5838         }
5839         return s;
5840       }
5841     }
5842     /**
5843      * <code>optional string name = 1;</code>
5844      */
5845     public com.google.protobuf.ByteString
5846         getNameBytes() {
5847       java.lang.Object ref = name_;
5848       if (ref instanceof java.lang.String) {
5849         com.google.protobuf.ByteString b =
5850             com.google.protobuf.ByteString.copyFromUtf8(
5851                 (java.lang.String) ref);
5852         name_ = b;
5853         return b;
5854       } else {
5855         return (com.google.protobuf.ByteString) ref;
5856       }
5857     }
5858
5859     // optional string value = 2;
5860     public static final int VALUE_FIELD_NUMBER = 2;
5861     private java.lang.Object value_;
5862     /**
5863      * <code>optional string value = 2;</code>
5864      */
5865     public boolean hasValue() {
5866       return ((bitField0_ & 0x00000002) == 0x00000002);
5867     }
5868     /**
5869      * <code>optional string value = 2;</code>
5870      */
5871     public java.lang.String getValue() {
5872       java.lang.Object ref = value_;
5873       if (ref instanceof java.lang.String) {
5874         return (java.lang.String) ref;
5875       } else {
5876         com.google.protobuf.ByteString bs =
5877             (com.google.protobuf.ByteString) ref;
5878         java.lang.String s = bs.toStringUtf8();
5879         if (bs.isValidUtf8()) {
5880           value_ = s;
5881         }
5882         return s;
5883       }
5884     }
5885     /**
5886      * <code>optional string value = 2;</code>
5887      */
5888     public com.google.protobuf.ByteString
5889         getValueBytes() {
5890       java.lang.Object ref = value_;
5891       if (ref instanceof java.lang.String) {
5892         com.google.protobuf.ByteString b =
5893             com.google.protobuf.ByteString.copyFromUtf8(
5894                 (java.lang.String) ref);
5895         value_ = b;
5896         return b;
5897       } else {
5898         return (com.google.protobuf.ByteString) ref;
5899       }
5900     }
5901
5902     // optional double event = 3;
5903     public static final int EVENT_FIELD_NUMBER = 3;
5904     private double event_;
5905     /**
5906      * <code>optional double event = 3;</code>
5907      */
5908     public boolean hasEvent() {
5909       return ((bitField0_ & 0x00000004) == 0x00000004);
5910     }
5911     /**
5912      * <code>optional double event = 3;</code>
5913      */
5914     public double getEvent() {
5915       return event_;
5916     }
5917
5918     private void initFields() {
5919       name_ = "";
5920       value_ = "";
5921       event_ = 0D;
5922     }
5923     private byte memoizedIsInitialized = -1;
5924     public final boolean isInitialized() {
5925       byte isInitialized = memoizedIsInitialized;
5926       if (isInitialized != -1) return isInitialized == 1;
5927
5928       memoizedIsInitialized = 1;
5929       return true;
5930     }
5931
5932     public void writeTo(com.google.protobuf.CodedOutputStream output)
5933                         throws java.io.IOException {
5934       getSerializedSize();
5935       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5936         output.writeBytes(1, getNameBytes());
5937       }
5938       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5939         output.writeBytes(2, getValueBytes());
5940       }
5941       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5942         output.writeDouble(3, event_);
5943       }
5944       getUnknownFields().writeTo(output);
5945     }
5946
5947     private int memoizedSerializedSize = -1;
5948     public int getSerializedSize() {
5949       int size = memoizedSerializedSize;
5950       if (size != -1) return size;
5951
5952       size = 0;
5953       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5954         size += com.google.protobuf.CodedOutputStream
5955           .computeBytesSize(1, getNameBytes());
5956       }
5957       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5958         size += com.google.protobuf.CodedOutputStream
5959           .computeBytesSize(2, getValueBytes());
5960       }
5961       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5962         size += com.google.protobuf.CodedOutputStream
5963           .computeDoubleSize(3, event_);
5964       }
5965       size += getUnknownFields().getSerializedSize();
5966       memoizedSerializedSize = size;
5967       return size;
5968     }
5969
5970     private static final long serialVersionUID = 0L;
5971     @java.lang.Override
5972     protected java.lang.Object writeReplace()
5973         throws java.io.ObjectStreamException {
5974       return super.writeReplace();
5975     }
5976
5977     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5978         com.google.protobuf.ByteString data)
5979         throws com.google.protobuf.InvalidProtocolBufferException {
5980       return PARSER.parseFrom(data);
5981     }
5982     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5983         com.google.protobuf.ByteString data,
5984         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5985         throws com.google.protobuf.InvalidProtocolBufferException {
5986       return PARSER.parseFrom(data, extensionRegistry);
5987     }
5988     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(byte[] data)
5989         throws com.google.protobuf.InvalidProtocolBufferException {
5990       return PARSER.parseFrom(data);
5991     }
5992     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5993         byte[] data,
5994         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5995         throws com.google.protobuf.InvalidProtocolBufferException {
5996       return PARSER.parseFrom(data, extensionRegistry);
5997     }
5998     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(java.io.InputStream input)
5999         throws java.io.IOException {
6000       return PARSER.parseFrom(input);
6001     }
6002     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
6003         java.io.InputStream input,
6004         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6005         throws java.io.IOException {
6006       return PARSER.parseFrom(input, extensionRegistry);
6007     }
6008     public static com.openxc.BinaryMessages.EventedNumericMessage parseDelimitedFrom(java.io.InputStream input)
6009         throws java.io.IOException {
6010       return PARSER.parseDelimitedFrom(input);
6011     }
6012     public static com.openxc.BinaryMessages.EventedNumericMessage parseDelimitedFrom(
6013         java.io.InputStream input,
6014         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6015         throws java.io.IOException {
6016       return PARSER.parseDelimitedFrom(input, extensionRegistry);
6017     }
6018     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
6019         com.google.protobuf.CodedInputStream input)
6020         throws java.io.IOException {
6021       return PARSER.parseFrom(input);
6022     }
6023     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
6024         com.google.protobuf.CodedInputStream input,
6025         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6026         throws java.io.IOException {
6027       return PARSER.parseFrom(input, extensionRegistry);
6028     }
6029
6030     public static Builder newBuilder() { return Builder.create(); }
6031     public Builder newBuilderForType() { return newBuilder(); }
6032     public static Builder newBuilder(com.openxc.BinaryMessages.EventedNumericMessage prototype) {
6033       return newBuilder().mergeFrom(prototype);
6034     }
6035     public Builder toBuilder() { return newBuilder(this); }
6036
6037     @java.lang.Override
6038     protected Builder newBuilderForType(
6039         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6040       Builder builder = new Builder(parent);
6041       return builder;
6042     }
6043     /**
6044      * Protobuf type {@code openxc.EventedNumericMessage}
6045      */
6046     public static final class Builder extends
6047         com.google.protobuf.GeneratedMessage.Builder<Builder>
6048        implements com.openxc.BinaryMessages.EventedNumericMessageOrBuilder {
6049       public static final com.google.protobuf.Descriptors.Descriptor
6050           getDescriptor() {
6051         return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_descriptor;
6052       }
6053
6054       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
6055           internalGetFieldAccessorTable() {
6056         return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_fieldAccessorTable
6057             .ensureFieldAccessorsInitialized(
6058                 com.openxc.BinaryMessages.EventedNumericMessage.class, com.openxc.BinaryMessages.EventedNumericMessage.Builder.class);
6059       }
6060
6061       // Construct using com.openxc.BinaryMessages.EventedNumericMessage.newBuilder()
6062       private Builder() {
6063         maybeForceBuilderInitialization();
6064       }
6065
6066       private Builder(
6067           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
6068         super(parent);
6069         maybeForceBuilderInitialization();
6070       }
6071       private void maybeForceBuilderInitialization() {
6072         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
6073         }
6074       }
6075       private static Builder create() {
6076         return new Builder();
6077       }
6078
6079       public Builder clear() {
6080         super.clear();
6081         name_ = "";
6082         bitField0_ = (bitField0_ & ~0x00000001);
6083         value_ = "";
6084         bitField0_ = (bitField0_ & ~0x00000002);
6085         event_ = 0D;
6086         bitField0_ = (bitField0_ & ~0x00000004);
6087         return this;
6088       }
6089
6090       public Builder clone() {
6091         return create().mergeFrom(buildPartial());
6092       }
6093
6094       public com.google.protobuf.Descriptors.Descriptor
6095           getDescriptorForType() {
6096         return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_descriptor;
6097       }
6098
6099       public com.openxc.BinaryMessages.EventedNumericMessage getDefaultInstanceForType() {
6100         return com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance();
6101       }
6102
6103       public com.openxc.BinaryMessages.EventedNumericMessage build() {
6104         com.openxc.BinaryMessages.EventedNumericMessage result = buildPartial();
6105         if (!result.isInitialized()) {
6106           throw newUninitializedMessageException(result);
6107         }
6108         return result;
6109       }
6110
6111       public com.openxc.BinaryMessages.EventedNumericMessage buildPartial() {
6112         com.openxc.BinaryMessages.EventedNumericMessage result = new com.openxc.BinaryMessages.EventedNumericMessage(this);
6113         int from_bitField0_ = bitField0_;
6114         int to_bitField0_ = 0;
6115         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6116           to_bitField0_ |= 0x00000001;
6117         }
6118         result.name_ = name_;
6119         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6120           to_bitField0_ |= 0x00000002;
6121         }
6122         result.value_ = value_;
6123         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6124           to_bitField0_ |= 0x00000004;
6125         }
6126         result.event_ = event_;
6127         result.bitField0_ = to_bitField0_;
6128         onBuilt();
6129         return result;
6130       }
6131
6132       public Builder mergeFrom(com.google.protobuf.Message other) {
6133         if (other instanceof com.openxc.BinaryMessages.EventedNumericMessage) {
6134           return mergeFrom((com.openxc.BinaryMessages.EventedNumericMessage)other);
6135         } else {
6136           super.mergeFrom(other);
6137           return this;
6138         }
6139       }
6140
6141       public Builder mergeFrom(com.openxc.BinaryMessages.EventedNumericMessage other) {
6142         if (other == com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance()) return this;
6143         if (other.hasName()) {
6144           bitField0_ |= 0x00000001;
6145           name_ = other.name_;
6146           onChanged();
6147         }
6148         if (other.hasValue()) {
6149           bitField0_ |= 0x00000002;
6150           value_ = other.value_;
6151           onChanged();
6152         }
6153         if (other.hasEvent()) {
6154           setEvent(other.getEvent());
6155         }
6156         this.mergeUnknownFields(other.getUnknownFields());
6157         return this;
6158       }
6159
6160       public final boolean isInitialized() {
6161         return true;
6162       }
6163
6164       public Builder mergeFrom(
6165           com.google.protobuf.CodedInputStream input,
6166           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6167           throws java.io.IOException {
6168         com.openxc.BinaryMessages.EventedNumericMessage parsedMessage = null;
6169         try {
6170           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6171         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6172           parsedMessage = (com.openxc.BinaryMessages.EventedNumericMessage) e.getUnfinishedMessage();
6173           throw e;
6174         } finally {
6175           if (parsedMessage != null) {
6176             mergeFrom(parsedMessage);
6177           }
6178         }
6179         return this;
6180       }
6181       private int bitField0_;
6182
6183       // optional string name = 1;
6184       private java.lang.Object name_ = "";
6185       /**
6186        * <code>optional string name = 1;</code>
6187        */
6188       public boolean hasName() {
6189         return ((bitField0_ & 0x00000001) == 0x00000001);
6190       }
6191       /**
6192        * <code>optional string name = 1;</code>
6193        */
6194       public java.lang.String getName() {
6195         java.lang.Object ref = name_;
6196         if (!(ref instanceof java.lang.String)) {
6197           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6198               .toStringUtf8();
6199           name_ = s;
6200           return s;
6201         } else {
6202           return (java.lang.String) ref;
6203         }
6204       }
6205       /**
6206        * <code>optional string name = 1;</code>
6207        */
6208       public com.google.protobuf.ByteString
6209           getNameBytes() {
6210         java.lang.Object ref = name_;
6211         if (ref instanceof String) {
6212           com.google.protobuf.ByteString b =
6213               com.google.protobuf.ByteString.copyFromUtf8(
6214                   (java.lang.String) ref);
6215           name_ = b;
6216           return b;
6217         } else {
6218           return (com.google.protobuf.ByteString) ref;
6219         }
6220       }
6221       /**
6222        * <code>optional string name = 1;</code>
6223        */
6224       public Builder setName(
6225           java.lang.String value) {
6226         if (value == null) {
6227     throw new NullPointerException();
6228   }
6229   bitField0_ |= 0x00000001;
6230         name_ = value;
6231         onChanged();
6232         return this;
6233       }
6234       /**
6235        * <code>optional string name = 1;</code>
6236        */
6237       public Builder clearName() {
6238         bitField0_ = (bitField0_ & ~0x00000001);
6239         name_ = getDefaultInstance().getName();
6240         onChanged();
6241         return this;
6242       }
6243       /**
6244        * <code>optional string name = 1;</code>
6245        */
6246       public Builder setNameBytes(
6247           com.google.protobuf.ByteString value) {
6248         if (value == null) {
6249     throw new NullPointerException();
6250   }
6251   bitField0_ |= 0x00000001;
6252         name_ = value;
6253         onChanged();
6254         return this;
6255       }
6256
6257       // optional string value = 2;
6258       private java.lang.Object value_ = "";
6259       /**
6260        * <code>optional string value = 2;</code>
6261        */
6262       public boolean hasValue() {
6263         return ((bitField0_ & 0x00000002) == 0x00000002);
6264       }
6265       /**
6266        * <code>optional string value = 2;</code>
6267        */
6268       public java.lang.String getValue() {
6269         java.lang.Object ref = value_;
6270         if (!(ref instanceof java.lang.String)) {
6271           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6272               .toStringUtf8();
6273           value_ = s;
6274           return s;
6275         } else {
6276           return (java.lang.String) ref;
6277         }
6278       }
6279       /**
6280        * <code>optional string value = 2;</code>
6281        */
6282       public com.google.protobuf.ByteString
6283           getValueBytes() {
6284         java.lang.Object ref = value_;
6285         if (ref instanceof String) {
6286           com.google.protobuf.ByteString b =
6287               com.google.protobuf.ByteString.copyFromUtf8(
6288                   (java.lang.String) ref);
6289           value_ = b;
6290           return b;
6291         } else {
6292           return (com.google.protobuf.ByteString) ref;
6293         }
6294       }
6295       /**
6296        * <code>optional string value = 2;</code>
6297        */
6298       public Builder setValue(
6299           java.lang.String value) {
6300         if (value == null) {
6301     throw new NullPointerException();
6302   }
6303   bitField0_ |= 0x00000002;
6304         value_ = value;
6305         onChanged();
6306         return this;
6307       }
6308       /**
6309        * <code>optional string value = 2;</code>
6310        */
6311       public Builder clearValue() {
6312         bitField0_ = (bitField0_ & ~0x00000002);
6313         value_ = getDefaultInstance().getValue();
6314         onChanged();
6315         return this;
6316       }
6317       /**
6318        * <code>optional string value = 2;</code>
6319        */
6320       public Builder setValueBytes(
6321           com.google.protobuf.ByteString value) {
6322         if (value == null) {
6323     throw new NullPointerException();
6324   }
6325   bitField0_ |= 0x00000002;
6326         value_ = value;
6327         onChanged();
6328         return this;
6329       }
6330
6331       // optional double event = 3;
6332       private double event_ ;
6333       /**
6334        * <code>optional double event = 3;</code>
6335        */
6336       public boolean hasEvent() {
6337         return ((bitField0_ & 0x00000004) == 0x00000004);
6338       }
6339       /**
6340        * <code>optional double event = 3;</code>
6341        */
6342       public double getEvent() {
6343         return event_;
6344       }
6345       /**
6346        * <code>optional double event = 3;</code>
6347        */
6348       public Builder setEvent(double value) {
6349         bitField0_ |= 0x00000004;
6350         event_ = value;
6351         onChanged();
6352         return this;
6353       }
6354       /**
6355        * <code>optional double event = 3;</code>
6356        */
6357       public Builder clearEvent() {
6358         bitField0_ = (bitField0_ & ~0x00000004);
6359         event_ = 0D;
6360         onChanged();
6361         return this;
6362       }
6363
6364       // @@protoc_insertion_point(builder_scope:openxc.EventedNumericMessage)
6365     }
6366
6367     static {
6368       defaultInstance = new EventedNumericMessage(true);
6369       defaultInstance.initFields();
6370     }
6371
6372     // @@protoc_insertion_point(class_scope:openxc.EventedNumericMessage)
6373   }
6374
6375   private static com.google.protobuf.Descriptors.Descriptor
6376     internal_static_openxc_VehicleMessage_descriptor;
6377   private static
6378     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6379       internal_static_openxc_VehicleMessage_fieldAccessorTable;
6380   private static com.google.protobuf.Descriptors.Descriptor
6381     internal_static_openxc_RawMessage_descriptor;
6382   private static
6383     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6384       internal_static_openxc_RawMessage_fieldAccessorTable;
6385   private static com.google.protobuf.Descriptors.Descriptor
6386     internal_static_openxc_StringMessage_descriptor;
6387   private static
6388     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6389       internal_static_openxc_StringMessage_fieldAccessorTable;
6390   private static com.google.protobuf.Descriptors.Descriptor
6391     internal_static_openxc_NumericMessage_descriptor;
6392   private static
6393     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6394       internal_static_openxc_NumericMessage_fieldAccessorTable;
6395   private static com.google.protobuf.Descriptors.Descriptor
6396     internal_static_openxc_BooleanMessage_descriptor;
6397   private static
6398     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6399       internal_static_openxc_BooleanMessage_fieldAccessorTable;
6400   private static com.google.protobuf.Descriptors.Descriptor
6401     internal_static_openxc_EventedStringMessage_descriptor;
6402   private static
6403     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6404       internal_static_openxc_EventedStringMessage_fieldAccessorTable;
6405   private static com.google.protobuf.Descriptors.Descriptor
6406     internal_static_openxc_EventedBooleanMessage_descriptor;
6407   private static
6408     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6409       internal_static_openxc_EventedBooleanMessage_fieldAccessorTable;
6410   private static com.google.protobuf.Descriptors.Descriptor
6411     internal_static_openxc_EventedNumericMessage_descriptor;
6412   private static
6413     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6414       internal_static_openxc_EventedNumericMessage_fieldAccessorTable;
6415
6416   public static com.google.protobuf.Descriptors.FileDescriptor
6417       getDescriptor() {
6418     return descriptor;
6419   }
6420   private static com.google.protobuf.Descriptors.FileDescriptor
6421       descriptor;
6422   static {
6423     java.lang.String[] descriptorData = {
6424       "\n\014openxc.proto\022\006openxc\"\232\004\n\016VehicleMessag" +
6425       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
6426       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
6427       "ssage\022-\n\016string_message\030\003 \001(\0132\025.openxc.S" +
6428       "tringMessage\022/\n\017numeric_message\030\004 \001(\0132\026." +
6429       "openxc.NumericMessage\022/\n\017boolean_message" +
6430       "\030\005 \001(\0132\026.openxc.BooleanMessage\022<\n\026evente" +
6431       "d_string_message\030\006 \001(\0132\034.openxc.EventedS" +
6432       "tringMessage\022>\n\027evented_boolean_message\030" +
6433       "\007 \001(\0132\035.openxc.EventedBooleanMessage\022>\n\027",
6434       "evented_numeric_message\030\010 \001(\0132\035.openxc.E" +
6435       "ventedNumericMessage\"e\n\004Type\022\007\n\003RAW\020\001\022\n\n" +
6436       "\006STRING\020\002\022\010\n\004BOOL\020\003\022\007\n\003NUM\020\004\022\017\n\013EVENTED_" +
6437       "NUM\020\005\022\022\n\016EVENTED_STRING\020\006\022\020\n\014EVENTED_BOO" +
6438       "L\020\007\";\n\nRawMessage\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessag" +
6439       "e_id\030\002 \001(\r\022\014\n\004data\030\003 \001(\004\",\n\rStringMessag" +
6440       "e\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\"-\n\016Numeri" +
6441       "cMessage\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\001\"-\n" +
6442       "\016BooleanMessage\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002" +
6443       " \001(\010\"B\n\024EventedStringMessage\022\014\n\004name\030\001 \001",
6444       "(\t\022\r\n\005value\030\002 \001(\t\022\r\n\005event\030\003 \001(\t\"C\n\025Even" +
6445       "tedBooleanMessage\022\014\n\004name\030\001 \001(\t\022\r\n\005value" +
6446       "\030\002 \001(\t\022\r\n\005event\030\003 \001(\010\"C\n\025EventedNumericM" +
6447       "essage\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\022\r\n\005e" +
6448       "vent\030\003 \001(\001B\034\n\ncom.openxcB\016BinaryMessages"
6449     };
6450     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
6451       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
6452         public com.google.protobuf.ExtensionRegistry assignDescriptors(
6453             com.google.protobuf.Descriptors.FileDescriptor root) {
6454           descriptor = root;
6455           internal_static_openxc_VehicleMessage_descriptor =
6456             getDescriptor().getMessageTypes().get(0);
6457           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
6458             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6459               internal_static_openxc_VehicleMessage_descriptor,
6460               new java.lang.String[] { "Type", "RawMessage", "StringMessage", "NumericMessage", "BooleanMessage", "EventedStringMessage", "EventedBooleanMessage", "EventedNumericMessage", });
6461           internal_static_openxc_RawMessage_descriptor =
6462             getDescriptor().getMessageTypes().get(1);
6463           internal_static_openxc_RawMessage_fieldAccessorTable = new
6464             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6465               internal_static_openxc_RawMessage_descriptor,
6466               new java.lang.String[] { "Bus", "MessageId", "Data", });
6467           internal_static_openxc_StringMessage_descriptor =
6468             getDescriptor().getMessageTypes().get(2);
6469           internal_static_openxc_StringMessage_fieldAccessorTable = new
6470             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6471               internal_static_openxc_StringMessage_descriptor,
6472               new java.lang.String[] { "Name", "Value", });
6473           internal_static_openxc_NumericMessage_descriptor =
6474             getDescriptor().getMessageTypes().get(3);
6475           internal_static_openxc_NumericMessage_fieldAccessorTable = new
6476             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6477               internal_static_openxc_NumericMessage_descriptor,
6478               new java.lang.String[] { "Name", "Value", });
6479           internal_static_openxc_BooleanMessage_descriptor =
6480             getDescriptor().getMessageTypes().get(4);
6481           internal_static_openxc_BooleanMessage_fieldAccessorTable = new
6482             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6483               internal_static_openxc_BooleanMessage_descriptor,
6484               new java.lang.String[] { "Name", "Value", });
6485           internal_static_openxc_EventedStringMessage_descriptor =
6486             getDescriptor().getMessageTypes().get(5);
6487           internal_static_openxc_EventedStringMessage_fieldAccessorTable = new
6488             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6489               internal_static_openxc_EventedStringMessage_descriptor,
6490               new java.lang.String[] { "Name", "Value", "Event", });
6491           internal_static_openxc_EventedBooleanMessage_descriptor =
6492             getDescriptor().getMessageTypes().get(6);
6493           internal_static_openxc_EventedBooleanMessage_fieldAccessorTable = new
6494             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6495               internal_static_openxc_EventedBooleanMessage_descriptor,
6496               new java.lang.String[] { "Name", "Value", "Event", });
6497           internal_static_openxc_EventedNumericMessage_descriptor =
6498             getDescriptor().getMessageTypes().get(7);
6499           internal_static_openxc_EventedNumericMessage_fieldAccessorTable = new
6500             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6501               internal_static_openxc_EventedNumericMessage_descriptor,
6502               new java.lang.String[] { "Name", "Value", "Event", });
6503           return null;
6504         }
6505       };
6506     com.google.protobuf.Descriptors.FileDescriptor
6507       .internalBuildGeneratedFileFrom(descriptorData,
6508         new com.google.protobuf.Descriptors.FileDescriptor[] {
6509         }, assigner);
6510   }
6511
6512   // @@protoc_insertion_point(outer_class_scope)
6513 }