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   /**
1911    * Protobuf type {@code openxc.RawMessage}
1912    */
1913   public static final class RawMessage extends
1914       com.google.protobuf.GeneratedMessage
1915       implements RawMessageOrBuilder {
1916     // Use RawMessage.newBuilder() to construct.
1917     private RawMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1918       super(builder);
1919       this.unknownFields = builder.getUnknownFields();
1920     }
1921     private RawMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1922
1923     private static final RawMessage defaultInstance;
1924     public static RawMessage getDefaultInstance() {
1925       return defaultInstance;
1926     }
1927
1928     public RawMessage getDefaultInstanceForType() {
1929       return defaultInstance;
1930     }
1931
1932     private final com.google.protobuf.UnknownFieldSet unknownFields;
1933     @java.lang.Override
1934     public final com.google.protobuf.UnknownFieldSet
1935         getUnknownFields() {
1936       return this.unknownFields;
1937     }
1938     private RawMessage(
1939         com.google.protobuf.CodedInputStream input,
1940         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1941         throws com.google.protobuf.InvalidProtocolBufferException {
1942       initFields();
1943       int mutable_bitField0_ = 0;
1944       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1945           com.google.protobuf.UnknownFieldSet.newBuilder();
1946       try {
1947         boolean done = false;
1948         while (!done) {
1949           int tag = input.readTag();
1950           switch (tag) {
1951             case 0:
1952               done = true;
1953               break;
1954             default: {
1955               if (!parseUnknownField(input, unknownFields,
1956                                      extensionRegistry, tag)) {
1957                 done = true;
1958               }
1959               break;
1960             }
1961             case 8: {
1962               bitField0_ |= 0x00000001;
1963               bus_ = input.readInt32();
1964               break;
1965             }
1966             case 16: {
1967               bitField0_ |= 0x00000002;
1968               messageId_ = input.readUInt32();
1969               break;
1970             }
1971           }
1972         }
1973       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1974         throw e.setUnfinishedMessage(this);
1975       } catch (java.io.IOException e) {
1976         throw new com.google.protobuf.InvalidProtocolBufferException(
1977             e.getMessage()).setUnfinishedMessage(this);
1978       } finally {
1979         this.unknownFields = unknownFields.build();
1980         makeExtensionsImmutable();
1981       }
1982     }
1983     public static final com.google.protobuf.Descriptors.Descriptor
1984         getDescriptor() {
1985       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
1986     }
1987
1988     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1989         internalGetFieldAccessorTable() {
1990       return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
1991           .ensureFieldAccessorsInitialized(
1992               com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
1993     }
1994
1995     public static com.google.protobuf.Parser<RawMessage> PARSER =
1996         new com.google.protobuf.AbstractParser<RawMessage>() {
1997       public RawMessage parsePartialFrom(
1998           com.google.protobuf.CodedInputStream input,
1999           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2000           throws com.google.protobuf.InvalidProtocolBufferException {
2001         return new RawMessage(input, extensionRegistry);
2002       }
2003     };
2004
2005     @java.lang.Override
2006     public com.google.protobuf.Parser<RawMessage> getParserForType() {
2007       return PARSER;
2008     }
2009
2010     private int bitField0_;
2011     // optional int32 bus = 1;
2012     public static final int BUS_FIELD_NUMBER = 1;
2013     private int bus_;
2014     /**
2015      * <code>optional int32 bus = 1;</code>
2016      */
2017     public boolean hasBus() {
2018       return ((bitField0_ & 0x00000001) == 0x00000001);
2019     }
2020     /**
2021      * <code>optional int32 bus = 1;</code>
2022      */
2023     public int getBus() {
2024       return bus_;
2025     }
2026
2027     // optional uint32 message_id = 2;
2028     public static final int MESSAGE_ID_FIELD_NUMBER = 2;
2029     private int messageId_;
2030     /**
2031      * <code>optional uint32 message_id = 2;</code>
2032      */
2033     public boolean hasMessageId() {
2034       return ((bitField0_ & 0x00000002) == 0x00000002);
2035     }
2036     /**
2037      * <code>optional uint32 message_id = 2;</code>
2038      */
2039     public int getMessageId() {
2040       return messageId_;
2041     }
2042
2043     private void initFields() {
2044       bus_ = 0;
2045       messageId_ = 0;
2046     }
2047     private byte memoizedIsInitialized = -1;
2048     public final boolean isInitialized() {
2049       byte isInitialized = memoizedIsInitialized;
2050       if (isInitialized != -1) return isInitialized == 1;
2051
2052       memoizedIsInitialized = 1;
2053       return true;
2054     }
2055
2056     public void writeTo(com.google.protobuf.CodedOutputStream output)
2057                         throws java.io.IOException {
2058       getSerializedSize();
2059       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2060         output.writeInt32(1, bus_);
2061       }
2062       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2063         output.writeUInt32(2, messageId_);
2064       }
2065       getUnknownFields().writeTo(output);
2066     }
2067
2068     private int memoizedSerializedSize = -1;
2069     public int getSerializedSize() {
2070       int size = memoizedSerializedSize;
2071       if (size != -1) return size;
2072
2073       size = 0;
2074       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2075         size += com.google.protobuf.CodedOutputStream
2076           .computeInt32Size(1, bus_);
2077       }
2078       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2079         size += com.google.protobuf.CodedOutputStream
2080           .computeUInt32Size(2, messageId_);
2081       }
2082       size += getUnknownFields().getSerializedSize();
2083       memoizedSerializedSize = size;
2084       return size;
2085     }
2086
2087     private static final long serialVersionUID = 0L;
2088     @java.lang.Override
2089     protected java.lang.Object writeReplace()
2090         throws java.io.ObjectStreamException {
2091       return super.writeReplace();
2092     }
2093
2094     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2095         com.google.protobuf.ByteString data)
2096         throws com.google.protobuf.InvalidProtocolBufferException {
2097       return PARSER.parseFrom(data);
2098     }
2099     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2100         com.google.protobuf.ByteString data,
2101         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2102         throws com.google.protobuf.InvalidProtocolBufferException {
2103       return PARSER.parseFrom(data, extensionRegistry);
2104     }
2105     public static com.openxc.BinaryMessages.RawMessage parseFrom(byte[] data)
2106         throws com.google.protobuf.InvalidProtocolBufferException {
2107       return PARSER.parseFrom(data);
2108     }
2109     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2110         byte[] data,
2111         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2112         throws com.google.protobuf.InvalidProtocolBufferException {
2113       return PARSER.parseFrom(data, extensionRegistry);
2114     }
2115     public static com.openxc.BinaryMessages.RawMessage parseFrom(java.io.InputStream input)
2116         throws java.io.IOException {
2117       return PARSER.parseFrom(input);
2118     }
2119     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2120         java.io.InputStream input,
2121         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2122         throws java.io.IOException {
2123       return PARSER.parseFrom(input, extensionRegistry);
2124     }
2125     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(java.io.InputStream input)
2126         throws java.io.IOException {
2127       return PARSER.parseDelimitedFrom(input);
2128     }
2129     public static com.openxc.BinaryMessages.RawMessage parseDelimitedFrom(
2130         java.io.InputStream input,
2131         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2132         throws java.io.IOException {
2133       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2134     }
2135     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2136         com.google.protobuf.CodedInputStream input)
2137         throws java.io.IOException {
2138       return PARSER.parseFrom(input);
2139     }
2140     public static com.openxc.BinaryMessages.RawMessage parseFrom(
2141         com.google.protobuf.CodedInputStream input,
2142         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2143         throws java.io.IOException {
2144       return PARSER.parseFrom(input, extensionRegistry);
2145     }
2146
2147     public static Builder newBuilder() { return Builder.create(); }
2148     public Builder newBuilderForType() { return newBuilder(); }
2149     public static Builder newBuilder(com.openxc.BinaryMessages.RawMessage prototype) {
2150       return newBuilder().mergeFrom(prototype);
2151     }
2152     public Builder toBuilder() { return newBuilder(this); }
2153
2154     @java.lang.Override
2155     protected Builder newBuilderForType(
2156         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2157       Builder builder = new Builder(parent);
2158       return builder;
2159     }
2160     /**
2161      * Protobuf type {@code openxc.RawMessage}
2162      */
2163     public static final class Builder extends
2164         com.google.protobuf.GeneratedMessage.Builder<Builder>
2165        implements com.openxc.BinaryMessages.RawMessageOrBuilder {
2166       public static final com.google.protobuf.Descriptors.Descriptor
2167           getDescriptor() {
2168         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
2169       }
2170
2171       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2172           internalGetFieldAccessorTable() {
2173         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_fieldAccessorTable
2174             .ensureFieldAccessorsInitialized(
2175                 com.openxc.BinaryMessages.RawMessage.class, com.openxc.BinaryMessages.RawMessage.Builder.class);
2176       }
2177
2178       // Construct using com.openxc.BinaryMessages.RawMessage.newBuilder()
2179       private Builder() {
2180         maybeForceBuilderInitialization();
2181       }
2182
2183       private Builder(
2184           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2185         super(parent);
2186         maybeForceBuilderInitialization();
2187       }
2188       private void maybeForceBuilderInitialization() {
2189         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2190         }
2191       }
2192       private static Builder create() {
2193         return new Builder();
2194       }
2195
2196       public Builder clear() {
2197         super.clear();
2198         bus_ = 0;
2199         bitField0_ = (bitField0_ & ~0x00000001);
2200         messageId_ = 0;
2201         bitField0_ = (bitField0_ & ~0x00000002);
2202         return this;
2203       }
2204
2205       public Builder clone() {
2206         return create().mergeFrom(buildPartial());
2207       }
2208
2209       public com.google.protobuf.Descriptors.Descriptor
2210           getDescriptorForType() {
2211         return com.openxc.BinaryMessages.internal_static_openxc_RawMessage_descriptor;
2212       }
2213
2214       public com.openxc.BinaryMessages.RawMessage getDefaultInstanceForType() {
2215         return com.openxc.BinaryMessages.RawMessage.getDefaultInstance();
2216       }
2217
2218       public com.openxc.BinaryMessages.RawMessage build() {
2219         com.openxc.BinaryMessages.RawMessage result = buildPartial();
2220         if (!result.isInitialized()) {
2221           throw newUninitializedMessageException(result);
2222         }
2223         return result;
2224       }
2225
2226       public com.openxc.BinaryMessages.RawMessage buildPartial() {
2227         com.openxc.BinaryMessages.RawMessage result = new com.openxc.BinaryMessages.RawMessage(this);
2228         int from_bitField0_ = bitField0_;
2229         int to_bitField0_ = 0;
2230         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2231           to_bitField0_ |= 0x00000001;
2232         }
2233         result.bus_ = bus_;
2234         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2235           to_bitField0_ |= 0x00000002;
2236         }
2237         result.messageId_ = messageId_;
2238         result.bitField0_ = to_bitField0_;
2239         onBuilt();
2240         return result;
2241       }
2242
2243       public Builder mergeFrom(com.google.protobuf.Message other) {
2244         if (other instanceof com.openxc.BinaryMessages.RawMessage) {
2245           return mergeFrom((com.openxc.BinaryMessages.RawMessage)other);
2246         } else {
2247           super.mergeFrom(other);
2248           return this;
2249         }
2250       }
2251
2252       public Builder mergeFrom(com.openxc.BinaryMessages.RawMessage other) {
2253         if (other == com.openxc.BinaryMessages.RawMessage.getDefaultInstance()) return this;
2254         if (other.hasBus()) {
2255           setBus(other.getBus());
2256         }
2257         if (other.hasMessageId()) {
2258           setMessageId(other.getMessageId());
2259         }
2260         this.mergeUnknownFields(other.getUnknownFields());
2261         return this;
2262       }
2263
2264       public final boolean isInitialized() {
2265         return true;
2266       }
2267
2268       public Builder mergeFrom(
2269           com.google.protobuf.CodedInputStream input,
2270           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2271           throws java.io.IOException {
2272         com.openxc.BinaryMessages.RawMessage parsedMessage = null;
2273         try {
2274           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2275         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2276           parsedMessage = (com.openxc.BinaryMessages.RawMessage) e.getUnfinishedMessage();
2277           throw e;
2278         } finally {
2279           if (parsedMessage != null) {
2280             mergeFrom(parsedMessage);
2281           }
2282         }
2283         return this;
2284       }
2285       private int bitField0_;
2286
2287       // optional int32 bus = 1;
2288       private int bus_ ;
2289       /**
2290        * <code>optional int32 bus = 1;</code>
2291        */
2292       public boolean hasBus() {
2293         return ((bitField0_ & 0x00000001) == 0x00000001);
2294       }
2295       /**
2296        * <code>optional int32 bus = 1;</code>
2297        */
2298       public int getBus() {
2299         return bus_;
2300       }
2301       /**
2302        * <code>optional int32 bus = 1;</code>
2303        */
2304       public Builder setBus(int value) {
2305         bitField0_ |= 0x00000001;
2306         bus_ = value;
2307         onChanged();
2308         return this;
2309       }
2310       /**
2311        * <code>optional int32 bus = 1;</code>
2312        */
2313       public Builder clearBus() {
2314         bitField0_ = (bitField0_ & ~0x00000001);
2315         bus_ = 0;
2316         onChanged();
2317         return this;
2318       }
2319
2320       // optional uint32 message_id = 2;
2321       private int messageId_ ;
2322       /**
2323        * <code>optional uint32 message_id = 2;</code>
2324        */
2325       public boolean hasMessageId() {
2326         return ((bitField0_ & 0x00000002) == 0x00000002);
2327       }
2328       /**
2329        * <code>optional uint32 message_id = 2;</code>
2330        */
2331       public int getMessageId() {
2332         return messageId_;
2333       }
2334       /**
2335        * <code>optional uint32 message_id = 2;</code>
2336        */
2337       public Builder setMessageId(int value) {
2338         bitField0_ |= 0x00000002;
2339         messageId_ = value;
2340         onChanged();
2341         return this;
2342       }
2343       /**
2344        * <code>optional uint32 message_id = 2;</code>
2345        */
2346       public Builder clearMessageId() {
2347         bitField0_ = (bitField0_ & ~0x00000002);
2348         messageId_ = 0;
2349         onChanged();
2350         return this;
2351       }
2352
2353       // @@protoc_insertion_point(builder_scope:openxc.RawMessage)
2354     }
2355
2356     static {
2357       defaultInstance = new RawMessage(true);
2358       defaultInstance.initFields();
2359     }
2360
2361     // @@protoc_insertion_point(class_scope:openxc.RawMessage)
2362   }
2363
2364   public interface StringMessageOrBuilder
2365       extends com.google.protobuf.MessageOrBuilder {
2366
2367     // optional string name = 1;
2368     /**
2369      * <code>optional string name = 1;</code>
2370      */
2371     boolean hasName();
2372     /**
2373      * <code>optional string name = 1;</code>
2374      */
2375     java.lang.String getName();
2376     /**
2377      * <code>optional string name = 1;</code>
2378      */
2379     com.google.protobuf.ByteString
2380         getNameBytes();
2381
2382     // optional string value = 2;
2383     /**
2384      * <code>optional string value = 2;</code>
2385      */
2386     boolean hasValue();
2387     /**
2388      * <code>optional string value = 2;</code>
2389      */
2390     java.lang.String getValue();
2391     /**
2392      * <code>optional string value = 2;</code>
2393      */
2394     com.google.protobuf.ByteString
2395         getValueBytes();
2396   }
2397   /**
2398    * Protobuf type {@code openxc.StringMessage}
2399    */
2400   public static final class StringMessage extends
2401       com.google.protobuf.GeneratedMessage
2402       implements StringMessageOrBuilder {
2403     // Use StringMessage.newBuilder() to construct.
2404     private StringMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
2405       super(builder);
2406       this.unknownFields = builder.getUnknownFields();
2407     }
2408     private StringMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
2409
2410     private static final StringMessage defaultInstance;
2411     public static StringMessage getDefaultInstance() {
2412       return defaultInstance;
2413     }
2414
2415     public StringMessage getDefaultInstanceForType() {
2416       return defaultInstance;
2417     }
2418
2419     private final com.google.protobuf.UnknownFieldSet unknownFields;
2420     @java.lang.Override
2421     public final com.google.protobuf.UnknownFieldSet
2422         getUnknownFields() {
2423       return this.unknownFields;
2424     }
2425     private StringMessage(
2426         com.google.protobuf.CodedInputStream input,
2427         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2428         throws com.google.protobuf.InvalidProtocolBufferException {
2429       initFields();
2430       int mutable_bitField0_ = 0;
2431       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
2432           com.google.protobuf.UnknownFieldSet.newBuilder();
2433       try {
2434         boolean done = false;
2435         while (!done) {
2436           int tag = input.readTag();
2437           switch (tag) {
2438             case 0:
2439               done = true;
2440               break;
2441             default: {
2442               if (!parseUnknownField(input, unknownFields,
2443                                      extensionRegistry, tag)) {
2444                 done = true;
2445               }
2446               break;
2447             }
2448             case 10: {
2449               bitField0_ |= 0x00000001;
2450               name_ = input.readBytes();
2451               break;
2452             }
2453             case 18: {
2454               bitField0_ |= 0x00000002;
2455               value_ = input.readBytes();
2456               break;
2457             }
2458           }
2459         }
2460       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2461         throw e.setUnfinishedMessage(this);
2462       } catch (java.io.IOException e) {
2463         throw new com.google.protobuf.InvalidProtocolBufferException(
2464             e.getMessage()).setUnfinishedMessage(this);
2465       } finally {
2466         this.unknownFields = unknownFields.build();
2467         makeExtensionsImmutable();
2468       }
2469     }
2470     public static final com.google.protobuf.Descriptors.Descriptor
2471         getDescriptor() {
2472       return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_descriptor;
2473     }
2474
2475     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2476         internalGetFieldAccessorTable() {
2477       return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_fieldAccessorTable
2478           .ensureFieldAccessorsInitialized(
2479               com.openxc.BinaryMessages.StringMessage.class, com.openxc.BinaryMessages.StringMessage.Builder.class);
2480     }
2481
2482     public static com.google.protobuf.Parser<StringMessage> PARSER =
2483         new com.google.protobuf.AbstractParser<StringMessage>() {
2484       public StringMessage parsePartialFrom(
2485           com.google.protobuf.CodedInputStream input,
2486           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2487           throws com.google.protobuf.InvalidProtocolBufferException {
2488         return new StringMessage(input, extensionRegistry);
2489       }
2490     };
2491
2492     @java.lang.Override
2493     public com.google.protobuf.Parser<StringMessage> getParserForType() {
2494       return PARSER;
2495     }
2496
2497     private int bitField0_;
2498     // optional string name = 1;
2499     public static final int NAME_FIELD_NUMBER = 1;
2500     private java.lang.Object name_;
2501     /**
2502      * <code>optional string name = 1;</code>
2503      */
2504     public boolean hasName() {
2505       return ((bitField0_ & 0x00000001) == 0x00000001);
2506     }
2507     /**
2508      * <code>optional string name = 1;</code>
2509      */
2510     public java.lang.String getName() {
2511       java.lang.Object ref = name_;
2512       if (ref instanceof java.lang.String) {
2513         return (java.lang.String) ref;
2514       } else {
2515         com.google.protobuf.ByteString bs =
2516             (com.google.protobuf.ByteString) ref;
2517         java.lang.String s = bs.toStringUtf8();
2518         if (bs.isValidUtf8()) {
2519           name_ = s;
2520         }
2521         return s;
2522       }
2523     }
2524     /**
2525      * <code>optional string name = 1;</code>
2526      */
2527     public com.google.protobuf.ByteString
2528         getNameBytes() {
2529       java.lang.Object ref = name_;
2530       if (ref instanceof java.lang.String) {
2531         com.google.protobuf.ByteString b =
2532             com.google.protobuf.ByteString.copyFromUtf8(
2533                 (java.lang.String) ref);
2534         name_ = b;
2535         return b;
2536       } else {
2537         return (com.google.protobuf.ByteString) ref;
2538       }
2539     }
2540
2541     // optional string value = 2;
2542     public static final int VALUE_FIELD_NUMBER = 2;
2543     private java.lang.Object value_;
2544     /**
2545      * <code>optional string value = 2;</code>
2546      */
2547     public boolean hasValue() {
2548       return ((bitField0_ & 0x00000002) == 0x00000002);
2549     }
2550     /**
2551      * <code>optional string value = 2;</code>
2552      */
2553     public java.lang.String getValue() {
2554       java.lang.Object ref = value_;
2555       if (ref instanceof java.lang.String) {
2556         return (java.lang.String) ref;
2557       } else {
2558         com.google.protobuf.ByteString bs =
2559             (com.google.protobuf.ByteString) ref;
2560         java.lang.String s = bs.toStringUtf8();
2561         if (bs.isValidUtf8()) {
2562           value_ = s;
2563         }
2564         return s;
2565       }
2566     }
2567     /**
2568      * <code>optional string value = 2;</code>
2569      */
2570     public com.google.protobuf.ByteString
2571         getValueBytes() {
2572       java.lang.Object ref = value_;
2573       if (ref instanceof java.lang.String) {
2574         com.google.protobuf.ByteString b =
2575             com.google.protobuf.ByteString.copyFromUtf8(
2576                 (java.lang.String) ref);
2577         value_ = b;
2578         return b;
2579       } else {
2580         return (com.google.protobuf.ByteString) ref;
2581       }
2582     }
2583
2584     private void initFields() {
2585       name_ = "";
2586       value_ = "";
2587     }
2588     private byte memoizedIsInitialized = -1;
2589     public final boolean isInitialized() {
2590       byte isInitialized = memoizedIsInitialized;
2591       if (isInitialized != -1) return isInitialized == 1;
2592
2593       memoizedIsInitialized = 1;
2594       return true;
2595     }
2596
2597     public void writeTo(com.google.protobuf.CodedOutputStream output)
2598                         throws java.io.IOException {
2599       getSerializedSize();
2600       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2601         output.writeBytes(1, getNameBytes());
2602       }
2603       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2604         output.writeBytes(2, getValueBytes());
2605       }
2606       getUnknownFields().writeTo(output);
2607     }
2608
2609     private int memoizedSerializedSize = -1;
2610     public int getSerializedSize() {
2611       int size = memoizedSerializedSize;
2612       if (size != -1) return size;
2613
2614       size = 0;
2615       if (((bitField0_ & 0x00000001) == 0x00000001)) {
2616         size += com.google.protobuf.CodedOutputStream
2617           .computeBytesSize(1, getNameBytes());
2618       }
2619       if (((bitField0_ & 0x00000002) == 0x00000002)) {
2620         size += com.google.protobuf.CodedOutputStream
2621           .computeBytesSize(2, getValueBytes());
2622       }
2623       size += getUnknownFields().getSerializedSize();
2624       memoizedSerializedSize = size;
2625       return size;
2626     }
2627
2628     private static final long serialVersionUID = 0L;
2629     @java.lang.Override
2630     protected java.lang.Object writeReplace()
2631         throws java.io.ObjectStreamException {
2632       return super.writeReplace();
2633     }
2634
2635     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2636         com.google.protobuf.ByteString data)
2637         throws com.google.protobuf.InvalidProtocolBufferException {
2638       return PARSER.parseFrom(data);
2639     }
2640     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2641         com.google.protobuf.ByteString data,
2642         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2643         throws com.google.protobuf.InvalidProtocolBufferException {
2644       return PARSER.parseFrom(data, extensionRegistry);
2645     }
2646     public static com.openxc.BinaryMessages.StringMessage parseFrom(byte[] data)
2647         throws com.google.protobuf.InvalidProtocolBufferException {
2648       return PARSER.parseFrom(data);
2649     }
2650     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2651         byte[] data,
2652         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2653         throws com.google.protobuf.InvalidProtocolBufferException {
2654       return PARSER.parseFrom(data, extensionRegistry);
2655     }
2656     public static com.openxc.BinaryMessages.StringMessage parseFrom(java.io.InputStream input)
2657         throws java.io.IOException {
2658       return PARSER.parseFrom(input);
2659     }
2660     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2661         java.io.InputStream input,
2662         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2663         throws java.io.IOException {
2664       return PARSER.parseFrom(input, extensionRegistry);
2665     }
2666     public static com.openxc.BinaryMessages.StringMessage parseDelimitedFrom(java.io.InputStream input)
2667         throws java.io.IOException {
2668       return PARSER.parseDelimitedFrom(input);
2669     }
2670     public static com.openxc.BinaryMessages.StringMessage parseDelimitedFrom(
2671         java.io.InputStream input,
2672         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2673         throws java.io.IOException {
2674       return PARSER.parseDelimitedFrom(input, extensionRegistry);
2675     }
2676     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2677         com.google.protobuf.CodedInputStream input)
2678         throws java.io.IOException {
2679       return PARSER.parseFrom(input);
2680     }
2681     public static com.openxc.BinaryMessages.StringMessage parseFrom(
2682         com.google.protobuf.CodedInputStream input,
2683         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2684         throws java.io.IOException {
2685       return PARSER.parseFrom(input, extensionRegistry);
2686     }
2687
2688     public static Builder newBuilder() { return Builder.create(); }
2689     public Builder newBuilderForType() { return newBuilder(); }
2690     public static Builder newBuilder(com.openxc.BinaryMessages.StringMessage prototype) {
2691       return newBuilder().mergeFrom(prototype);
2692     }
2693     public Builder toBuilder() { return newBuilder(this); }
2694
2695     @java.lang.Override
2696     protected Builder newBuilderForType(
2697         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2698       Builder builder = new Builder(parent);
2699       return builder;
2700     }
2701     /**
2702      * Protobuf type {@code openxc.StringMessage}
2703      */
2704     public static final class Builder extends
2705         com.google.protobuf.GeneratedMessage.Builder<Builder>
2706        implements com.openxc.BinaryMessages.StringMessageOrBuilder {
2707       public static final com.google.protobuf.Descriptors.Descriptor
2708           getDescriptor() {
2709         return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_descriptor;
2710       }
2711
2712       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2713           internalGetFieldAccessorTable() {
2714         return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_fieldAccessorTable
2715             .ensureFieldAccessorsInitialized(
2716                 com.openxc.BinaryMessages.StringMessage.class, com.openxc.BinaryMessages.StringMessage.Builder.class);
2717       }
2718
2719       // Construct using com.openxc.BinaryMessages.StringMessage.newBuilder()
2720       private Builder() {
2721         maybeForceBuilderInitialization();
2722       }
2723
2724       private Builder(
2725           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2726         super(parent);
2727         maybeForceBuilderInitialization();
2728       }
2729       private void maybeForceBuilderInitialization() {
2730         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2731         }
2732       }
2733       private static Builder create() {
2734         return new Builder();
2735       }
2736
2737       public Builder clear() {
2738         super.clear();
2739         name_ = "";
2740         bitField0_ = (bitField0_ & ~0x00000001);
2741         value_ = "";
2742         bitField0_ = (bitField0_ & ~0x00000002);
2743         return this;
2744       }
2745
2746       public Builder clone() {
2747         return create().mergeFrom(buildPartial());
2748       }
2749
2750       public com.google.protobuf.Descriptors.Descriptor
2751           getDescriptorForType() {
2752         return com.openxc.BinaryMessages.internal_static_openxc_StringMessage_descriptor;
2753       }
2754
2755       public com.openxc.BinaryMessages.StringMessage getDefaultInstanceForType() {
2756         return com.openxc.BinaryMessages.StringMessage.getDefaultInstance();
2757       }
2758
2759       public com.openxc.BinaryMessages.StringMessage build() {
2760         com.openxc.BinaryMessages.StringMessage result = buildPartial();
2761         if (!result.isInitialized()) {
2762           throw newUninitializedMessageException(result);
2763         }
2764         return result;
2765       }
2766
2767       public com.openxc.BinaryMessages.StringMessage buildPartial() {
2768         com.openxc.BinaryMessages.StringMessage result = new com.openxc.BinaryMessages.StringMessage(this);
2769         int from_bitField0_ = bitField0_;
2770         int to_bitField0_ = 0;
2771         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2772           to_bitField0_ |= 0x00000001;
2773         }
2774         result.name_ = name_;
2775         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2776           to_bitField0_ |= 0x00000002;
2777         }
2778         result.value_ = value_;
2779         result.bitField0_ = to_bitField0_;
2780         onBuilt();
2781         return result;
2782       }
2783
2784       public Builder mergeFrom(com.google.protobuf.Message other) {
2785         if (other instanceof com.openxc.BinaryMessages.StringMessage) {
2786           return mergeFrom((com.openxc.BinaryMessages.StringMessage)other);
2787         } else {
2788           super.mergeFrom(other);
2789           return this;
2790         }
2791       }
2792
2793       public Builder mergeFrom(com.openxc.BinaryMessages.StringMessage other) {
2794         if (other == com.openxc.BinaryMessages.StringMessage.getDefaultInstance()) return this;
2795         if (other.hasName()) {
2796           bitField0_ |= 0x00000001;
2797           name_ = other.name_;
2798           onChanged();
2799         }
2800         if (other.hasValue()) {
2801           bitField0_ |= 0x00000002;
2802           value_ = other.value_;
2803           onChanged();
2804         }
2805         this.mergeUnknownFields(other.getUnknownFields());
2806         return this;
2807       }
2808
2809       public final boolean isInitialized() {
2810         return true;
2811       }
2812
2813       public Builder mergeFrom(
2814           com.google.protobuf.CodedInputStream input,
2815           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2816           throws java.io.IOException {
2817         com.openxc.BinaryMessages.StringMessage parsedMessage = null;
2818         try {
2819           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2820         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2821           parsedMessage = (com.openxc.BinaryMessages.StringMessage) e.getUnfinishedMessage();
2822           throw e;
2823         } finally {
2824           if (parsedMessage != null) {
2825             mergeFrom(parsedMessage);
2826           }
2827         }
2828         return this;
2829       }
2830       private int bitField0_;
2831
2832       // optional string name = 1;
2833       private java.lang.Object name_ = "";
2834       /**
2835        * <code>optional string name = 1;</code>
2836        */
2837       public boolean hasName() {
2838         return ((bitField0_ & 0x00000001) == 0x00000001);
2839       }
2840       /**
2841        * <code>optional string name = 1;</code>
2842        */
2843       public java.lang.String getName() {
2844         java.lang.Object ref = name_;
2845         if (!(ref instanceof java.lang.String)) {
2846           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2847               .toStringUtf8();
2848           name_ = s;
2849           return s;
2850         } else {
2851           return (java.lang.String) ref;
2852         }
2853       }
2854       /**
2855        * <code>optional string name = 1;</code>
2856        */
2857       public com.google.protobuf.ByteString
2858           getNameBytes() {
2859         java.lang.Object ref = name_;
2860         if (ref instanceof String) {
2861           com.google.protobuf.ByteString b =
2862               com.google.protobuf.ByteString.copyFromUtf8(
2863                   (java.lang.String) ref);
2864           name_ = b;
2865           return b;
2866         } else {
2867           return (com.google.protobuf.ByteString) ref;
2868         }
2869       }
2870       /**
2871        * <code>optional string name = 1;</code>
2872        */
2873       public Builder setName(
2874           java.lang.String value) {
2875         if (value == null) {
2876     throw new NullPointerException();
2877   }
2878   bitField0_ |= 0x00000001;
2879         name_ = value;
2880         onChanged();
2881         return this;
2882       }
2883       /**
2884        * <code>optional string name = 1;</code>
2885        */
2886       public Builder clearName() {
2887         bitField0_ = (bitField0_ & ~0x00000001);
2888         name_ = getDefaultInstance().getName();
2889         onChanged();
2890         return this;
2891       }
2892       /**
2893        * <code>optional string name = 1;</code>
2894        */
2895       public Builder setNameBytes(
2896           com.google.protobuf.ByteString value) {
2897         if (value == null) {
2898     throw new NullPointerException();
2899   }
2900   bitField0_ |= 0x00000001;
2901         name_ = value;
2902         onChanged();
2903         return this;
2904       }
2905
2906       // optional string value = 2;
2907       private java.lang.Object value_ = "";
2908       /**
2909        * <code>optional string value = 2;</code>
2910        */
2911       public boolean hasValue() {
2912         return ((bitField0_ & 0x00000002) == 0x00000002);
2913       }
2914       /**
2915        * <code>optional string value = 2;</code>
2916        */
2917       public java.lang.String getValue() {
2918         java.lang.Object ref = value_;
2919         if (!(ref instanceof java.lang.String)) {
2920           java.lang.String s = ((com.google.protobuf.ByteString) ref)
2921               .toStringUtf8();
2922           value_ = s;
2923           return s;
2924         } else {
2925           return (java.lang.String) ref;
2926         }
2927       }
2928       /**
2929        * <code>optional string value = 2;</code>
2930        */
2931       public com.google.protobuf.ByteString
2932           getValueBytes() {
2933         java.lang.Object ref = value_;
2934         if (ref instanceof String) {
2935           com.google.protobuf.ByteString b =
2936               com.google.protobuf.ByteString.copyFromUtf8(
2937                   (java.lang.String) ref);
2938           value_ = b;
2939           return b;
2940         } else {
2941           return (com.google.protobuf.ByteString) ref;
2942         }
2943       }
2944       /**
2945        * <code>optional string value = 2;</code>
2946        */
2947       public Builder setValue(
2948           java.lang.String value) {
2949         if (value == null) {
2950     throw new NullPointerException();
2951   }
2952   bitField0_ |= 0x00000002;
2953         value_ = value;
2954         onChanged();
2955         return this;
2956       }
2957       /**
2958        * <code>optional string value = 2;</code>
2959        */
2960       public Builder clearValue() {
2961         bitField0_ = (bitField0_ & ~0x00000002);
2962         value_ = getDefaultInstance().getValue();
2963         onChanged();
2964         return this;
2965       }
2966       /**
2967        * <code>optional string value = 2;</code>
2968        */
2969       public Builder setValueBytes(
2970           com.google.protobuf.ByteString value) {
2971         if (value == null) {
2972     throw new NullPointerException();
2973   }
2974   bitField0_ |= 0x00000002;
2975         value_ = value;
2976         onChanged();
2977         return this;
2978       }
2979
2980       // @@protoc_insertion_point(builder_scope:openxc.StringMessage)
2981     }
2982
2983     static {
2984       defaultInstance = new StringMessage(true);
2985       defaultInstance.initFields();
2986     }
2987
2988     // @@protoc_insertion_point(class_scope:openxc.StringMessage)
2989   }
2990
2991   public interface NumericMessageOrBuilder
2992       extends com.google.protobuf.MessageOrBuilder {
2993
2994     // optional string name = 1;
2995     /**
2996      * <code>optional string name = 1;</code>
2997      */
2998     boolean hasName();
2999     /**
3000      * <code>optional string name = 1;</code>
3001      */
3002     java.lang.String getName();
3003     /**
3004      * <code>optional string name = 1;</code>
3005      */
3006     com.google.protobuf.ByteString
3007         getNameBytes();
3008
3009     // optional double value = 2;
3010     /**
3011      * <code>optional double value = 2;</code>
3012      */
3013     boolean hasValue();
3014     /**
3015      * <code>optional double value = 2;</code>
3016      */
3017     double getValue();
3018   }
3019   /**
3020    * Protobuf type {@code openxc.NumericMessage}
3021    */
3022   public static final class NumericMessage extends
3023       com.google.protobuf.GeneratedMessage
3024       implements NumericMessageOrBuilder {
3025     // Use NumericMessage.newBuilder() to construct.
3026     private NumericMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3027       super(builder);
3028       this.unknownFields = builder.getUnknownFields();
3029     }
3030     private NumericMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3031
3032     private static final NumericMessage defaultInstance;
3033     public static NumericMessage getDefaultInstance() {
3034       return defaultInstance;
3035     }
3036
3037     public NumericMessage getDefaultInstanceForType() {
3038       return defaultInstance;
3039     }
3040
3041     private final com.google.protobuf.UnknownFieldSet unknownFields;
3042     @java.lang.Override
3043     public final com.google.protobuf.UnknownFieldSet
3044         getUnknownFields() {
3045       return this.unknownFields;
3046     }
3047     private NumericMessage(
3048         com.google.protobuf.CodedInputStream input,
3049         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3050         throws com.google.protobuf.InvalidProtocolBufferException {
3051       initFields();
3052       int mutable_bitField0_ = 0;
3053       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3054           com.google.protobuf.UnknownFieldSet.newBuilder();
3055       try {
3056         boolean done = false;
3057         while (!done) {
3058           int tag = input.readTag();
3059           switch (tag) {
3060             case 0:
3061               done = true;
3062               break;
3063             default: {
3064               if (!parseUnknownField(input, unknownFields,
3065                                      extensionRegistry, tag)) {
3066                 done = true;
3067               }
3068               break;
3069             }
3070             case 10: {
3071               bitField0_ |= 0x00000001;
3072               name_ = input.readBytes();
3073               break;
3074             }
3075             case 17: {
3076               bitField0_ |= 0x00000002;
3077               value_ = input.readDouble();
3078               break;
3079             }
3080           }
3081         }
3082       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3083         throw e.setUnfinishedMessage(this);
3084       } catch (java.io.IOException e) {
3085         throw new com.google.protobuf.InvalidProtocolBufferException(
3086             e.getMessage()).setUnfinishedMessage(this);
3087       } finally {
3088         this.unknownFields = unknownFields.build();
3089         makeExtensionsImmutable();
3090       }
3091     }
3092     public static final com.google.protobuf.Descriptors.Descriptor
3093         getDescriptor() {
3094       return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_descriptor;
3095     }
3096
3097     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3098         internalGetFieldAccessorTable() {
3099       return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_fieldAccessorTable
3100           .ensureFieldAccessorsInitialized(
3101               com.openxc.BinaryMessages.NumericMessage.class, com.openxc.BinaryMessages.NumericMessage.Builder.class);
3102     }
3103
3104     public static com.google.protobuf.Parser<NumericMessage> PARSER =
3105         new com.google.protobuf.AbstractParser<NumericMessage>() {
3106       public NumericMessage parsePartialFrom(
3107           com.google.protobuf.CodedInputStream input,
3108           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3109           throws com.google.protobuf.InvalidProtocolBufferException {
3110         return new NumericMessage(input, extensionRegistry);
3111       }
3112     };
3113
3114     @java.lang.Override
3115     public com.google.protobuf.Parser<NumericMessage> getParserForType() {
3116       return PARSER;
3117     }
3118
3119     private int bitField0_;
3120     // optional string name = 1;
3121     public static final int NAME_FIELD_NUMBER = 1;
3122     private java.lang.Object name_;
3123     /**
3124      * <code>optional string name = 1;</code>
3125      */
3126     public boolean hasName() {
3127       return ((bitField0_ & 0x00000001) == 0x00000001);
3128     }
3129     /**
3130      * <code>optional string name = 1;</code>
3131      */
3132     public java.lang.String getName() {
3133       java.lang.Object ref = name_;
3134       if (ref instanceof java.lang.String) {
3135         return (java.lang.String) ref;
3136       } else {
3137         com.google.protobuf.ByteString bs =
3138             (com.google.protobuf.ByteString) ref;
3139         java.lang.String s = bs.toStringUtf8();
3140         if (bs.isValidUtf8()) {
3141           name_ = s;
3142         }
3143         return s;
3144       }
3145     }
3146     /**
3147      * <code>optional string name = 1;</code>
3148      */
3149     public com.google.protobuf.ByteString
3150         getNameBytes() {
3151       java.lang.Object ref = name_;
3152       if (ref instanceof java.lang.String) {
3153         com.google.protobuf.ByteString b =
3154             com.google.protobuf.ByteString.copyFromUtf8(
3155                 (java.lang.String) ref);
3156         name_ = b;
3157         return b;
3158       } else {
3159         return (com.google.protobuf.ByteString) ref;
3160       }
3161     }
3162
3163     // optional double value = 2;
3164     public static final int VALUE_FIELD_NUMBER = 2;
3165     private double value_;
3166     /**
3167      * <code>optional double value = 2;</code>
3168      */
3169     public boolean hasValue() {
3170       return ((bitField0_ & 0x00000002) == 0x00000002);
3171     }
3172     /**
3173      * <code>optional double value = 2;</code>
3174      */
3175     public double getValue() {
3176       return value_;
3177     }
3178
3179     private void initFields() {
3180       name_ = "";
3181       value_ = 0D;
3182     }
3183     private byte memoizedIsInitialized = -1;
3184     public final boolean isInitialized() {
3185       byte isInitialized = memoizedIsInitialized;
3186       if (isInitialized != -1) return isInitialized == 1;
3187
3188       memoizedIsInitialized = 1;
3189       return true;
3190     }
3191
3192     public void writeTo(com.google.protobuf.CodedOutputStream output)
3193                         throws java.io.IOException {
3194       getSerializedSize();
3195       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3196         output.writeBytes(1, getNameBytes());
3197       }
3198       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3199         output.writeDouble(2, value_);
3200       }
3201       getUnknownFields().writeTo(output);
3202     }
3203
3204     private int memoizedSerializedSize = -1;
3205     public int getSerializedSize() {
3206       int size = memoizedSerializedSize;
3207       if (size != -1) return size;
3208
3209       size = 0;
3210       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3211         size += com.google.protobuf.CodedOutputStream
3212           .computeBytesSize(1, getNameBytes());
3213       }
3214       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3215         size += com.google.protobuf.CodedOutputStream
3216           .computeDoubleSize(2, value_);
3217       }
3218       size += getUnknownFields().getSerializedSize();
3219       memoizedSerializedSize = size;
3220       return size;
3221     }
3222
3223     private static final long serialVersionUID = 0L;
3224     @java.lang.Override
3225     protected java.lang.Object writeReplace()
3226         throws java.io.ObjectStreamException {
3227       return super.writeReplace();
3228     }
3229
3230     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3231         com.google.protobuf.ByteString data)
3232         throws com.google.protobuf.InvalidProtocolBufferException {
3233       return PARSER.parseFrom(data);
3234     }
3235     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3236         com.google.protobuf.ByteString data,
3237         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3238         throws com.google.protobuf.InvalidProtocolBufferException {
3239       return PARSER.parseFrom(data, extensionRegistry);
3240     }
3241     public static com.openxc.BinaryMessages.NumericMessage parseFrom(byte[] data)
3242         throws com.google.protobuf.InvalidProtocolBufferException {
3243       return PARSER.parseFrom(data);
3244     }
3245     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3246         byte[] data,
3247         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3248         throws com.google.protobuf.InvalidProtocolBufferException {
3249       return PARSER.parseFrom(data, extensionRegistry);
3250     }
3251     public static com.openxc.BinaryMessages.NumericMessage parseFrom(java.io.InputStream input)
3252         throws java.io.IOException {
3253       return PARSER.parseFrom(input);
3254     }
3255     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3256         java.io.InputStream input,
3257         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3258         throws java.io.IOException {
3259       return PARSER.parseFrom(input, extensionRegistry);
3260     }
3261     public static com.openxc.BinaryMessages.NumericMessage parseDelimitedFrom(java.io.InputStream input)
3262         throws java.io.IOException {
3263       return PARSER.parseDelimitedFrom(input);
3264     }
3265     public static com.openxc.BinaryMessages.NumericMessage parseDelimitedFrom(
3266         java.io.InputStream input,
3267         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3268         throws java.io.IOException {
3269       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3270     }
3271     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3272         com.google.protobuf.CodedInputStream input)
3273         throws java.io.IOException {
3274       return PARSER.parseFrom(input);
3275     }
3276     public static com.openxc.BinaryMessages.NumericMessage parseFrom(
3277         com.google.protobuf.CodedInputStream input,
3278         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3279         throws java.io.IOException {
3280       return PARSER.parseFrom(input, extensionRegistry);
3281     }
3282
3283     public static Builder newBuilder() { return Builder.create(); }
3284     public Builder newBuilderForType() { return newBuilder(); }
3285     public static Builder newBuilder(com.openxc.BinaryMessages.NumericMessage prototype) {
3286       return newBuilder().mergeFrom(prototype);
3287     }
3288     public Builder toBuilder() { return newBuilder(this); }
3289
3290     @java.lang.Override
3291     protected Builder newBuilderForType(
3292         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3293       Builder builder = new Builder(parent);
3294       return builder;
3295     }
3296     /**
3297      * Protobuf type {@code openxc.NumericMessage}
3298      */
3299     public static final class Builder extends
3300         com.google.protobuf.GeneratedMessage.Builder<Builder>
3301        implements com.openxc.BinaryMessages.NumericMessageOrBuilder {
3302       public static final com.google.protobuf.Descriptors.Descriptor
3303           getDescriptor() {
3304         return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_descriptor;
3305       }
3306
3307       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3308           internalGetFieldAccessorTable() {
3309         return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_fieldAccessorTable
3310             .ensureFieldAccessorsInitialized(
3311                 com.openxc.BinaryMessages.NumericMessage.class, com.openxc.BinaryMessages.NumericMessage.Builder.class);
3312       }
3313
3314       // Construct using com.openxc.BinaryMessages.NumericMessage.newBuilder()
3315       private Builder() {
3316         maybeForceBuilderInitialization();
3317       }
3318
3319       private Builder(
3320           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3321         super(parent);
3322         maybeForceBuilderInitialization();
3323       }
3324       private void maybeForceBuilderInitialization() {
3325         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3326         }
3327       }
3328       private static Builder create() {
3329         return new Builder();
3330       }
3331
3332       public Builder clear() {
3333         super.clear();
3334         name_ = "";
3335         bitField0_ = (bitField0_ & ~0x00000001);
3336         value_ = 0D;
3337         bitField0_ = (bitField0_ & ~0x00000002);
3338         return this;
3339       }
3340
3341       public Builder clone() {
3342         return create().mergeFrom(buildPartial());
3343       }
3344
3345       public com.google.protobuf.Descriptors.Descriptor
3346           getDescriptorForType() {
3347         return com.openxc.BinaryMessages.internal_static_openxc_NumericMessage_descriptor;
3348       }
3349
3350       public com.openxc.BinaryMessages.NumericMessage getDefaultInstanceForType() {
3351         return com.openxc.BinaryMessages.NumericMessage.getDefaultInstance();
3352       }
3353
3354       public com.openxc.BinaryMessages.NumericMessage build() {
3355         com.openxc.BinaryMessages.NumericMessage result = buildPartial();
3356         if (!result.isInitialized()) {
3357           throw newUninitializedMessageException(result);
3358         }
3359         return result;
3360       }
3361
3362       public com.openxc.BinaryMessages.NumericMessage buildPartial() {
3363         com.openxc.BinaryMessages.NumericMessage result = new com.openxc.BinaryMessages.NumericMessage(this);
3364         int from_bitField0_ = bitField0_;
3365         int to_bitField0_ = 0;
3366         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3367           to_bitField0_ |= 0x00000001;
3368         }
3369         result.name_ = name_;
3370         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3371           to_bitField0_ |= 0x00000002;
3372         }
3373         result.value_ = value_;
3374         result.bitField0_ = to_bitField0_;
3375         onBuilt();
3376         return result;
3377       }
3378
3379       public Builder mergeFrom(com.google.protobuf.Message other) {
3380         if (other instanceof com.openxc.BinaryMessages.NumericMessage) {
3381           return mergeFrom((com.openxc.BinaryMessages.NumericMessage)other);
3382         } else {
3383           super.mergeFrom(other);
3384           return this;
3385         }
3386       }
3387
3388       public Builder mergeFrom(com.openxc.BinaryMessages.NumericMessage other) {
3389         if (other == com.openxc.BinaryMessages.NumericMessage.getDefaultInstance()) return this;
3390         if (other.hasName()) {
3391           bitField0_ |= 0x00000001;
3392           name_ = other.name_;
3393           onChanged();
3394         }
3395         if (other.hasValue()) {
3396           setValue(other.getValue());
3397         }
3398         this.mergeUnknownFields(other.getUnknownFields());
3399         return this;
3400       }
3401
3402       public final boolean isInitialized() {
3403         return true;
3404       }
3405
3406       public Builder mergeFrom(
3407           com.google.protobuf.CodedInputStream input,
3408           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3409           throws java.io.IOException {
3410         com.openxc.BinaryMessages.NumericMessage parsedMessage = null;
3411         try {
3412           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3413         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3414           parsedMessage = (com.openxc.BinaryMessages.NumericMessage) e.getUnfinishedMessage();
3415           throw e;
3416         } finally {
3417           if (parsedMessage != null) {
3418             mergeFrom(parsedMessage);
3419           }
3420         }
3421         return this;
3422       }
3423       private int bitField0_;
3424
3425       // optional string name = 1;
3426       private java.lang.Object name_ = "";
3427       /**
3428        * <code>optional string name = 1;</code>
3429        */
3430       public boolean hasName() {
3431         return ((bitField0_ & 0x00000001) == 0x00000001);
3432       }
3433       /**
3434        * <code>optional string name = 1;</code>
3435        */
3436       public java.lang.String getName() {
3437         java.lang.Object ref = name_;
3438         if (!(ref instanceof java.lang.String)) {
3439           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3440               .toStringUtf8();
3441           name_ = s;
3442           return s;
3443         } else {
3444           return (java.lang.String) ref;
3445         }
3446       }
3447       /**
3448        * <code>optional string name = 1;</code>
3449        */
3450       public com.google.protobuf.ByteString
3451           getNameBytes() {
3452         java.lang.Object ref = name_;
3453         if (ref instanceof String) {
3454           com.google.protobuf.ByteString b =
3455               com.google.protobuf.ByteString.copyFromUtf8(
3456                   (java.lang.String) ref);
3457           name_ = b;
3458           return b;
3459         } else {
3460           return (com.google.protobuf.ByteString) ref;
3461         }
3462       }
3463       /**
3464        * <code>optional string name = 1;</code>
3465        */
3466       public Builder setName(
3467           java.lang.String value) {
3468         if (value == null) {
3469     throw new NullPointerException();
3470   }
3471   bitField0_ |= 0x00000001;
3472         name_ = value;
3473         onChanged();
3474         return this;
3475       }
3476       /**
3477        * <code>optional string name = 1;</code>
3478        */
3479       public Builder clearName() {
3480         bitField0_ = (bitField0_ & ~0x00000001);
3481         name_ = getDefaultInstance().getName();
3482         onChanged();
3483         return this;
3484       }
3485       /**
3486        * <code>optional string name = 1;</code>
3487        */
3488       public Builder setNameBytes(
3489           com.google.protobuf.ByteString value) {
3490         if (value == null) {
3491     throw new NullPointerException();
3492   }
3493   bitField0_ |= 0x00000001;
3494         name_ = value;
3495         onChanged();
3496         return this;
3497       }
3498
3499       // optional double value = 2;
3500       private double value_ ;
3501       /**
3502        * <code>optional double value = 2;</code>
3503        */
3504       public boolean hasValue() {
3505         return ((bitField0_ & 0x00000002) == 0x00000002);
3506       }
3507       /**
3508        * <code>optional double value = 2;</code>
3509        */
3510       public double getValue() {
3511         return value_;
3512       }
3513       /**
3514        * <code>optional double value = 2;</code>
3515        */
3516       public Builder setValue(double value) {
3517         bitField0_ |= 0x00000002;
3518         value_ = value;
3519         onChanged();
3520         return this;
3521       }
3522       /**
3523        * <code>optional double value = 2;</code>
3524        */
3525       public Builder clearValue() {
3526         bitField0_ = (bitField0_ & ~0x00000002);
3527         value_ = 0D;
3528         onChanged();
3529         return this;
3530       }
3531
3532       // @@protoc_insertion_point(builder_scope:openxc.NumericMessage)
3533     }
3534
3535     static {
3536       defaultInstance = new NumericMessage(true);
3537       defaultInstance.initFields();
3538     }
3539
3540     // @@protoc_insertion_point(class_scope:openxc.NumericMessage)
3541   }
3542
3543   public interface BooleanMessageOrBuilder
3544       extends com.google.protobuf.MessageOrBuilder {
3545
3546     // optional string name = 1;
3547     /**
3548      * <code>optional string name = 1;</code>
3549      */
3550     boolean hasName();
3551     /**
3552      * <code>optional string name = 1;</code>
3553      */
3554     java.lang.String getName();
3555     /**
3556      * <code>optional string name = 1;</code>
3557      */
3558     com.google.protobuf.ByteString
3559         getNameBytes();
3560
3561     // optional bool value = 2;
3562     /**
3563      * <code>optional bool value = 2;</code>
3564      */
3565     boolean hasValue();
3566     /**
3567      * <code>optional bool value = 2;</code>
3568      */
3569     boolean getValue();
3570   }
3571   /**
3572    * Protobuf type {@code openxc.BooleanMessage}
3573    */
3574   public static final class BooleanMessage extends
3575       com.google.protobuf.GeneratedMessage
3576       implements BooleanMessageOrBuilder {
3577     // Use BooleanMessage.newBuilder() to construct.
3578     private BooleanMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3579       super(builder);
3580       this.unknownFields = builder.getUnknownFields();
3581     }
3582     private BooleanMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3583
3584     private static final BooleanMessage defaultInstance;
3585     public static BooleanMessage getDefaultInstance() {
3586       return defaultInstance;
3587     }
3588
3589     public BooleanMessage getDefaultInstanceForType() {
3590       return defaultInstance;
3591     }
3592
3593     private final com.google.protobuf.UnknownFieldSet unknownFields;
3594     @java.lang.Override
3595     public final com.google.protobuf.UnknownFieldSet
3596         getUnknownFields() {
3597       return this.unknownFields;
3598     }
3599     private BooleanMessage(
3600         com.google.protobuf.CodedInputStream input,
3601         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3602         throws com.google.protobuf.InvalidProtocolBufferException {
3603       initFields();
3604       int mutable_bitField0_ = 0;
3605       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3606           com.google.protobuf.UnknownFieldSet.newBuilder();
3607       try {
3608         boolean done = false;
3609         while (!done) {
3610           int tag = input.readTag();
3611           switch (tag) {
3612             case 0:
3613               done = true;
3614               break;
3615             default: {
3616               if (!parseUnknownField(input, unknownFields,
3617                                      extensionRegistry, tag)) {
3618                 done = true;
3619               }
3620               break;
3621             }
3622             case 10: {
3623               bitField0_ |= 0x00000001;
3624               name_ = input.readBytes();
3625               break;
3626             }
3627             case 16: {
3628               bitField0_ |= 0x00000002;
3629               value_ = input.readBool();
3630               break;
3631             }
3632           }
3633         }
3634       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3635         throw e.setUnfinishedMessage(this);
3636       } catch (java.io.IOException e) {
3637         throw new com.google.protobuf.InvalidProtocolBufferException(
3638             e.getMessage()).setUnfinishedMessage(this);
3639       } finally {
3640         this.unknownFields = unknownFields.build();
3641         makeExtensionsImmutable();
3642       }
3643     }
3644     public static final com.google.protobuf.Descriptors.Descriptor
3645         getDescriptor() {
3646       return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_descriptor;
3647     }
3648
3649     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3650         internalGetFieldAccessorTable() {
3651       return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_fieldAccessorTable
3652           .ensureFieldAccessorsInitialized(
3653               com.openxc.BinaryMessages.BooleanMessage.class, com.openxc.BinaryMessages.BooleanMessage.Builder.class);
3654     }
3655
3656     public static com.google.protobuf.Parser<BooleanMessage> PARSER =
3657         new com.google.protobuf.AbstractParser<BooleanMessage>() {
3658       public BooleanMessage parsePartialFrom(
3659           com.google.protobuf.CodedInputStream input,
3660           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3661           throws com.google.protobuf.InvalidProtocolBufferException {
3662         return new BooleanMessage(input, extensionRegistry);
3663       }
3664     };
3665
3666     @java.lang.Override
3667     public com.google.protobuf.Parser<BooleanMessage> getParserForType() {
3668       return PARSER;
3669     }
3670
3671     private int bitField0_;
3672     // optional string name = 1;
3673     public static final int NAME_FIELD_NUMBER = 1;
3674     private java.lang.Object name_;
3675     /**
3676      * <code>optional string name = 1;</code>
3677      */
3678     public boolean hasName() {
3679       return ((bitField0_ & 0x00000001) == 0x00000001);
3680     }
3681     /**
3682      * <code>optional string name = 1;</code>
3683      */
3684     public java.lang.String getName() {
3685       java.lang.Object ref = name_;
3686       if (ref instanceof java.lang.String) {
3687         return (java.lang.String) ref;
3688       } else {
3689         com.google.protobuf.ByteString bs =
3690             (com.google.protobuf.ByteString) ref;
3691         java.lang.String s = bs.toStringUtf8();
3692         if (bs.isValidUtf8()) {
3693           name_ = s;
3694         }
3695         return s;
3696       }
3697     }
3698     /**
3699      * <code>optional string name = 1;</code>
3700      */
3701     public com.google.protobuf.ByteString
3702         getNameBytes() {
3703       java.lang.Object ref = name_;
3704       if (ref instanceof java.lang.String) {
3705         com.google.protobuf.ByteString b =
3706             com.google.protobuf.ByteString.copyFromUtf8(
3707                 (java.lang.String) ref);
3708         name_ = b;
3709         return b;
3710       } else {
3711         return (com.google.protobuf.ByteString) ref;
3712       }
3713     }
3714
3715     // optional bool value = 2;
3716     public static final int VALUE_FIELD_NUMBER = 2;
3717     private boolean value_;
3718     /**
3719      * <code>optional bool value = 2;</code>
3720      */
3721     public boolean hasValue() {
3722       return ((bitField0_ & 0x00000002) == 0x00000002);
3723     }
3724     /**
3725      * <code>optional bool value = 2;</code>
3726      */
3727     public boolean getValue() {
3728       return value_;
3729     }
3730
3731     private void initFields() {
3732       name_ = "";
3733       value_ = false;
3734     }
3735     private byte memoizedIsInitialized = -1;
3736     public final boolean isInitialized() {
3737       byte isInitialized = memoizedIsInitialized;
3738       if (isInitialized != -1) return isInitialized == 1;
3739
3740       memoizedIsInitialized = 1;
3741       return true;
3742     }
3743
3744     public void writeTo(com.google.protobuf.CodedOutputStream output)
3745                         throws java.io.IOException {
3746       getSerializedSize();
3747       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3748         output.writeBytes(1, getNameBytes());
3749       }
3750       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3751         output.writeBool(2, value_);
3752       }
3753       getUnknownFields().writeTo(output);
3754     }
3755
3756     private int memoizedSerializedSize = -1;
3757     public int getSerializedSize() {
3758       int size = memoizedSerializedSize;
3759       if (size != -1) return size;
3760
3761       size = 0;
3762       if (((bitField0_ & 0x00000001) == 0x00000001)) {
3763         size += com.google.protobuf.CodedOutputStream
3764           .computeBytesSize(1, getNameBytes());
3765       }
3766       if (((bitField0_ & 0x00000002) == 0x00000002)) {
3767         size += com.google.protobuf.CodedOutputStream
3768           .computeBoolSize(2, value_);
3769       }
3770       size += getUnknownFields().getSerializedSize();
3771       memoizedSerializedSize = size;
3772       return size;
3773     }
3774
3775     private static final long serialVersionUID = 0L;
3776     @java.lang.Override
3777     protected java.lang.Object writeReplace()
3778         throws java.io.ObjectStreamException {
3779       return super.writeReplace();
3780     }
3781
3782     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3783         com.google.protobuf.ByteString data)
3784         throws com.google.protobuf.InvalidProtocolBufferException {
3785       return PARSER.parseFrom(data);
3786     }
3787     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3788         com.google.protobuf.ByteString data,
3789         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3790         throws com.google.protobuf.InvalidProtocolBufferException {
3791       return PARSER.parseFrom(data, extensionRegistry);
3792     }
3793     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(byte[] data)
3794         throws com.google.protobuf.InvalidProtocolBufferException {
3795       return PARSER.parseFrom(data);
3796     }
3797     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3798         byte[] data,
3799         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3800         throws com.google.protobuf.InvalidProtocolBufferException {
3801       return PARSER.parseFrom(data, extensionRegistry);
3802     }
3803     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(java.io.InputStream input)
3804         throws java.io.IOException {
3805       return PARSER.parseFrom(input);
3806     }
3807     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3808         java.io.InputStream input,
3809         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3810         throws java.io.IOException {
3811       return PARSER.parseFrom(input, extensionRegistry);
3812     }
3813     public static com.openxc.BinaryMessages.BooleanMessage parseDelimitedFrom(java.io.InputStream input)
3814         throws java.io.IOException {
3815       return PARSER.parseDelimitedFrom(input);
3816     }
3817     public static com.openxc.BinaryMessages.BooleanMessage parseDelimitedFrom(
3818         java.io.InputStream input,
3819         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3820         throws java.io.IOException {
3821       return PARSER.parseDelimitedFrom(input, extensionRegistry);
3822     }
3823     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3824         com.google.protobuf.CodedInputStream input)
3825         throws java.io.IOException {
3826       return PARSER.parseFrom(input);
3827     }
3828     public static com.openxc.BinaryMessages.BooleanMessage parseFrom(
3829         com.google.protobuf.CodedInputStream input,
3830         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3831         throws java.io.IOException {
3832       return PARSER.parseFrom(input, extensionRegistry);
3833     }
3834
3835     public static Builder newBuilder() { return Builder.create(); }
3836     public Builder newBuilderForType() { return newBuilder(); }
3837     public static Builder newBuilder(com.openxc.BinaryMessages.BooleanMessage prototype) {
3838       return newBuilder().mergeFrom(prototype);
3839     }
3840     public Builder toBuilder() { return newBuilder(this); }
3841
3842     @java.lang.Override
3843     protected Builder newBuilderForType(
3844         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3845       Builder builder = new Builder(parent);
3846       return builder;
3847     }
3848     /**
3849      * Protobuf type {@code openxc.BooleanMessage}
3850      */
3851     public static final class Builder extends
3852         com.google.protobuf.GeneratedMessage.Builder<Builder>
3853        implements com.openxc.BinaryMessages.BooleanMessageOrBuilder {
3854       public static final com.google.protobuf.Descriptors.Descriptor
3855           getDescriptor() {
3856         return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_descriptor;
3857       }
3858
3859       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3860           internalGetFieldAccessorTable() {
3861         return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_fieldAccessorTable
3862             .ensureFieldAccessorsInitialized(
3863                 com.openxc.BinaryMessages.BooleanMessage.class, com.openxc.BinaryMessages.BooleanMessage.Builder.class);
3864       }
3865
3866       // Construct using com.openxc.BinaryMessages.BooleanMessage.newBuilder()
3867       private Builder() {
3868         maybeForceBuilderInitialization();
3869       }
3870
3871       private Builder(
3872           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3873         super(parent);
3874         maybeForceBuilderInitialization();
3875       }
3876       private void maybeForceBuilderInitialization() {
3877         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
3878         }
3879       }
3880       private static Builder create() {
3881         return new Builder();
3882       }
3883
3884       public Builder clear() {
3885         super.clear();
3886         name_ = "";
3887         bitField0_ = (bitField0_ & ~0x00000001);
3888         value_ = false;
3889         bitField0_ = (bitField0_ & ~0x00000002);
3890         return this;
3891       }
3892
3893       public Builder clone() {
3894         return create().mergeFrom(buildPartial());
3895       }
3896
3897       public com.google.protobuf.Descriptors.Descriptor
3898           getDescriptorForType() {
3899         return com.openxc.BinaryMessages.internal_static_openxc_BooleanMessage_descriptor;
3900       }
3901
3902       public com.openxc.BinaryMessages.BooleanMessage getDefaultInstanceForType() {
3903         return com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance();
3904       }
3905
3906       public com.openxc.BinaryMessages.BooleanMessage build() {
3907         com.openxc.BinaryMessages.BooleanMessage result = buildPartial();
3908         if (!result.isInitialized()) {
3909           throw newUninitializedMessageException(result);
3910         }
3911         return result;
3912       }
3913
3914       public com.openxc.BinaryMessages.BooleanMessage buildPartial() {
3915         com.openxc.BinaryMessages.BooleanMessage result = new com.openxc.BinaryMessages.BooleanMessage(this);
3916         int from_bitField0_ = bitField0_;
3917         int to_bitField0_ = 0;
3918         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
3919           to_bitField0_ |= 0x00000001;
3920         }
3921         result.name_ = name_;
3922         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
3923           to_bitField0_ |= 0x00000002;
3924         }
3925         result.value_ = value_;
3926         result.bitField0_ = to_bitField0_;
3927         onBuilt();
3928         return result;
3929       }
3930
3931       public Builder mergeFrom(com.google.protobuf.Message other) {
3932         if (other instanceof com.openxc.BinaryMessages.BooleanMessage) {
3933           return mergeFrom((com.openxc.BinaryMessages.BooleanMessage)other);
3934         } else {
3935           super.mergeFrom(other);
3936           return this;
3937         }
3938       }
3939
3940       public Builder mergeFrom(com.openxc.BinaryMessages.BooleanMessage other) {
3941         if (other == com.openxc.BinaryMessages.BooleanMessage.getDefaultInstance()) return this;
3942         if (other.hasName()) {
3943           bitField0_ |= 0x00000001;
3944           name_ = other.name_;
3945           onChanged();
3946         }
3947         if (other.hasValue()) {
3948           setValue(other.getValue());
3949         }
3950         this.mergeUnknownFields(other.getUnknownFields());
3951         return this;
3952       }
3953
3954       public final boolean isInitialized() {
3955         return true;
3956       }
3957
3958       public Builder mergeFrom(
3959           com.google.protobuf.CodedInputStream input,
3960           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3961           throws java.io.IOException {
3962         com.openxc.BinaryMessages.BooleanMessage parsedMessage = null;
3963         try {
3964           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
3965         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3966           parsedMessage = (com.openxc.BinaryMessages.BooleanMessage) e.getUnfinishedMessage();
3967           throw e;
3968         } finally {
3969           if (parsedMessage != null) {
3970             mergeFrom(parsedMessage);
3971           }
3972         }
3973         return this;
3974       }
3975       private int bitField0_;
3976
3977       // optional string name = 1;
3978       private java.lang.Object name_ = "";
3979       /**
3980        * <code>optional string name = 1;</code>
3981        */
3982       public boolean hasName() {
3983         return ((bitField0_ & 0x00000001) == 0x00000001);
3984       }
3985       /**
3986        * <code>optional string name = 1;</code>
3987        */
3988       public java.lang.String getName() {
3989         java.lang.Object ref = name_;
3990         if (!(ref instanceof java.lang.String)) {
3991           java.lang.String s = ((com.google.protobuf.ByteString) ref)
3992               .toStringUtf8();
3993           name_ = s;
3994           return s;
3995         } else {
3996           return (java.lang.String) ref;
3997         }
3998       }
3999       /**
4000        * <code>optional string name = 1;</code>
4001        */
4002       public com.google.protobuf.ByteString
4003           getNameBytes() {
4004         java.lang.Object ref = name_;
4005         if (ref instanceof String) {
4006           com.google.protobuf.ByteString b =
4007               com.google.protobuf.ByteString.copyFromUtf8(
4008                   (java.lang.String) ref);
4009           name_ = b;
4010           return b;
4011         } else {
4012           return (com.google.protobuf.ByteString) ref;
4013         }
4014       }
4015       /**
4016        * <code>optional string name = 1;</code>
4017        */
4018       public Builder setName(
4019           java.lang.String value) {
4020         if (value == null) {
4021     throw new NullPointerException();
4022   }
4023   bitField0_ |= 0x00000001;
4024         name_ = value;
4025         onChanged();
4026         return this;
4027       }
4028       /**
4029        * <code>optional string name = 1;</code>
4030        */
4031       public Builder clearName() {
4032         bitField0_ = (bitField0_ & ~0x00000001);
4033         name_ = getDefaultInstance().getName();
4034         onChanged();
4035         return this;
4036       }
4037       /**
4038        * <code>optional string name = 1;</code>
4039        */
4040       public Builder setNameBytes(
4041           com.google.protobuf.ByteString value) {
4042         if (value == null) {
4043     throw new NullPointerException();
4044   }
4045   bitField0_ |= 0x00000001;
4046         name_ = value;
4047         onChanged();
4048         return this;
4049       }
4050
4051       // optional bool value = 2;
4052       private boolean value_ ;
4053       /**
4054        * <code>optional bool value = 2;</code>
4055        */
4056       public boolean hasValue() {
4057         return ((bitField0_ & 0x00000002) == 0x00000002);
4058       }
4059       /**
4060        * <code>optional bool value = 2;</code>
4061        */
4062       public boolean getValue() {
4063         return value_;
4064       }
4065       /**
4066        * <code>optional bool value = 2;</code>
4067        */
4068       public Builder setValue(boolean value) {
4069         bitField0_ |= 0x00000002;
4070         value_ = value;
4071         onChanged();
4072         return this;
4073       }
4074       /**
4075        * <code>optional bool value = 2;</code>
4076        */
4077       public Builder clearValue() {
4078         bitField0_ = (bitField0_ & ~0x00000002);
4079         value_ = false;
4080         onChanged();
4081         return this;
4082       }
4083
4084       // @@protoc_insertion_point(builder_scope:openxc.BooleanMessage)
4085     }
4086
4087     static {
4088       defaultInstance = new BooleanMessage(true);
4089       defaultInstance.initFields();
4090     }
4091
4092     // @@protoc_insertion_point(class_scope:openxc.BooleanMessage)
4093   }
4094
4095   public interface EventedStringMessageOrBuilder
4096       extends com.google.protobuf.MessageOrBuilder {
4097
4098     // optional string name = 1;
4099     /**
4100      * <code>optional string name = 1;</code>
4101      */
4102     boolean hasName();
4103     /**
4104      * <code>optional string name = 1;</code>
4105      */
4106     java.lang.String getName();
4107     /**
4108      * <code>optional string name = 1;</code>
4109      */
4110     com.google.protobuf.ByteString
4111         getNameBytes();
4112
4113     // optional string value = 2;
4114     /**
4115      * <code>optional string value = 2;</code>
4116      */
4117     boolean hasValue();
4118     /**
4119      * <code>optional string value = 2;</code>
4120      */
4121     java.lang.String getValue();
4122     /**
4123      * <code>optional string value = 2;</code>
4124      */
4125     com.google.protobuf.ByteString
4126         getValueBytes();
4127
4128     // optional string event = 3;
4129     /**
4130      * <code>optional string event = 3;</code>
4131      */
4132     boolean hasEvent();
4133     /**
4134      * <code>optional string event = 3;</code>
4135      */
4136     java.lang.String getEvent();
4137     /**
4138      * <code>optional string event = 3;</code>
4139      */
4140     com.google.protobuf.ByteString
4141         getEventBytes();
4142   }
4143   /**
4144    * Protobuf type {@code openxc.EventedStringMessage}
4145    */
4146   public static final class EventedStringMessage extends
4147       com.google.protobuf.GeneratedMessage
4148       implements EventedStringMessageOrBuilder {
4149     // Use EventedStringMessage.newBuilder() to construct.
4150     private EventedStringMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4151       super(builder);
4152       this.unknownFields = builder.getUnknownFields();
4153     }
4154     private EventedStringMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4155
4156     private static final EventedStringMessage defaultInstance;
4157     public static EventedStringMessage getDefaultInstance() {
4158       return defaultInstance;
4159     }
4160
4161     public EventedStringMessage getDefaultInstanceForType() {
4162       return defaultInstance;
4163     }
4164
4165     private final com.google.protobuf.UnknownFieldSet unknownFields;
4166     @java.lang.Override
4167     public final com.google.protobuf.UnknownFieldSet
4168         getUnknownFields() {
4169       return this.unknownFields;
4170     }
4171     private EventedStringMessage(
4172         com.google.protobuf.CodedInputStream input,
4173         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4174         throws com.google.protobuf.InvalidProtocolBufferException {
4175       initFields();
4176       int mutable_bitField0_ = 0;
4177       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4178           com.google.protobuf.UnknownFieldSet.newBuilder();
4179       try {
4180         boolean done = false;
4181         while (!done) {
4182           int tag = input.readTag();
4183           switch (tag) {
4184             case 0:
4185               done = true;
4186               break;
4187             default: {
4188               if (!parseUnknownField(input, unknownFields,
4189                                      extensionRegistry, tag)) {
4190                 done = true;
4191               }
4192               break;
4193             }
4194             case 10: {
4195               bitField0_ |= 0x00000001;
4196               name_ = input.readBytes();
4197               break;
4198             }
4199             case 18: {
4200               bitField0_ |= 0x00000002;
4201               value_ = input.readBytes();
4202               break;
4203             }
4204             case 26: {
4205               bitField0_ |= 0x00000004;
4206               event_ = input.readBytes();
4207               break;
4208             }
4209           }
4210         }
4211       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4212         throw e.setUnfinishedMessage(this);
4213       } catch (java.io.IOException e) {
4214         throw new com.google.protobuf.InvalidProtocolBufferException(
4215             e.getMessage()).setUnfinishedMessage(this);
4216       } finally {
4217         this.unknownFields = unknownFields.build();
4218         makeExtensionsImmutable();
4219       }
4220     }
4221     public static final com.google.protobuf.Descriptors.Descriptor
4222         getDescriptor() {
4223       return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_descriptor;
4224     }
4225
4226     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4227         internalGetFieldAccessorTable() {
4228       return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_fieldAccessorTable
4229           .ensureFieldAccessorsInitialized(
4230               com.openxc.BinaryMessages.EventedStringMessage.class, com.openxc.BinaryMessages.EventedStringMessage.Builder.class);
4231     }
4232
4233     public static com.google.protobuf.Parser<EventedStringMessage> PARSER =
4234         new com.google.protobuf.AbstractParser<EventedStringMessage>() {
4235       public EventedStringMessage parsePartialFrom(
4236           com.google.protobuf.CodedInputStream input,
4237           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4238           throws com.google.protobuf.InvalidProtocolBufferException {
4239         return new EventedStringMessage(input, extensionRegistry);
4240       }
4241     };
4242
4243     @java.lang.Override
4244     public com.google.protobuf.Parser<EventedStringMessage> getParserForType() {
4245       return PARSER;
4246     }
4247
4248     private int bitField0_;
4249     // optional string name = 1;
4250     public static final int NAME_FIELD_NUMBER = 1;
4251     private java.lang.Object name_;
4252     /**
4253      * <code>optional string name = 1;</code>
4254      */
4255     public boolean hasName() {
4256       return ((bitField0_ & 0x00000001) == 0x00000001);
4257     }
4258     /**
4259      * <code>optional string name = 1;</code>
4260      */
4261     public java.lang.String getName() {
4262       java.lang.Object ref = name_;
4263       if (ref instanceof java.lang.String) {
4264         return (java.lang.String) ref;
4265       } else {
4266         com.google.protobuf.ByteString bs =
4267             (com.google.protobuf.ByteString) ref;
4268         java.lang.String s = bs.toStringUtf8();
4269         if (bs.isValidUtf8()) {
4270           name_ = s;
4271         }
4272         return s;
4273       }
4274     }
4275     /**
4276      * <code>optional string name = 1;</code>
4277      */
4278     public com.google.protobuf.ByteString
4279         getNameBytes() {
4280       java.lang.Object ref = name_;
4281       if (ref instanceof java.lang.String) {
4282         com.google.protobuf.ByteString b =
4283             com.google.protobuf.ByteString.copyFromUtf8(
4284                 (java.lang.String) ref);
4285         name_ = b;
4286         return b;
4287       } else {
4288         return (com.google.protobuf.ByteString) ref;
4289       }
4290     }
4291
4292     // optional string value = 2;
4293     public static final int VALUE_FIELD_NUMBER = 2;
4294     private java.lang.Object value_;
4295     /**
4296      * <code>optional string value = 2;</code>
4297      */
4298     public boolean hasValue() {
4299       return ((bitField0_ & 0x00000002) == 0x00000002);
4300     }
4301     /**
4302      * <code>optional string value = 2;</code>
4303      */
4304     public java.lang.String getValue() {
4305       java.lang.Object ref = value_;
4306       if (ref instanceof java.lang.String) {
4307         return (java.lang.String) ref;
4308       } else {
4309         com.google.protobuf.ByteString bs =
4310             (com.google.protobuf.ByteString) ref;
4311         java.lang.String s = bs.toStringUtf8();
4312         if (bs.isValidUtf8()) {
4313           value_ = s;
4314         }
4315         return s;
4316       }
4317     }
4318     /**
4319      * <code>optional string value = 2;</code>
4320      */
4321     public com.google.protobuf.ByteString
4322         getValueBytes() {
4323       java.lang.Object ref = value_;
4324       if (ref instanceof java.lang.String) {
4325         com.google.protobuf.ByteString b =
4326             com.google.protobuf.ByteString.copyFromUtf8(
4327                 (java.lang.String) ref);
4328         value_ = b;
4329         return b;
4330       } else {
4331         return (com.google.protobuf.ByteString) ref;
4332       }
4333     }
4334
4335     // optional string event = 3;
4336     public static final int EVENT_FIELD_NUMBER = 3;
4337     private java.lang.Object event_;
4338     /**
4339      * <code>optional string event = 3;</code>
4340      */
4341     public boolean hasEvent() {
4342       return ((bitField0_ & 0x00000004) == 0x00000004);
4343     }
4344     /**
4345      * <code>optional string event = 3;</code>
4346      */
4347     public java.lang.String getEvent() {
4348       java.lang.Object ref = event_;
4349       if (ref instanceof java.lang.String) {
4350         return (java.lang.String) ref;
4351       } else {
4352         com.google.protobuf.ByteString bs =
4353             (com.google.protobuf.ByteString) ref;
4354         java.lang.String s = bs.toStringUtf8();
4355         if (bs.isValidUtf8()) {
4356           event_ = s;
4357         }
4358         return s;
4359       }
4360     }
4361     /**
4362      * <code>optional string event = 3;</code>
4363      */
4364     public com.google.protobuf.ByteString
4365         getEventBytes() {
4366       java.lang.Object ref = event_;
4367       if (ref instanceof java.lang.String) {
4368         com.google.protobuf.ByteString b =
4369             com.google.protobuf.ByteString.copyFromUtf8(
4370                 (java.lang.String) ref);
4371         event_ = b;
4372         return b;
4373       } else {
4374         return (com.google.protobuf.ByteString) ref;
4375       }
4376     }
4377
4378     private void initFields() {
4379       name_ = "";
4380       value_ = "";
4381       event_ = "";
4382     }
4383     private byte memoizedIsInitialized = -1;
4384     public final boolean isInitialized() {
4385       byte isInitialized = memoizedIsInitialized;
4386       if (isInitialized != -1) return isInitialized == 1;
4387
4388       memoizedIsInitialized = 1;
4389       return true;
4390     }
4391
4392     public void writeTo(com.google.protobuf.CodedOutputStream output)
4393                         throws java.io.IOException {
4394       getSerializedSize();
4395       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4396         output.writeBytes(1, getNameBytes());
4397       }
4398       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4399         output.writeBytes(2, getValueBytes());
4400       }
4401       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4402         output.writeBytes(3, getEventBytes());
4403       }
4404       getUnknownFields().writeTo(output);
4405     }
4406
4407     private int memoizedSerializedSize = -1;
4408     public int getSerializedSize() {
4409       int size = memoizedSerializedSize;
4410       if (size != -1) return size;
4411
4412       size = 0;
4413       if (((bitField0_ & 0x00000001) == 0x00000001)) {
4414         size += com.google.protobuf.CodedOutputStream
4415           .computeBytesSize(1, getNameBytes());
4416       }
4417       if (((bitField0_ & 0x00000002) == 0x00000002)) {
4418         size += com.google.protobuf.CodedOutputStream
4419           .computeBytesSize(2, getValueBytes());
4420       }
4421       if (((bitField0_ & 0x00000004) == 0x00000004)) {
4422         size += com.google.protobuf.CodedOutputStream
4423           .computeBytesSize(3, getEventBytes());
4424       }
4425       size += getUnknownFields().getSerializedSize();
4426       memoizedSerializedSize = size;
4427       return size;
4428     }
4429
4430     private static final long serialVersionUID = 0L;
4431     @java.lang.Override
4432     protected java.lang.Object writeReplace()
4433         throws java.io.ObjectStreamException {
4434       return super.writeReplace();
4435     }
4436
4437     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4438         com.google.protobuf.ByteString data)
4439         throws com.google.protobuf.InvalidProtocolBufferException {
4440       return PARSER.parseFrom(data);
4441     }
4442     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4443         com.google.protobuf.ByteString data,
4444         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4445         throws com.google.protobuf.InvalidProtocolBufferException {
4446       return PARSER.parseFrom(data, extensionRegistry);
4447     }
4448     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(byte[] data)
4449         throws com.google.protobuf.InvalidProtocolBufferException {
4450       return PARSER.parseFrom(data);
4451     }
4452     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4453         byte[] data,
4454         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4455         throws com.google.protobuf.InvalidProtocolBufferException {
4456       return PARSER.parseFrom(data, extensionRegistry);
4457     }
4458     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(java.io.InputStream input)
4459         throws java.io.IOException {
4460       return PARSER.parseFrom(input);
4461     }
4462     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4463         java.io.InputStream input,
4464         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4465         throws java.io.IOException {
4466       return PARSER.parseFrom(input, extensionRegistry);
4467     }
4468     public static com.openxc.BinaryMessages.EventedStringMessage parseDelimitedFrom(java.io.InputStream input)
4469         throws java.io.IOException {
4470       return PARSER.parseDelimitedFrom(input);
4471     }
4472     public static com.openxc.BinaryMessages.EventedStringMessage parseDelimitedFrom(
4473         java.io.InputStream input,
4474         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4475         throws java.io.IOException {
4476       return PARSER.parseDelimitedFrom(input, extensionRegistry);
4477     }
4478     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4479         com.google.protobuf.CodedInputStream input)
4480         throws java.io.IOException {
4481       return PARSER.parseFrom(input);
4482     }
4483     public static com.openxc.BinaryMessages.EventedStringMessage parseFrom(
4484         com.google.protobuf.CodedInputStream input,
4485         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4486         throws java.io.IOException {
4487       return PARSER.parseFrom(input, extensionRegistry);
4488     }
4489
4490     public static Builder newBuilder() { return Builder.create(); }
4491     public Builder newBuilderForType() { return newBuilder(); }
4492     public static Builder newBuilder(com.openxc.BinaryMessages.EventedStringMessage prototype) {
4493       return newBuilder().mergeFrom(prototype);
4494     }
4495     public Builder toBuilder() { return newBuilder(this); }
4496
4497     @java.lang.Override
4498     protected Builder newBuilderForType(
4499         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4500       Builder builder = new Builder(parent);
4501       return builder;
4502     }
4503     /**
4504      * Protobuf type {@code openxc.EventedStringMessage}
4505      */
4506     public static final class Builder extends
4507         com.google.protobuf.GeneratedMessage.Builder<Builder>
4508        implements com.openxc.BinaryMessages.EventedStringMessageOrBuilder {
4509       public static final com.google.protobuf.Descriptors.Descriptor
4510           getDescriptor() {
4511         return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_descriptor;
4512       }
4513
4514       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4515           internalGetFieldAccessorTable() {
4516         return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_fieldAccessorTable
4517             .ensureFieldAccessorsInitialized(
4518                 com.openxc.BinaryMessages.EventedStringMessage.class, com.openxc.BinaryMessages.EventedStringMessage.Builder.class);
4519       }
4520
4521       // Construct using com.openxc.BinaryMessages.EventedStringMessage.newBuilder()
4522       private Builder() {
4523         maybeForceBuilderInitialization();
4524       }
4525
4526       private Builder(
4527           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4528         super(parent);
4529         maybeForceBuilderInitialization();
4530       }
4531       private void maybeForceBuilderInitialization() {
4532         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4533         }
4534       }
4535       private static Builder create() {
4536         return new Builder();
4537       }
4538
4539       public Builder clear() {
4540         super.clear();
4541         name_ = "";
4542         bitField0_ = (bitField0_ & ~0x00000001);
4543         value_ = "";
4544         bitField0_ = (bitField0_ & ~0x00000002);
4545         event_ = "";
4546         bitField0_ = (bitField0_ & ~0x00000004);
4547         return this;
4548       }
4549
4550       public Builder clone() {
4551         return create().mergeFrom(buildPartial());
4552       }
4553
4554       public com.google.protobuf.Descriptors.Descriptor
4555           getDescriptorForType() {
4556         return com.openxc.BinaryMessages.internal_static_openxc_EventedStringMessage_descriptor;
4557       }
4558
4559       public com.openxc.BinaryMessages.EventedStringMessage getDefaultInstanceForType() {
4560         return com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance();
4561       }
4562
4563       public com.openxc.BinaryMessages.EventedStringMessage build() {
4564         com.openxc.BinaryMessages.EventedStringMessage result = buildPartial();
4565         if (!result.isInitialized()) {
4566           throw newUninitializedMessageException(result);
4567         }
4568         return result;
4569       }
4570
4571       public com.openxc.BinaryMessages.EventedStringMessage buildPartial() {
4572         com.openxc.BinaryMessages.EventedStringMessage result = new com.openxc.BinaryMessages.EventedStringMessage(this);
4573         int from_bitField0_ = bitField0_;
4574         int to_bitField0_ = 0;
4575         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4576           to_bitField0_ |= 0x00000001;
4577         }
4578         result.name_ = name_;
4579         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4580           to_bitField0_ |= 0x00000002;
4581         }
4582         result.value_ = value_;
4583         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4584           to_bitField0_ |= 0x00000004;
4585         }
4586         result.event_ = event_;
4587         result.bitField0_ = to_bitField0_;
4588         onBuilt();
4589         return result;
4590       }
4591
4592       public Builder mergeFrom(com.google.protobuf.Message other) {
4593         if (other instanceof com.openxc.BinaryMessages.EventedStringMessage) {
4594           return mergeFrom((com.openxc.BinaryMessages.EventedStringMessage)other);
4595         } else {
4596           super.mergeFrom(other);
4597           return this;
4598         }
4599       }
4600
4601       public Builder mergeFrom(com.openxc.BinaryMessages.EventedStringMessage other) {
4602         if (other == com.openxc.BinaryMessages.EventedStringMessage.getDefaultInstance()) return this;
4603         if (other.hasName()) {
4604           bitField0_ |= 0x00000001;
4605           name_ = other.name_;
4606           onChanged();
4607         }
4608         if (other.hasValue()) {
4609           bitField0_ |= 0x00000002;
4610           value_ = other.value_;
4611           onChanged();
4612         }
4613         if (other.hasEvent()) {
4614           bitField0_ |= 0x00000004;
4615           event_ = other.event_;
4616           onChanged();
4617         }
4618         this.mergeUnknownFields(other.getUnknownFields());
4619         return this;
4620       }
4621
4622       public final boolean isInitialized() {
4623         return true;
4624       }
4625
4626       public Builder mergeFrom(
4627           com.google.protobuf.CodedInputStream input,
4628           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4629           throws java.io.IOException {
4630         com.openxc.BinaryMessages.EventedStringMessage parsedMessage = null;
4631         try {
4632           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4633         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4634           parsedMessage = (com.openxc.BinaryMessages.EventedStringMessage) e.getUnfinishedMessage();
4635           throw e;
4636         } finally {
4637           if (parsedMessage != null) {
4638             mergeFrom(parsedMessage);
4639           }
4640         }
4641         return this;
4642       }
4643       private int bitField0_;
4644
4645       // optional string name = 1;
4646       private java.lang.Object name_ = "";
4647       /**
4648        * <code>optional string name = 1;</code>
4649        */
4650       public boolean hasName() {
4651         return ((bitField0_ & 0x00000001) == 0x00000001);
4652       }
4653       /**
4654        * <code>optional string name = 1;</code>
4655        */
4656       public java.lang.String getName() {
4657         java.lang.Object ref = name_;
4658         if (!(ref instanceof java.lang.String)) {
4659           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4660               .toStringUtf8();
4661           name_ = s;
4662           return s;
4663         } else {
4664           return (java.lang.String) ref;
4665         }
4666       }
4667       /**
4668        * <code>optional string name = 1;</code>
4669        */
4670       public com.google.protobuf.ByteString
4671           getNameBytes() {
4672         java.lang.Object ref = name_;
4673         if (ref instanceof String) {
4674           com.google.protobuf.ByteString b =
4675               com.google.protobuf.ByteString.copyFromUtf8(
4676                   (java.lang.String) ref);
4677           name_ = b;
4678           return b;
4679         } else {
4680           return (com.google.protobuf.ByteString) ref;
4681         }
4682       }
4683       /**
4684        * <code>optional string name = 1;</code>
4685        */
4686       public Builder setName(
4687           java.lang.String value) {
4688         if (value == null) {
4689     throw new NullPointerException();
4690   }
4691   bitField0_ |= 0x00000001;
4692         name_ = value;
4693         onChanged();
4694         return this;
4695       }
4696       /**
4697        * <code>optional string name = 1;</code>
4698        */
4699       public Builder clearName() {
4700         bitField0_ = (bitField0_ & ~0x00000001);
4701         name_ = getDefaultInstance().getName();
4702         onChanged();
4703         return this;
4704       }
4705       /**
4706        * <code>optional string name = 1;</code>
4707        */
4708       public Builder setNameBytes(
4709           com.google.protobuf.ByteString value) {
4710         if (value == null) {
4711     throw new NullPointerException();
4712   }
4713   bitField0_ |= 0x00000001;
4714         name_ = value;
4715         onChanged();
4716         return this;
4717       }
4718
4719       // optional string value = 2;
4720       private java.lang.Object value_ = "";
4721       /**
4722        * <code>optional string value = 2;</code>
4723        */
4724       public boolean hasValue() {
4725         return ((bitField0_ & 0x00000002) == 0x00000002);
4726       }
4727       /**
4728        * <code>optional string value = 2;</code>
4729        */
4730       public java.lang.String getValue() {
4731         java.lang.Object ref = value_;
4732         if (!(ref instanceof java.lang.String)) {
4733           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4734               .toStringUtf8();
4735           value_ = s;
4736           return s;
4737         } else {
4738           return (java.lang.String) ref;
4739         }
4740       }
4741       /**
4742        * <code>optional string value = 2;</code>
4743        */
4744       public com.google.protobuf.ByteString
4745           getValueBytes() {
4746         java.lang.Object ref = value_;
4747         if (ref instanceof String) {
4748           com.google.protobuf.ByteString b =
4749               com.google.protobuf.ByteString.copyFromUtf8(
4750                   (java.lang.String) ref);
4751           value_ = b;
4752           return b;
4753         } else {
4754           return (com.google.protobuf.ByteString) ref;
4755         }
4756       }
4757       /**
4758        * <code>optional string value = 2;</code>
4759        */
4760       public Builder setValue(
4761           java.lang.String value) {
4762         if (value == null) {
4763     throw new NullPointerException();
4764   }
4765   bitField0_ |= 0x00000002;
4766         value_ = value;
4767         onChanged();
4768         return this;
4769       }
4770       /**
4771        * <code>optional string value = 2;</code>
4772        */
4773       public Builder clearValue() {
4774         bitField0_ = (bitField0_ & ~0x00000002);
4775         value_ = getDefaultInstance().getValue();
4776         onChanged();
4777         return this;
4778       }
4779       /**
4780        * <code>optional string value = 2;</code>
4781        */
4782       public Builder setValueBytes(
4783           com.google.protobuf.ByteString value) {
4784         if (value == null) {
4785     throw new NullPointerException();
4786   }
4787   bitField0_ |= 0x00000002;
4788         value_ = value;
4789         onChanged();
4790         return this;
4791       }
4792
4793       // optional string event = 3;
4794       private java.lang.Object event_ = "";
4795       /**
4796        * <code>optional string event = 3;</code>
4797        */
4798       public boolean hasEvent() {
4799         return ((bitField0_ & 0x00000004) == 0x00000004);
4800       }
4801       /**
4802        * <code>optional string event = 3;</code>
4803        */
4804       public java.lang.String getEvent() {
4805         java.lang.Object ref = event_;
4806         if (!(ref instanceof java.lang.String)) {
4807           java.lang.String s = ((com.google.protobuf.ByteString) ref)
4808               .toStringUtf8();
4809           event_ = s;
4810           return s;
4811         } else {
4812           return (java.lang.String) ref;
4813         }
4814       }
4815       /**
4816        * <code>optional string event = 3;</code>
4817        */
4818       public com.google.protobuf.ByteString
4819           getEventBytes() {
4820         java.lang.Object ref = event_;
4821         if (ref instanceof String) {
4822           com.google.protobuf.ByteString b =
4823               com.google.protobuf.ByteString.copyFromUtf8(
4824                   (java.lang.String) ref);
4825           event_ = b;
4826           return b;
4827         } else {
4828           return (com.google.protobuf.ByteString) ref;
4829         }
4830       }
4831       /**
4832        * <code>optional string event = 3;</code>
4833        */
4834       public Builder setEvent(
4835           java.lang.String value) {
4836         if (value == null) {
4837     throw new NullPointerException();
4838   }
4839   bitField0_ |= 0x00000004;
4840         event_ = value;
4841         onChanged();
4842         return this;
4843       }
4844       /**
4845        * <code>optional string event = 3;</code>
4846        */
4847       public Builder clearEvent() {
4848         bitField0_ = (bitField0_ & ~0x00000004);
4849         event_ = getDefaultInstance().getEvent();
4850         onChanged();
4851         return this;
4852       }
4853       /**
4854        * <code>optional string event = 3;</code>
4855        */
4856       public Builder setEventBytes(
4857           com.google.protobuf.ByteString value) {
4858         if (value == null) {
4859     throw new NullPointerException();
4860   }
4861   bitField0_ |= 0x00000004;
4862         event_ = value;
4863         onChanged();
4864         return this;
4865       }
4866
4867       // @@protoc_insertion_point(builder_scope:openxc.EventedStringMessage)
4868     }
4869
4870     static {
4871       defaultInstance = new EventedStringMessage(true);
4872       defaultInstance.initFields();
4873     }
4874
4875     // @@protoc_insertion_point(class_scope:openxc.EventedStringMessage)
4876   }
4877
4878   public interface EventedBooleanMessageOrBuilder
4879       extends com.google.protobuf.MessageOrBuilder {
4880
4881     // optional string name = 1;
4882     /**
4883      * <code>optional string name = 1;</code>
4884      */
4885     boolean hasName();
4886     /**
4887      * <code>optional string name = 1;</code>
4888      */
4889     java.lang.String getName();
4890     /**
4891      * <code>optional string name = 1;</code>
4892      */
4893     com.google.protobuf.ByteString
4894         getNameBytes();
4895
4896     // optional string value = 2;
4897     /**
4898      * <code>optional string value = 2;</code>
4899      */
4900     boolean hasValue();
4901     /**
4902      * <code>optional string value = 2;</code>
4903      */
4904     java.lang.String getValue();
4905     /**
4906      * <code>optional string value = 2;</code>
4907      */
4908     com.google.protobuf.ByteString
4909         getValueBytes();
4910
4911     // optional bool event = 3;
4912     /**
4913      * <code>optional bool event = 3;</code>
4914      */
4915     boolean hasEvent();
4916     /**
4917      * <code>optional bool event = 3;</code>
4918      */
4919     boolean getEvent();
4920   }
4921   /**
4922    * Protobuf type {@code openxc.EventedBooleanMessage}
4923    */
4924   public static final class EventedBooleanMessage extends
4925       com.google.protobuf.GeneratedMessage
4926       implements EventedBooleanMessageOrBuilder {
4927     // Use EventedBooleanMessage.newBuilder() to construct.
4928     private EventedBooleanMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
4929       super(builder);
4930       this.unknownFields = builder.getUnknownFields();
4931     }
4932     private EventedBooleanMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
4933
4934     private static final EventedBooleanMessage defaultInstance;
4935     public static EventedBooleanMessage getDefaultInstance() {
4936       return defaultInstance;
4937     }
4938
4939     public EventedBooleanMessage getDefaultInstanceForType() {
4940       return defaultInstance;
4941     }
4942
4943     private final com.google.protobuf.UnknownFieldSet unknownFields;
4944     @java.lang.Override
4945     public final com.google.protobuf.UnknownFieldSet
4946         getUnknownFields() {
4947       return this.unknownFields;
4948     }
4949     private EventedBooleanMessage(
4950         com.google.protobuf.CodedInputStream input,
4951         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4952         throws com.google.protobuf.InvalidProtocolBufferException {
4953       initFields();
4954       int mutable_bitField0_ = 0;
4955       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
4956           com.google.protobuf.UnknownFieldSet.newBuilder();
4957       try {
4958         boolean done = false;
4959         while (!done) {
4960           int tag = input.readTag();
4961           switch (tag) {
4962             case 0:
4963               done = true;
4964               break;
4965             default: {
4966               if (!parseUnknownField(input, unknownFields,
4967                                      extensionRegistry, tag)) {
4968                 done = true;
4969               }
4970               break;
4971             }
4972             case 10: {
4973               bitField0_ |= 0x00000001;
4974               name_ = input.readBytes();
4975               break;
4976             }
4977             case 18: {
4978               bitField0_ |= 0x00000002;
4979               value_ = input.readBytes();
4980               break;
4981             }
4982             case 24: {
4983               bitField0_ |= 0x00000004;
4984               event_ = input.readBool();
4985               break;
4986             }
4987           }
4988         }
4989       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4990         throw e.setUnfinishedMessage(this);
4991       } catch (java.io.IOException e) {
4992         throw new com.google.protobuf.InvalidProtocolBufferException(
4993             e.getMessage()).setUnfinishedMessage(this);
4994       } finally {
4995         this.unknownFields = unknownFields.build();
4996         makeExtensionsImmutable();
4997       }
4998     }
4999     public static final com.google.protobuf.Descriptors.Descriptor
5000         getDescriptor() {
5001       return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_descriptor;
5002     }
5003
5004     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5005         internalGetFieldAccessorTable() {
5006       return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_fieldAccessorTable
5007           .ensureFieldAccessorsInitialized(
5008               com.openxc.BinaryMessages.EventedBooleanMessage.class, com.openxc.BinaryMessages.EventedBooleanMessage.Builder.class);
5009     }
5010
5011     public static com.google.protobuf.Parser<EventedBooleanMessage> PARSER =
5012         new com.google.protobuf.AbstractParser<EventedBooleanMessage>() {
5013       public EventedBooleanMessage parsePartialFrom(
5014           com.google.protobuf.CodedInputStream input,
5015           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5016           throws com.google.protobuf.InvalidProtocolBufferException {
5017         return new EventedBooleanMessage(input, extensionRegistry);
5018       }
5019     };
5020
5021     @java.lang.Override
5022     public com.google.protobuf.Parser<EventedBooleanMessage> getParserForType() {
5023       return PARSER;
5024     }
5025
5026     private int bitField0_;
5027     // optional string name = 1;
5028     public static final int NAME_FIELD_NUMBER = 1;
5029     private java.lang.Object name_;
5030     /**
5031      * <code>optional string name = 1;</code>
5032      */
5033     public boolean hasName() {
5034       return ((bitField0_ & 0x00000001) == 0x00000001);
5035     }
5036     /**
5037      * <code>optional string name = 1;</code>
5038      */
5039     public java.lang.String getName() {
5040       java.lang.Object ref = name_;
5041       if (ref instanceof java.lang.String) {
5042         return (java.lang.String) ref;
5043       } else {
5044         com.google.protobuf.ByteString bs =
5045             (com.google.protobuf.ByteString) ref;
5046         java.lang.String s = bs.toStringUtf8();
5047         if (bs.isValidUtf8()) {
5048           name_ = s;
5049         }
5050         return s;
5051       }
5052     }
5053     /**
5054      * <code>optional string name = 1;</code>
5055      */
5056     public com.google.protobuf.ByteString
5057         getNameBytes() {
5058       java.lang.Object ref = name_;
5059       if (ref instanceof java.lang.String) {
5060         com.google.protobuf.ByteString b =
5061             com.google.protobuf.ByteString.copyFromUtf8(
5062                 (java.lang.String) ref);
5063         name_ = b;
5064         return b;
5065       } else {
5066         return (com.google.protobuf.ByteString) ref;
5067       }
5068     }
5069
5070     // optional string value = 2;
5071     public static final int VALUE_FIELD_NUMBER = 2;
5072     private java.lang.Object value_;
5073     /**
5074      * <code>optional string value = 2;</code>
5075      */
5076     public boolean hasValue() {
5077       return ((bitField0_ & 0x00000002) == 0x00000002);
5078     }
5079     /**
5080      * <code>optional string value = 2;</code>
5081      */
5082     public java.lang.String getValue() {
5083       java.lang.Object ref = value_;
5084       if (ref instanceof java.lang.String) {
5085         return (java.lang.String) ref;
5086       } else {
5087         com.google.protobuf.ByteString bs =
5088             (com.google.protobuf.ByteString) ref;
5089         java.lang.String s = bs.toStringUtf8();
5090         if (bs.isValidUtf8()) {
5091           value_ = s;
5092         }
5093         return s;
5094       }
5095     }
5096     /**
5097      * <code>optional string value = 2;</code>
5098      */
5099     public com.google.protobuf.ByteString
5100         getValueBytes() {
5101       java.lang.Object ref = value_;
5102       if (ref instanceof java.lang.String) {
5103         com.google.protobuf.ByteString b =
5104             com.google.protobuf.ByteString.copyFromUtf8(
5105                 (java.lang.String) ref);
5106         value_ = b;
5107         return b;
5108       } else {
5109         return (com.google.protobuf.ByteString) ref;
5110       }
5111     }
5112
5113     // optional bool event = 3;
5114     public static final int EVENT_FIELD_NUMBER = 3;
5115     private boolean event_;
5116     /**
5117      * <code>optional bool event = 3;</code>
5118      */
5119     public boolean hasEvent() {
5120       return ((bitField0_ & 0x00000004) == 0x00000004);
5121     }
5122     /**
5123      * <code>optional bool event = 3;</code>
5124      */
5125     public boolean getEvent() {
5126       return event_;
5127     }
5128
5129     private void initFields() {
5130       name_ = "";
5131       value_ = "";
5132       event_ = false;
5133     }
5134     private byte memoizedIsInitialized = -1;
5135     public final boolean isInitialized() {
5136       byte isInitialized = memoizedIsInitialized;
5137       if (isInitialized != -1) return isInitialized == 1;
5138
5139       memoizedIsInitialized = 1;
5140       return true;
5141     }
5142
5143     public void writeTo(com.google.protobuf.CodedOutputStream output)
5144                         throws java.io.IOException {
5145       getSerializedSize();
5146       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5147         output.writeBytes(1, getNameBytes());
5148       }
5149       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5150         output.writeBytes(2, getValueBytes());
5151       }
5152       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5153         output.writeBool(3, event_);
5154       }
5155       getUnknownFields().writeTo(output);
5156     }
5157
5158     private int memoizedSerializedSize = -1;
5159     public int getSerializedSize() {
5160       int size = memoizedSerializedSize;
5161       if (size != -1) return size;
5162
5163       size = 0;
5164       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5165         size += com.google.protobuf.CodedOutputStream
5166           .computeBytesSize(1, getNameBytes());
5167       }
5168       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5169         size += com.google.protobuf.CodedOutputStream
5170           .computeBytesSize(2, getValueBytes());
5171       }
5172       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5173         size += com.google.protobuf.CodedOutputStream
5174           .computeBoolSize(3, event_);
5175       }
5176       size += getUnknownFields().getSerializedSize();
5177       memoizedSerializedSize = size;
5178       return size;
5179     }
5180
5181     private static final long serialVersionUID = 0L;
5182     @java.lang.Override
5183     protected java.lang.Object writeReplace()
5184         throws java.io.ObjectStreamException {
5185       return super.writeReplace();
5186     }
5187
5188     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5189         com.google.protobuf.ByteString data)
5190         throws com.google.protobuf.InvalidProtocolBufferException {
5191       return PARSER.parseFrom(data);
5192     }
5193     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5194         com.google.protobuf.ByteString data,
5195         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5196         throws com.google.protobuf.InvalidProtocolBufferException {
5197       return PARSER.parseFrom(data, extensionRegistry);
5198     }
5199     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(byte[] data)
5200         throws com.google.protobuf.InvalidProtocolBufferException {
5201       return PARSER.parseFrom(data);
5202     }
5203     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5204         byte[] data,
5205         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5206         throws com.google.protobuf.InvalidProtocolBufferException {
5207       return PARSER.parseFrom(data, extensionRegistry);
5208     }
5209     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(java.io.InputStream input)
5210         throws java.io.IOException {
5211       return PARSER.parseFrom(input);
5212     }
5213     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5214         java.io.InputStream input,
5215         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5216         throws java.io.IOException {
5217       return PARSER.parseFrom(input, extensionRegistry);
5218     }
5219     public static com.openxc.BinaryMessages.EventedBooleanMessage parseDelimitedFrom(java.io.InputStream input)
5220         throws java.io.IOException {
5221       return PARSER.parseDelimitedFrom(input);
5222     }
5223     public static com.openxc.BinaryMessages.EventedBooleanMessage parseDelimitedFrom(
5224         java.io.InputStream input,
5225         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5226         throws java.io.IOException {
5227       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5228     }
5229     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5230         com.google.protobuf.CodedInputStream input)
5231         throws java.io.IOException {
5232       return PARSER.parseFrom(input);
5233     }
5234     public static com.openxc.BinaryMessages.EventedBooleanMessage parseFrom(
5235         com.google.protobuf.CodedInputStream input,
5236         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5237         throws java.io.IOException {
5238       return PARSER.parseFrom(input, extensionRegistry);
5239     }
5240
5241     public static Builder newBuilder() { return Builder.create(); }
5242     public Builder newBuilderForType() { return newBuilder(); }
5243     public static Builder newBuilder(com.openxc.BinaryMessages.EventedBooleanMessage prototype) {
5244       return newBuilder().mergeFrom(prototype);
5245     }
5246     public Builder toBuilder() { return newBuilder(this); }
5247
5248     @java.lang.Override
5249     protected Builder newBuilderForType(
5250         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5251       Builder builder = new Builder(parent);
5252       return builder;
5253     }
5254     /**
5255      * Protobuf type {@code openxc.EventedBooleanMessage}
5256      */
5257     public static final class Builder extends
5258         com.google.protobuf.GeneratedMessage.Builder<Builder>
5259        implements com.openxc.BinaryMessages.EventedBooleanMessageOrBuilder {
5260       public static final com.google.protobuf.Descriptors.Descriptor
5261           getDescriptor() {
5262         return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_descriptor;
5263       }
5264
5265       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5266           internalGetFieldAccessorTable() {
5267         return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_fieldAccessorTable
5268             .ensureFieldAccessorsInitialized(
5269                 com.openxc.BinaryMessages.EventedBooleanMessage.class, com.openxc.BinaryMessages.EventedBooleanMessage.Builder.class);
5270       }
5271
5272       // Construct using com.openxc.BinaryMessages.EventedBooleanMessage.newBuilder()
5273       private Builder() {
5274         maybeForceBuilderInitialization();
5275       }
5276
5277       private Builder(
5278           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5279         super(parent);
5280         maybeForceBuilderInitialization();
5281       }
5282       private void maybeForceBuilderInitialization() {
5283         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5284         }
5285       }
5286       private static Builder create() {
5287         return new Builder();
5288       }
5289
5290       public Builder clear() {
5291         super.clear();
5292         name_ = "";
5293         bitField0_ = (bitField0_ & ~0x00000001);
5294         value_ = "";
5295         bitField0_ = (bitField0_ & ~0x00000002);
5296         event_ = false;
5297         bitField0_ = (bitField0_ & ~0x00000004);
5298         return this;
5299       }
5300
5301       public Builder clone() {
5302         return create().mergeFrom(buildPartial());
5303       }
5304
5305       public com.google.protobuf.Descriptors.Descriptor
5306           getDescriptorForType() {
5307         return com.openxc.BinaryMessages.internal_static_openxc_EventedBooleanMessage_descriptor;
5308       }
5309
5310       public com.openxc.BinaryMessages.EventedBooleanMessage getDefaultInstanceForType() {
5311         return com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance();
5312       }
5313
5314       public com.openxc.BinaryMessages.EventedBooleanMessage build() {
5315         com.openxc.BinaryMessages.EventedBooleanMessage result = buildPartial();
5316         if (!result.isInitialized()) {
5317           throw newUninitializedMessageException(result);
5318         }
5319         return result;
5320       }
5321
5322       public com.openxc.BinaryMessages.EventedBooleanMessage buildPartial() {
5323         com.openxc.BinaryMessages.EventedBooleanMessage result = new com.openxc.BinaryMessages.EventedBooleanMessage(this);
5324         int from_bitField0_ = bitField0_;
5325         int to_bitField0_ = 0;
5326         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
5327           to_bitField0_ |= 0x00000001;
5328         }
5329         result.name_ = name_;
5330         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
5331           to_bitField0_ |= 0x00000002;
5332         }
5333         result.value_ = value_;
5334         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
5335           to_bitField0_ |= 0x00000004;
5336         }
5337         result.event_ = event_;
5338         result.bitField0_ = to_bitField0_;
5339         onBuilt();
5340         return result;
5341       }
5342
5343       public Builder mergeFrom(com.google.protobuf.Message other) {
5344         if (other instanceof com.openxc.BinaryMessages.EventedBooleanMessage) {
5345           return mergeFrom((com.openxc.BinaryMessages.EventedBooleanMessage)other);
5346         } else {
5347           super.mergeFrom(other);
5348           return this;
5349         }
5350       }
5351
5352       public Builder mergeFrom(com.openxc.BinaryMessages.EventedBooleanMessage other) {
5353         if (other == com.openxc.BinaryMessages.EventedBooleanMessage.getDefaultInstance()) return this;
5354         if (other.hasName()) {
5355           bitField0_ |= 0x00000001;
5356           name_ = other.name_;
5357           onChanged();
5358         }
5359         if (other.hasValue()) {
5360           bitField0_ |= 0x00000002;
5361           value_ = other.value_;
5362           onChanged();
5363         }
5364         if (other.hasEvent()) {
5365           setEvent(other.getEvent());
5366         }
5367         this.mergeUnknownFields(other.getUnknownFields());
5368         return this;
5369       }
5370
5371       public final boolean isInitialized() {
5372         return true;
5373       }
5374
5375       public Builder mergeFrom(
5376           com.google.protobuf.CodedInputStream input,
5377           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5378           throws java.io.IOException {
5379         com.openxc.BinaryMessages.EventedBooleanMessage parsedMessage = null;
5380         try {
5381           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
5382         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5383           parsedMessage = (com.openxc.BinaryMessages.EventedBooleanMessage) e.getUnfinishedMessage();
5384           throw e;
5385         } finally {
5386           if (parsedMessage != null) {
5387             mergeFrom(parsedMessage);
5388           }
5389         }
5390         return this;
5391       }
5392       private int bitField0_;
5393
5394       // optional string name = 1;
5395       private java.lang.Object name_ = "";
5396       /**
5397        * <code>optional string name = 1;</code>
5398        */
5399       public boolean hasName() {
5400         return ((bitField0_ & 0x00000001) == 0x00000001);
5401       }
5402       /**
5403        * <code>optional string name = 1;</code>
5404        */
5405       public java.lang.String getName() {
5406         java.lang.Object ref = name_;
5407         if (!(ref instanceof java.lang.String)) {
5408           java.lang.String s = ((com.google.protobuf.ByteString) ref)
5409               .toStringUtf8();
5410           name_ = s;
5411           return s;
5412         } else {
5413           return (java.lang.String) ref;
5414         }
5415       }
5416       /**
5417        * <code>optional string name = 1;</code>
5418        */
5419       public com.google.protobuf.ByteString
5420           getNameBytes() {
5421         java.lang.Object ref = name_;
5422         if (ref instanceof String) {
5423           com.google.protobuf.ByteString b =
5424               com.google.protobuf.ByteString.copyFromUtf8(
5425                   (java.lang.String) ref);
5426           name_ = b;
5427           return b;
5428         } else {
5429           return (com.google.protobuf.ByteString) ref;
5430         }
5431       }
5432       /**
5433        * <code>optional string name = 1;</code>
5434        */
5435       public Builder setName(
5436           java.lang.String value) {
5437         if (value == null) {
5438     throw new NullPointerException();
5439   }
5440   bitField0_ |= 0x00000001;
5441         name_ = value;
5442         onChanged();
5443         return this;
5444       }
5445       /**
5446        * <code>optional string name = 1;</code>
5447        */
5448       public Builder clearName() {
5449         bitField0_ = (bitField0_ & ~0x00000001);
5450         name_ = getDefaultInstance().getName();
5451         onChanged();
5452         return this;
5453       }
5454       /**
5455        * <code>optional string name = 1;</code>
5456        */
5457       public Builder setNameBytes(
5458           com.google.protobuf.ByteString value) {
5459         if (value == null) {
5460     throw new NullPointerException();
5461   }
5462   bitField0_ |= 0x00000001;
5463         name_ = value;
5464         onChanged();
5465         return this;
5466       }
5467
5468       // optional string value = 2;
5469       private java.lang.Object value_ = "";
5470       /**
5471        * <code>optional string value = 2;</code>
5472        */
5473       public boolean hasValue() {
5474         return ((bitField0_ & 0x00000002) == 0x00000002);
5475       }
5476       /**
5477        * <code>optional string value = 2;</code>
5478        */
5479       public java.lang.String getValue() {
5480         java.lang.Object ref = value_;
5481         if (!(ref instanceof java.lang.String)) {
5482           java.lang.String s = ((com.google.protobuf.ByteString) ref)
5483               .toStringUtf8();
5484           value_ = s;
5485           return s;
5486         } else {
5487           return (java.lang.String) ref;
5488         }
5489       }
5490       /**
5491        * <code>optional string value = 2;</code>
5492        */
5493       public com.google.protobuf.ByteString
5494           getValueBytes() {
5495         java.lang.Object ref = value_;
5496         if (ref instanceof String) {
5497           com.google.protobuf.ByteString b =
5498               com.google.protobuf.ByteString.copyFromUtf8(
5499                   (java.lang.String) ref);
5500           value_ = b;
5501           return b;
5502         } else {
5503           return (com.google.protobuf.ByteString) ref;
5504         }
5505       }
5506       /**
5507        * <code>optional string value = 2;</code>
5508        */
5509       public Builder setValue(
5510           java.lang.String value) {
5511         if (value == null) {
5512     throw new NullPointerException();
5513   }
5514   bitField0_ |= 0x00000002;
5515         value_ = value;
5516         onChanged();
5517         return this;
5518       }
5519       /**
5520        * <code>optional string value = 2;</code>
5521        */
5522       public Builder clearValue() {
5523         bitField0_ = (bitField0_ & ~0x00000002);
5524         value_ = getDefaultInstance().getValue();
5525         onChanged();
5526         return this;
5527       }
5528       /**
5529        * <code>optional string value = 2;</code>
5530        */
5531       public Builder setValueBytes(
5532           com.google.protobuf.ByteString value) {
5533         if (value == null) {
5534     throw new NullPointerException();
5535   }
5536   bitField0_ |= 0x00000002;
5537         value_ = value;
5538         onChanged();
5539         return this;
5540       }
5541
5542       // optional bool event = 3;
5543       private boolean event_ ;
5544       /**
5545        * <code>optional bool event = 3;</code>
5546        */
5547       public boolean hasEvent() {
5548         return ((bitField0_ & 0x00000004) == 0x00000004);
5549       }
5550       /**
5551        * <code>optional bool event = 3;</code>
5552        */
5553       public boolean getEvent() {
5554         return event_;
5555       }
5556       /**
5557        * <code>optional bool event = 3;</code>
5558        */
5559       public Builder setEvent(boolean value) {
5560         bitField0_ |= 0x00000004;
5561         event_ = value;
5562         onChanged();
5563         return this;
5564       }
5565       /**
5566        * <code>optional bool event = 3;</code>
5567        */
5568       public Builder clearEvent() {
5569         bitField0_ = (bitField0_ & ~0x00000004);
5570         event_ = false;
5571         onChanged();
5572         return this;
5573       }
5574
5575       // @@protoc_insertion_point(builder_scope:openxc.EventedBooleanMessage)
5576     }
5577
5578     static {
5579       defaultInstance = new EventedBooleanMessage(true);
5580       defaultInstance.initFields();
5581     }
5582
5583     // @@protoc_insertion_point(class_scope:openxc.EventedBooleanMessage)
5584   }
5585
5586   public interface EventedNumericMessageOrBuilder
5587       extends com.google.protobuf.MessageOrBuilder {
5588
5589     // optional string name = 1;
5590     /**
5591      * <code>optional string name = 1;</code>
5592      */
5593     boolean hasName();
5594     /**
5595      * <code>optional string name = 1;</code>
5596      */
5597     java.lang.String getName();
5598     /**
5599      * <code>optional string name = 1;</code>
5600      */
5601     com.google.protobuf.ByteString
5602         getNameBytes();
5603
5604     // optional string value = 2;
5605     /**
5606      * <code>optional string value = 2;</code>
5607      */
5608     boolean hasValue();
5609     /**
5610      * <code>optional string value = 2;</code>
5611      */
5612     java.lang.String getValue();
5613     /**
5614      * <code>optional string value = 2;</code>
5615      */
5616     com.google.protobuf.ByteString
5617         getValueBytes();
5618
5619     // optional double event = 3;
5620     /**
5621      * <code>optional double event = 3;</code>
5622      */
5623     boolean hasEvent();
5624     /**
5625      * <code>optional double event = 3;</code>
5626      */
5627     double getEvent();
5628   }
5629   /**
5630    * Protobuf type {@code openxc.EventedNumericMessage}
5631    */
5632   public static final class EventedNumericMessage extends
5633       com.google.protobuf.GeneratedMessage
5634       implements EventedNumericMessageOrBuilder {
5635     // Use EventedNumericMessage.newBuilder() to construct.
5636     private EventedNumericMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
5637       super(builder);
5638       this.unknownFields = builder.getUnknownFields();
5639     }
5640     private EventedNumericMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
5641
5642     private static final EventedNumericMessage defaultInstance;
5643     public static EventedNumericMessage getDefaultInstance() {
5644       return defaultInstance;
5645     }
5646
5647     public EventedNumericMessage getDefaultInstanceForType() {
5648       return defaultInstance;
5649     }
5650
5651     private final com.google.protobuf.UnknownFieldSet unknownFields;
5652     @java.lang.Override
5653     public final com.google.protobuf.UnknownFieldSet
5654         getUnknownFields() {
5655       return this.unknownFields;
5656     }
5657     private EventedNumericMessage(
5658         com.google.protobuf.CodedInputStream input,
5659         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5660         throws com.google.protobuf.InvalidProtocolBufferException {
5661       initFields();
5662       int mutable_bitField0_ = 0;
5663       com.google.protobuf.UnknownFieldSet.Builder unknownFields =
5664           com.google.protobuf.UnknownFieldSet.newBuilder();
5665       try {
5666         boolean done = false;
5667         while (!done) {
5668           int tag = input.readTag();
5669           switch (tag) {
5670             case 0:
5671               done = true;
5672               break;
5673             default: {
5674               if (!parseUnknownField(input, unknownFields,
5675                                      extensionRegistry, tag)) {
5676                 done = true;
5677               }
5678               break;
5679             }
5680             case 10: {
5681               bitField0_ |= 0x00000001;
5682               name_ = input.readBytes();
5683               break;
5684             }
5685             case 18: {
5686               bitField0_ |= 0x00000002;
5687               value_ = input.readBytes();
5688               break;
5689             }
5690             case 25: {
5691               bitField0_ |= 0x00000004;
5692               event_ = input.readDouble();
5693               break;
5694             }
5695           }
5696         }
5697       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5698         throw e.setUnfinishedMessage(this);
5699       } catch (java.io.IOException e) {
5700         throw new com.google.protobuf.InvalidProtocolBufferException(
5701             e.getMessage()).setUnfinishedMessage(this);
5702       } finally {
5703         this.unknownFields = unknownFields.build();
5704         makeExtensionsImmutable();
5705       }
5706     }
5707     public static final com.google.protobuf.Descriptors.Descriptor
5708         getDescriptor() {
5709       return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_descriptor;
5710     }
5711
5712     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5713         internalGetFieldAccessorTable() {
5714       return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_fieldAccessorTable
5715           .ensureFieldAccessorsInitialized(
5716               com.openxc.BinaryMessages.EventedNumericMessage.class, com.openxc.BinaryMessages.EventedNumericMessage.Builder.class);
5717     }
5718
5719     public static com.google.protobuf.Parser<EventedNumericMessage> PARSER =
5720         new com.google.protobuf.AbstractParser<EventedNumericMessage>() {
5721       public EventedNumericMessage parsePartialFrom(
5722           com.google.protobuf.CodedInputStream input,
5723           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5724           throws com.google.protobuf.InvalidProtocolBufferException {
5725         return new EventedNumericMessage(input, extensionRegistry);
5726       }
5727     };
5728
5729     @java.lang.Override
5730     public com.google.protobuf.Parser<EventedNumericMessage> getParserForType() {
5731       return PARSER;
5732     }
5733
5734     private int bitField0_;
5735     // optional string name = 1;
5736     public static final int NAME_FIELD_NUMBER = 1;
5737     private java.lang.Object name_;
5738     /**
5739      * <code>optional string name = 1;</code>
5740      */
5741     public boolean hasName() {
5742       return ((bitField0_ & 0x00000001) == 0x00000001);
5743     }
5744     /**
5745      * <code>optional string name = 1;</code>
5746      */
5747     public java.lang.String getName() {
5748       java.lang.Object ref = name_;
5749       if (ref instanceof java.lang.String) {
5750         return (java.lang.String) ref;
5751       } else {
5752         com.google.protobuf.ByteString bs =
5753             (com.google.protobuf.ByteString) ref;
5754         java.lang.String s = bs.toStringUtf8();
5755         if (bs.isValidUtf8()) {
5756           name_ = s;
5757         }
5758         return s;
5759       }
5760     }
5761     /**
5762      * <code>optional string name = 1;</code>
5763      */
5764     public com.google.protobuf.ByteString
5765         getNameBytes() {
5766       java.lang.Object ref = name_;
5767       if (ref instanceof java.lang.String) {
5768         com.google.protobuf.ByteString b =
5769             com.google.protobuf.ByteString.copyFromUtf8(
5770                 (java.lang.String) ref);
5771         name_ = b;
5772         return b;
5773       } else {
5774         return (com.google.protobuf.ByteString) ref;
5775       }
5776     }
5777
5778     // optional string value = 2;
5779     public static final int VALUE_FIELD_NUMBER = 2;
5780     private java.lang.Object value_;
5781     /**
5782      * <code>optional string value = 2;</code>
5783      */
5784     public boolean hasValue() {
5785       return ((bitField0_ & 0x00000002) == 0x00000002);
5786     }
5787     /**
5788      * <code>optional string value = 2;</code>
5789      */
5790     public java.lang.String getValue() {
5791       java.lang.Object ref = value_;
5792       if (ref instanceof java.lang.String) {
5793         return (java.lang.String) ref;
5794       } else {
5795         com.google.protobuf.ByteString bs =
5796             (com.google.protobuf.ByteString) ref;
5797         java.lang.String s = bs.toStringUtf8();
5798         if (bs.isValidUtf8()) {
5799           value_ = s;
5800         }
5801         return s;
5802       }
5803     }
5804     /**
5805      * <code>optional string value = 2;</code>
5806      */
5807     public com.google.protobuf.ByteString
5808         getValueBytes() {
5809       java.lang.Object ref = value_;
5810       if (ref instanceof java.lang.String) {
5811         com.google.protobuf.ByteString b =
5812             com.google.protobuf.ByteString.copyFromUtf8(
5813                 (java.lang.String) ref);
5814         value_ = b;
5815         return b;
5816       } else {
5817         return (com.google.protobuf.ByteString) ref;
5818       }
5819     }
5820
5821     // optional double event = 3;
5822     public static final int EVENT_FIELD_NUMBER = 3;
5823     private double event_;
5824     /**
5825      * <code>optional double event = 3;</code>
5826      */
5827     public boolean hasEvent() {
5828       return ((bitField0_ & 0x00000004) == 0x00000004);
5829     }
5830     /**
5831      * <code>optional double event = 3;</code>
5832      */
5833     public double getEvent() {
5834       return event_;
5835     }
5836
5837     private void initFields() {
5838       name_ = "";
5839       value_ = "";
5840       event_ = 0D;
5841     }
5842     private byte memoizedIsInitialized = -1;
5843     public final boolean isInitialized() {
5844       byte isInitialized = memoizedIsInitialized;
5845       if (isInitialized != -1) return isInitialized == 1;
5846
5847       memoizedIsInitialized = 1;
5848       return true;
5849     }
5850
5851     public void writeTo(com.google.protobuf.CodedOutputStream output)
5852                         throws java.io.IOException {
5853       getSerializedSize();
5854       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5855         output.writeBytes(1, getNameBytes());
5856       }
5857       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5858         output.writeBytes(2, getValueBytes());
5859       }
5860       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5861         output.writeDouble(3, event_);
5862       }
5863       getUnknownFields().writeTo(output);
5864     }
5865
5866     private int memoizedSerializedSize = -1;
5867     public int getSerializedSize() {
5868       int size = memoizedSerializedSize;
5869       if (size != -1) return size;
5870
5871       size = 0;
5872       if (((bitField0_ & 0x00000001) == 0x00000001)) {
5873         size += com.google.protobuf.CodedOutputStream
5874           .computeBytesSize(1, getNameBytes());
5875       }
5876       if (((bitField0_ & 0x00000002) == 0x00000002)) {
5877         size += com.google.protobuf.CodedOutputStream
5878           .computeBytesSize(2, getValueBytes());
5879       }
5880       if (((bitField0_ & 0x00000004) == 0x00000004)) {
5881         size += com.google.protobuf.CodedOutputStream
5882           .computeDoubleSize(3, event_);
5883       }
5884       size += getUnknownFields().getSerializedSize();
5885       memoizedSerializedSize = size;
5886       return size;
5887     }
5888
5889     private static final long serialVersionUID = 0L;
5890     @java.lang.Override
5891     protected java.lang.Object writeReplace()
5892         throws java.io.ObjectStreamException {
5893       return super.writeReplace();
5894     }
5895
5896     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5897         com.google.protobuf.ByteString data)
5898         throws com.google.protobuf.InvalidProtocolBufferException {
5899       return PARSER.parseFrom(data);
5900     }
5901     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5902         com.google.protobuf.ByteString data,
5903         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5904         throws com.google.protobuf.InvalidProtocolBufferException {
5905       return PARSER.parseFrom(data, extensionRegistry);
5906     }
5907     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(byte[] data)
5908         throws com.google.protobuf.InvalidProtocolBufferException {
5909       return PARSER.parseFrom(data);
5910     }
5911     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5912         byte[] data,
5913         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5914         throws com.google.protobuf.InvalidProtocolBufferException {
5915       return PARSER.parseFrom(data, extensionRegistry);
5916     }
5917     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(java.io.InputStream input)
5918         throws java.io.IOException {
5919       return PARSER.parseFrom(input);
5920     }
5921     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5922         java.io.InputStream input,
5923         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5924         throws java.io.IOException {
5925       return PARSER.parseFrom(input, extensionRegistry);
5926     }
5927     public static com.openxc.BinaryMessages.EventedNumericMessage parseDelimitedFrom(java.io.InputStream input)
5928         throws java.io.IOException {
5929       return PARSER.parseDelimitedFrom(input);
5930     }
5931     public static com.openxc.BinaryMessages.EventedNumericMessage parseDelimitedFrom(
5932         java.io.InputStream input,
5933         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5934         throws java.io.IOException {
5935       return PARSER.parseDelimitedFrom(input, extensionRegistry);
5936     }
5937     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5938         com.google.protobuf.CodedInputStream input)
5939         throws java.io.IOException {
5940       return PARSER.parseFrom(input);
5941     }
5942     public static com.openxc.BinaryMessages.EventedNumericMessage parseFrom(
5943         com.google.protobuf.CodedInputStream input,
5944         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
5945         throws java.io.IOException {
5946       return PARSER.parseFrom(input, extensionRegistry);
5947     }
5948
5949     public static Builder newBuilder() { return Builder.create(); }
5950     public Builder newBuilderForType() { return newBuilder(); }
5951     public static Builder newBuilder(com.openxc.BinaryMessages.EventedNumericMessage prototype) {
5952       return newBuilder().mergeFrom(prototype);
5953     }
5954     public Builder toBuilder() { return newBuilder(this); }
5955
5956     @java.lang.Override
5957     protected Builder newBuilderForType(
5958         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5959       Builder builder = new Builder(parent);
5960       return builder;
5961     }
5962     /**
5963      * Protobuf type {@code openxc.EventedNumericMessage}
5964      */
5965     public static final class Builder extends
5966         com.google.protobuf.GeneratedMessage.Builder<Builder>
5967        implements com.openxc.BinaryMessages.EventedNumericMessageOrBuilder {
5968       public static final com.google.protobuf.Descriptors.Descriptor
5969           getDescriptor() {
5970         return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_descriptor;
5971       }
5972
5973       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
5974           internalGetFieldAccessorTable() {
5975         return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_fieldAccessorTable
5976             .ensureFieldAccessorsInitialized(
5977                 com.openxc.BinaryMessages.EventedNumericMessage.class, com.openxc.BinaryMessages.EventedNumericMessage.Builder.class);
5978       }
5979
5980       // Construct using com.openxc.BinaryMessages.EventedNumericMessage.newBuilder()
5981       private Builder() {
5982         maybeForceBuilderInitialization();
5983       }
5984
5985       private Builder(
5986           com.google.protobuf.GeneratedMessage.BuilderParent parent) {
5987         super(parent);
5988         maybeForceBuilderInitialization();
5989       }
5990       private void maybeForceBuilderInitialization() {
5991         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
5992         }
5993       }
5994       private static Builder create() {
5995         return new Builder();
5996       }
5997
5998       public Builder clear() {
5999         super.clear();
6000         name_ = "";
6001         bitField0_ = (bitField0_ & ~0x00000001);
6002         value_ = "";
6003         bitField0_ = (bitField0_ & ~0x00000002);
6004         event_ = 0D;
6005         bitField0_ = (bitField0_ & ~0x00000004);
6006         return this;
6007       }
6008
6009       public Builder clone() {
6010         return create().mergeFrom(buildPartial());
6011       }
6012
6013       public com.google.protobuf.Descriptors.Descriptor
6014           getDescriptorForType() {
6015         return com.openxc.BinaryMessages.internal_static_openxc_EventedNumericMessage_descriptor;
6016       }
6017
6018       public com.openxc.BinaryMessages.EventedNumericMessage getDefaultInstanceForType() {
6019         return com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance();
6020       }
6021
6022       public com.openxc.BinaryMessages.EventedNumericMessage build() {
6023         com.openxc.BinaryMessages.EventedNumericMessage result = buildPartial();
6024         if (!result.isInitialized()) {
6025           throw newUninitializedMessageException(result);
6026         }
6027         return result;
6028       }
6029
6030       public com.openxc.BinaryMessages.EventedNumericMessage buildPartial() {
6031         com.openxc.BinaryMessages.EventedNumericMessage result = new com.openxc.BinaryMessages.EventedNumericMessage(this);
6032         int from_bitField0_ = bitField0_;
6033         int to_bitField0_ = 0;
6034         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
6035           to_bitField0_ |= 0x00000001;
6036         }
6037         result.name_ = name_;
6038         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
6039           to_bitField0_ |= 0x00000002;
6040         }
6041         result.value_ = value_;
6042         if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
6043           to_bitField0_ |= 0x00000004;
6044         }
6045         result.event_ = event_;
6046         result.bitField0_ = to_bitField0_;
6047         onBuilt();
6048         return result;
6049       }
6050
6051       public Builder mergeFrom(com.google.protobuf.Message other) {
6052         if (other instanceof com.openxc.BinaryMessages.EventedNumericMessage) {
6053           return mergeFrom((com.openxc.BinaryMessages.EventedNumericMessage)other);
6054         } else {
6055           super.mergeFrom(other);
6056           return this;
6057         }
6058       }
6059
6060       public Builder mergeFrom(com.openxc.BinaryMessages.EventedNumericMessage other) {
6061         if (other == com.openxc.BinaryMessages.EventedNumericMessage.getDefaultInstance()) return this;
6062         if (other.hasName()) {
6063           bitField0_ |= 0x00000001;
6064           name_ = other.name_;
6065           onChanged();
6066         }
6067         if (other.hasValue()) {
6068           bitField0_ |= 0x00000002;
6069           value_ = other.value_;
6070           onChanged();
6071         }
6072         if (other.hasEvent()) {
6073           setEvent(other.getEvent());
6074         }
6075         this.mergeUnknownFields(other.getUnknownFields());
6076         return this;
6077       }
6078
6079       public final boolean isInitialized() {
6080         return true;
6081       }
6082
6083       public Builder mergeFrom(
6084           com.google.protobuf.CodedInputStream input,
6085           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
6086           throws java.io.IOException {
6087         com.openxc.BinaryMessages.EventedNumericMessage parsedMessage = null;
6088         try {
6089           parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
6090         } catch (com.google.protobuf.InvalidProtocolBufferException e) {
6091           parsedMessage = (com.openxc.BinaryMessages.EventedNumericMessage) e.getUnfinishedMessage();
6092           throw e;
6093         } finally {
6094           if (parsedMessage != null) {
6095             mergeFrom(parsedMessage);
6096           }
6097         }
6098         return this;
6099       }
6100       private int bitField0_;
6101
6102       // optional string name = 1;
6103       private java.lang.Object name_ = "";
6104       /**
6105        * <code>optional string name = 1;</code>
6106        */
6107       public boolean hasName() {
6108         return ((bitField0_ & 0x00000001) == 0x00000001);
6109       }
6110       /**
6111        * <code>optional string name = 1;</code>
6112        */
6113       public java.lang.String getName() {
6114         java.lang.Object ref = name_;
6115         if (!(ref instanceof java.lang.String)) {
6116           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6117               .toStringUtf8();
6118           name_ = s;
6119           return s;
6120         } else {
6121           return (java.lang.String) ref;
6122         }
6123       }
6124       /**
6125        * <code>optional string name = 1;</code>
6126        */
6127       public com.google.protobuf.ByteString
6128           getNameBytes() {
6129         java.lang.Object ref = name_;
6130         if (ref instanceof String) {
6131           com.google.protobuf.ByteString b =
6132               com.google.protobuf.ByteString.copyFromUtf8(
6133                   (java.lang.String) ref);
6134           name_ = b;
6135           return b;
6136         } else {
6137           return (com.google.protobuf.ByteString) ref;
6138         }
6139       }
6140       /**
6141        * <code>optional string name = 1;</code>
6142        */
6143       public Builder setName(
6144           java.lang.String value) {
6145         if (value == null) {
6146     throw new NullPointerException();
6147   }
6148   bitField0_ |= 0x00000001;
6149         name_ = value;
6150         onChanged();
6151         return this;
6152       }
6153       /**
6154        * <code>optional string name = 1;</code>
6155        */
6156       public Builder clearName() {
6157         bitField0_ = (bitField0_ & ~0x00000001);
6158         name_ = getDefaultInstance().getName();
6159         onChanged();
6160         return this;
6161       }
6162       /**
6163        * <code>optional string name = 1;</code>
6164        */
6165       public Builder setNameBytes(
6166           com.google.protobuf.ByteString value) {
6167         if (value == null) {
6168     throw new NullPointerException();
6169   }
6170   bitField0_ |= 0x00000001;
6171         name_ = value;
6172         onChanged();
6173         return this;
6174       }
6175
6176       // optional string value = 2;
6177       private java.lang.Object value_ = "";
6178       /**
6179        * <code>optional string value = 2;</code>
6180        */
6181       public boolean hasValue() {
6182         return ((bitField0_ & 0x00000002) == 0x00000002);
6183       }
6184       /**
6185        * <code>optional string value = 2;</code>
6186        */
6187       public java.lang.String getValue() {
6188         java.lang.Object ref = value_;
6189         if (!(ref instanceof java.lang.String)) {
6190           java.lang.String s = ((com.google.protobuf.ByteString) ref)
6191               .toStringUtf8();
6192           value_ = s;
6193           return s;
6194         } else {
6195           return (java.lang.String) ref;
6196         }
6197       }
6198       /**
6199        * <code>optional string value = 2;</code>
6200        */
6201       public com.google.protobuf.ByteString
6202           getValueBytes() {
6203         java.lang.Object ref = value_;
6204         if (ref instanceof String) {
6205           com.google.protobuf.ByteString b =
6206               com.google.protobuf.ByteString.copyFromUtf8(
6207                   (java.lang.String) ref);
6208           value_ = b;
6209           return b;
6210         } else {
6211           return (com.google.protobuf.ByteString) ref;
6212         }
6213       }
6214       /**
6215        * <code>optional string value = 2;</code>
6216        */
6217       public Builder setValue(
6218           java.lang.String value) {
6219         if (value == null) {
6220     throw new NullPointerException();
6221   }
6222   bitField0_ |= 0x00000002;
6223         value_ = value;
6224         onChanged();
6225         return this;
6226       }
6227       /**
6228        * <code>optional string value = 2;</code>
6229        */
6230       public Builder clearValue() {
6231         bitField0_ = (bitField0_ & ~0x00000002);
6232         value_ = getDefaultInstance().getValue();
6233         onChanged();
6234         return this;
6235       }
6236       /**
6237        * <code>optional string value = 2;</code>
6238        */
6239       public Builder setValueBytes(
6240           com.google.protobuf.ByteString value) {
6241         if (value == null) {
6242     throw new NullPointerException();
6243   }
6244   bitField0_ |= 0x00000002;
6245         value_ = value;
6246         onChanged();
6247         return this;
6248       }
6249
6250       // optional double event = 3;
6251       private double event_ ;
6252       /**
6253        * <code>optional double event = 3;</code>
6254        */
6255       public boolean hasEvent() {
6256         return ((bitField0_ & 0x00000004) == 0x00000004);
6257       }
6258       /**
6259        * <code>optional double event = 3;</code>
6260        */
6261       public double getEvent() {
6262         return event_;
6263       }
6264       /**
6265        * <code>optional double event = 3;</code>
6266        */
6267       public Builder setEvent(double value) {
6268         bitField0_ |= 0x00000004;
6269         event_ = value;
6270         onChanged();
6271         return this;
6272       }
6273       /**
6274        * <code>optional double event = 3;</code>
6275        */
6276       public Builder clearEvent() {
6277         bitField0_ = (bitField0_ & ~0x00000004);
6278         event_ = 0D;
6279         onChanged();
6280         return this;
6281       }
6282
6283       // @@protoc_insertion_point(builder_scope:openxc.EventedNumericMessage)
6284     }
6285
6286     static {
6287       defaultInstance = new EventedNumericMessage(true);
6288       defaultInstance.initFields();
6289     }
6290
6291     // @@protoc_insertion_point(class_scope:openxc.EventedNumericMessage)
6292   }
6293
6294   private static com.google.protobuf.Descriptors.Descriptor
6295     internal_static_openxc_VehicleMessage_descriptor;
6296   private static
6297     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6298       internal_static_openxc_VehicleMessage_fieldAccessorTable;
6299   private static com.google.protobuf.Descriptors.Descriptor
6300     internal_static_openxc_RawMessage_descriptor;
6301   private static
6302     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6303       internal_static_openxc_RawMessage_fieldAccessorTable;
6304   private static com.google.protobuf.Descriptors.Descriptor
6305     internal_static_openxc_StringMessage_descriptor;
6306   private static
6307     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6308       internal_static_openxc_StringMessage_fieldAccessorTable;
6309   private static com.google.protobuf.Descriptors.Descriptor
6310     internal_static_openxc_NumericMessage_descriptor;
6311   private static
6312     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6313       internal_static_openxc_NumericMessage_fieldAccessorTable;
6314   private static com.google.protobuf.Descriptors.Descriptor
6315     internal_static_openxc_BooleanMessage_descriptor;
6316   private static
6317     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6318       internal_static_openxc_BooleanMessage_fieldAccessorTable;
6319   private static com.google.protobuf.Descriptors.Descriptor
6320     internal_static_openxc_EventedStringMessage_descriptor;
6321   private static
6322     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6323       internal_static_openxc_EventedStringMessage_fieldAccessorTable;
6324   private static com.google.protobuf.Descriptors.Descriptor
6325     internal_static_openxc_EventedBooleanMessage_descriptor;
6326   private static
6327     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6328       internal_static_openxc_EventedBooleanMessage_fieldAccessorTable;
6329   private static com.google.protobuf.Descriptors.Descriptor
6330     internal_static_openxc_EventedNumericMessage_descriptor;
6331   private static
6332     com.google.protobuf.GeneratedMessage.FieldAccessorTable
6333       internal_static_openxc_EventedNumericMessage_fieldAccessorTable;
6334
6335   public static com.google.protobuf.Descriptors.FileDescriptor
6336       getDescriptor() {
6337     return descriptor;
6338   }
6339   private static com.google.protobuf.Descriptors.FileDescriptor
6340       descriptor;
6341   static {
6342     java.lang.String[] descriptorData = {
6343       "\n\014openxc.proto\022\006openxc\"\232\004\n\016VehicleMessag" +
6344       "e\022)\n\004type\030\001 \001(\0162\033.openxc.VehicleMessage." +
6345       "Type\022\'\n\013raw_message\030\002 \001(\0132\022.openxc.RawMe" +
6346       "ssage\022-\n\016string_message\030\003 \001(\0132\025.openxc.S" +
6347       "tringMessage\022/\n\017numeric_message\030\004 \001(\0132\026." +
6348       "openxc.NumericMessage\022/\n\017boolean_message" +
6349       "\030\005 \001(\0132\026.openxc.BooleanMessage\022<\n\026evente" +
6350       "d_string_message\030\006 \001(\0132\034.openxc.EventedS" +
6351       "tringMessage\022>\n\027evented_boolean_message\030" +
6352       "\007 \001(\0132\035.openxc.EventedBooleanMessage\022>\n\027",
6353       "evented_numeric_message\030\010 \001(\0132\035.openxc.E" +
6354       "ventedNumericMessage\"e\n\004Type\022\007\n\003RAW\020\001\022\n\n" +
6355       "\006STRING\020\002\022\010\n\004BOOL\020\003\022\007\n\003NUM\020\004\022\017\n\013EVENTED_" +
6356       "NUM\020\005\022\022\n\016EVENTED_STRING\020\006\022\020\n\014EVENTED_BOO" +
6357       "L\020\007\"-\n\nRawMessage\022\013\n\003bus\030\001 \001(\005\022\022\n\nmessag" +
6358       "e_id\030\002 \001(\r\",\n\rStringMessage\022\014\n\004name\030\001 \001(" +
6359       "\t\022\r\n\005value\030\002 \001(\t\"-\n\016NumericMessage\022\014\n\004na" +
6360       "me\030\001 \001(\t\022\r\n\005value\030\002 \001(\001\"-\n\016BooleanMessag" +
6361       "e\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\010\"B\n\024Evente" +
6362       "dStringMessage\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 ",
6363       "\001(\t\022\r\n\005event\030\003 \001(\t\"C\n\025EventedBooleanMess" +
6364       "age\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\022\r\n\005even" +
6365       "t\030\003 \001(\010\"C\n\025EventedNumericMessage\022\014\n\004name" +
6366       "\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\022\r\n\005event\030\003 \001(\001B\034\n\n" +
6367       "com.openxcB\016BinaryMessages"
6368     };
6369     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
6370       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
6371         public com.google.protobuf.ExtensionRegistry assignDescriptors(
6372             com.google.protobuf.Descriptors.FileDescriptor root) {
6373           descriptor = root;
6374           internal_static_openxc_VehicleMessage_descriptor =
6375             getDescriptor().getMessageTypes().get(0);
6376           internal_static_openxc_VehicleMessage_fieldAccessorTable = new
6377             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6378               internal_static_openxc_VehicleMessage_descriptor,
6379               new java.lang.String[] { "Type", "RawMessage", "StringMessage", "NumericMessage", "BooleanMessage", "EventedStringMessage", "EventedBooleanMessage", "EventedNumericMessage", });
6380           internal_static_openxc_RawMessage_descriptor =
6381             getDescriptor().getMessageTypes().get(1);
6382           internal_static_openxc_RawMessage_fieldAccessorTable = new
6383             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6384               internal_static_openxc_RawMessage_descriptor,
6385               new java.lang.String[] { "Bus", "MessageId", });
6386           internal_static_openxc_StringMessage_descriptor =
6387             getDescriptor().getMessageTypes().get(2);
6388           internal_static_openxc_StringMessage_fieldAccessorTable = new
6389             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6390               internal_static_openxc_StringMessage_descriptor,
6391               new java.lang.String[] { "Name", "Value", });
6392           internal_static_openxc_NumericMessage_descriptor =
6393             getDescriptor().getMessageTypes().get(3);
6394           internal_static_openxc_NumericMessage_fieldAccessorTable = new
6395             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6396               internal_static_openxc_NumericMessage_descriptor,
6397               new java.lang.String[] { "Name", "Value", });
6398           internal_static_openxc_BooleanMessage_descriptor =
6399             getDescriptor().getMessageTypes().get(4);
6400           internal_static_openxc_BooleanMessage_fieldAccessorTable = new
6401             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6402               internal_static_openxc_BooleanMessage_descriptor,
6403               new java.lang.String[] { "Name", "Value", });
6404           internal_static_openxc_EventedStringMessage_descriptor =
6405             getDescriptor().getMessageTypes().get(5);
6406           internal_static_openxc_EventedStringMessage_fieldAccessorTable = new
6407             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6408               internal_static_openxc_EventedStringMessage_descriptor,
6409               new java.lang.String[] { "Name", "Value", "Event", });
6410           internal_static_openxc_EventedBooleanMessage_descriptor =
6411             getDescriptor().getMessageTypes().get(6);
6412           internal_static_openxc_EventedBooleanMessage_fieldAccessorTable = new
6413             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6414               internal_static_openxc_EventedBooleanMessage_descriptor,
6415               new java.lang.String[] { "Name", "Value", "Event", });
6416           internal_static_openxc_EventedNumericMessage_descriptor =
6417             getDescriptor().getMessageTypes().get(7);
6418           internal_static_openxc_EventedNumericMessage_fieldAccessorTable = new
6419             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
6420               internal_static_openxc_EventedNumericMessage_descriptor,
6421               new java.lang.String[] { "Name", "Value", "Event", });
6422           return null;
6423         }
6424       };
6425     com.google.protobuf.Descriptors.FileDescriptor
6426       .internalBuildGeneratedFileFrom(descriptorData,
6427         new com.google.protobuf.Descriptors.FileDescriptor[] {
6428         }, assigner);
6429   }
6430
6431   // @@protoc_insertion_point(outer_class_scope)
6432 }